1395 lines
56 KiB
EmacsLisp
1395 lines
56 KiB
EmacsLisp
;;; powershell.el --- Mode for editing PowerShell scripts -*- lexical-binding: t; -*-
|
||
|
||
;; Copyright (C) 2009, 2010 Frédéric Perrin
|
||
;; Copyright (C) 2012 Richard Bielawski rbielaws-at-i1-dot-net
|
||
;; http://www.emacswiki.org/emacs/Rick_Bielawski
|
||
|
||
;; Author: Frédéric Perrin <frederic (dot) perrin (arobas) resel (dot) fr>
|
||
;; URL: http://github.com/jschaf/powershell.el
|
||
;; Package-Version: 20220402.643
|
||
;; Package-Commit: 77b27faf8a292f1dc9f54c872241dc53b6791bf1
|
||
;; Version: 0.3
|
||
;; Package-Requires: ((emacs "24"))
|
||
;; Keywords: powershell, languages
|
||
|
||
;; This file is NOT part of GNU Emacs.
|
||
|
||
;; This file 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/>.
|
||
|
||
;;; Installation:
|
||
|
||
;; Place powershell.el on your `load-path' by adding the following
|
||
;; code to your `user-init-file', which is usually ~/.emacs.d/init.el
|
||
;; or ~/.emacs.
|
||
;;
|
||
;; (add-to-list 'load-path "~/path/to/powershell")
|
||
;;
|
||
|
||
;;; Commentary:
|
||
|
||
;; powershell.el is a combination of powershell.el by Dino Chiesa
|
||
;; <dpchiesa@hotmail.com> and powershell-mode.el by Frédéric Perrin
|
||
;; and Richard Bielawski. Joe Schafer combined the work into a single
|
||
;; file.
|
||
|
||
;;; Frédéric Perrin Comments:
|
||
;;
|
||
;; The original powershell-mode.el was written from scratch, without
|
||
;; using Vivek Sharma's code: it had issues I wanted to correct, but
|
||
;; unfortunately there were no licence indication, and Vivek didn't
|
||
;; answered my mails.
|
||
;;
|
||
;;; Rick Bielawski Comments 2012/09/28:
|
||
;;
|
||
;; On March 31, 2012 Frédéric gave me permission to take over support
|
||
;; for powershell-mode.el. I've added support for multi-line comments
|
||
;; and here-strings as well as enhancement/features such as: Functions
|
||
;; to quote, unquote and escape a selection, and one to wrap a
|
||
;; selection in $(). Meanwhile I hope I didn't break anything.
|
||
;;
|
||
;; Joe Schafer Comments 2013-06-06:
|
||
;;
|
||
;; I combined powershell.el and powershell-mode.el. Since
|
||
;; powershell.el was licensed with the new BSD license I combined the
|
||
;; two files using the more restrictive license, the GPL. I also
|
||
;; cleaned up the documentation and reorganized some of the code.
|
||
|
||
;;; Updates:
|
||
|
||
;; 2012/10/01 Fixed several bugs in highlighting variables and types.
|
||
;; Renamed some variables to be more descriptive.
|
||
;; 2012/10/02 Enhanced PowerShell-mode indenting & syntax table.
|
||
;; Fixed dangling parens and re-indented the elisp itself.
|
||
;; 2012/10/05 Added eldoc support. Fixed bug where indent could loop.
|
||
;; See comment below on how to generate powershell-eldoc.el
|
||
;; 2013/06/06 Merged powershell.el and powershell-mode.el
|
||
|
||
;;; Code:
|
||
|
||
(eval-when-compile (require 'thingatpt))
|
||
(require 'shell)
|
||
(require 'compile)
|
||
|
||
;;;###autoload
|
||
(add-to-list 'auto-mode-alist '("\\.ps[dm]?1\\'" . powershell-mode))
|
||
|
||
|
||
;; User Variables
|
||
|
||
(defgroup powershell nil
|
||
"Customization of PowerShell mode."
|
||
:link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces)
|
||
:group 'languages)
|
||
|
||
(defcustom powershell-indent 4
|
||
"Amount of horizontal space to indent.
|
||
After, for instance, an opening brace"
|
||
:type 'integer
|
||
:group 'powershell)
|
||
|
||
(defcustom powershell-continuation-indent 2
|
||
"Amount of horizontal space to indent a continuation line."
|
||
:type 'integer
|
||
:group 'powershell)
|
||
|
||
(defcustom powershell-continued-regexp ".*\\(|[\\t ]*\\|`\\)$"
|
||
"Regexp matching a continued line.
|
||
Ending either with an explicit backtick, or with a pipe."
|
||
:type 'integer
|
||
:group 'powershell)
|
||
|
||
;; Note: There are no explicit references to the variable
|
||
;; `explicit-powershell.exe-args'. It is used implicitly by M-x shell
|
||
;; when the shell is `powershell.exe'. See
|
||
;; http://blogs.msdn.com/b/dotnetinterop/archive/2008/04/10/run-powershell-as-a-shell-within-emacs.aspx
|
||
;; for details.
|
||
(defcustom explicit-powershell.exe-args '("-Command" "-" )
|
||
"Args passed to inferior shell by \\[shell], if the shell is powershell.exe.
|
||
Value is a list of strings, which may be nil."
|
||
:type '(repeat (string :tag "Argument"))
|
||
:group 'powershell)
|
||
|
||
(defun powershell-continuation-line-p ()
|
||
"Return t is the current line is a continuation line.
|
||
The current line is a continued line when the previous line ends
|
||
with a backtick or a pipe"
|
||
(interactive)
|
||
(save-excursion
|
||
(forward-line -1)
|
||
(looking-at powershell-continued-regexp)))
|
||
|
||
;; Rick added significant complexity to Frédéric's original version
|
||
(defun powershell-indent-line-amount ()
|
||
"Return the column to which the current line ought to be indented."
|
||
(interactive)
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(if (powershell-continuation-line-p)
|
||
;; on a continuation line (i.e. prior line ends with backtick
|
||
;; or pipe), indent relative to the continued line.
|
||
(progn
|
||
(while (and (not (bobp))(powershell-continuation-line-p))
|
||
(forward-line -1))
|
||
(+ (current-indentation) powershell-continuation-indent))
|
||
;; otherwise, indent relative to the block's opening char ([{
|
||
;; \\s- includes newline, which make the line right before closing paren not indented
|
||
(let ((closing-paren (looking-at "[ \t]*\\s)"))
|
||
new-indent
|
||
block-open-line)
|
||
(condition-case nil
|
||
(progn
|
||
(backward-up-list) ;when at top level, throw to no-indent
|
||
(setq block-open-line (line-number-at-pos))
|
||
;; We're in a block, calculate/return indent amount.
|
||
(if (not (looking-at "\\s(\\s-*\\(#.*\\)?$"))
|
||
;; code (not comments) follow the block open so
|
||
;; vertically align the block with the code.
|
||
(if closing-paren
|
||
;; closing indent = open
|
||
(setq new-indent (current-column))
|
||
;; block indent = first line of code
|
||
(forward-char)
|
||
(skip-syntax-forward " ")
|
||
(setq new-indent (current-column)))
|
||
;; otherwise block open is at eol so indent is relative to
|
||
;; bol or another block open on the same line.
|
||
(if closing-paren ; this sets the default indent
|
||
(setq new-indent (current-indentation))
|
||
(setq new-indent (+ powershell-indent (current-indentation))))
|
||
;; now see if the block is nested on the same line
|
||
(when (condition-case nil
|
||
(progn
|
||
(backward-up-list)
|
||
(= block-open-line (line-number-at-pos)))
|
||
(scan-error nil))
|
||
(forward-char)
|
||
(skip-syntax-forward " ")
|
||
(if closing-paren
|
||
(setq new-indent (current-column))
|
||
(setq new-indent (+ powershell-indent (current-column))))))
|
||
new-indent)
|
||
(scan-error ;; most likely, we are at the top-level
|
||
0))))))
|
||
|
||
(defun powershell-indent-line ()
|
||
"Indent the current line of powershell mode.
|
||
Leave the point in place if it is inside the meat of the line"
|
||
(interactive)
|
||
(let ((savep (> (current-column) (current-indentation)))
|
||
(amount (powershell-indent-line-amount)))
|
||
(if savep
|
||
(save-excursion (indent-line-to amount))
|
||
(indent-line-to amount))))
|
||
|
||
(defun powershell-quote-selection (beg end)
|
||
"Quotes the selection between BEG and END.
|
||
Quotes with single quotes and doubles embedded single quotes."
|
||
(interactive `(,(region-beginning) ,(region-end)))
|
||
(if (not mark-active)
|
||
(error "Command requires a marked region"))
|
||
(goto-char beg)
|
||
(while (re-search-forward "'" end t)
|
||
(replace-match "''")(setq end (1+ end)))
|
||
(goto-char beg)
|
||
(insert "'")
|
||
(setq end (1+ end))
|
||
(goto-char end)
|
||
(insert "'"))
|
||
|
||
(defun powershell-unquote-selection (beg end)
|
||
"Unquotes the selected text between BEG and END.
|
||
Remove doubled single quotes as we go."
|
||
(interactive `(,(region-beginning) ,(region-end)))
|
||
(if (not mark-active)
|
||
(error "Command requires a marked region"))
|
||
(goto-char beg)
|
||
(cond ((looking-at "'")
|
||
(goto-char end)
|
||
(when (looking-back "'" nil)
|
||
(delete-char -1)
|
||
(setq end (1- end))
|
||
(goto-char beg)
|
||
(delete-char 1)
|
||
(setq end (1- end))
|
||
(while (search-forward "'" end t)
|
||
(delete-char -1)
|
||
(forward-char)
|
||
(setq end (1- end)))))
|
||
((looking-at "\"")
|
||
(goto-char end)
|
||
(when (looking-back "\"" nil)
|
||
(delete-char -1)
|
||
(setq end (1- end))
|
||
(goto-char beg)
|
||
(delete-char 1)
|
||
(setq end (1- end))
|
||
(while (search-forward "\"" end t)
|
||
(delete-char -1)
|
||
(forward-char)
|
||
(setq end (1- end)))
|
||
(while (search-forward "`" end t)
|
||
(delete-char -1)
|
||
(forward-char)
|
||
(setq end (1- end)))))
|
||
(t (error "Must select quoted text exactly"))))
|
||
|
||
(defun powershell-escape-selection (beg end)
|
||
"Escape variables between BEG and END.
|
||
Also extend existing escapes."
|
||
(interactive `(,(region-beginning) ,(region-end)))
|
||
(if (not mark-active)
|
||
(error "Command requires a marked region"))
|
||
(goto-char beg)
|
||
(while (re-search-forward "`" end t)
|
||
(replace-match "```")(setq end (+ end 2)))
|
||
(goto-char beg)
|
||
(while (re-search-forward "\\(?:\\=\\|[^`]\\)[$]" end t)
|
||
(goto-char (car (cdr (match-data))))
|
||
(backward-char)
|
||
(insert "`")
|
||
(forward-char)
|
||
(setq end (1+ end))))
|
||
|
||
(defun powershell-doublequote-selection (beg end)
|
||
"Quotes the text between BEG and END with double quotes.
|
||
Embedded quotes are doubled."
|
||
(interactive `(,(region-beginning) ,(region-end)))
|
||
(if (not mark-active)
|
||
(error "Command requires a marked region"))
|
||
(goto-char beg)
|
||
(while (re-search-forward "\"" end t)
|
||
(replace-match "\"\"")(setq end (1+ end)))
|
||
(goto-char beg)
|
||
(while (re-search-forward "`'" end t)
|
||
(replace-match "```")(setq end (+ 2 end)))
|
||
(goto-char beg)
|
||
(insert "\"")
|
||
(setq end (1+ end))
|
||
(goto-char end)
|
||
(insert "\""))
|
||
|
||
(defun powershell-dollarparen-selection (beg end)
|
||
"Wraps the text between BEG and END with $().
|
||
The point is moved to the closing paren."
|
||
(interactive `(,(region-beginning) ,(region-end)))
|
||
(if (not mark-active)
|
||
(error "Command requires a marked region"))
|
||
(save-excursion
|
||
(goto-char end)
|
||
(insert ")")
|
||
(goto-char beg)
|
||
(insert "$("))
|
||
(forward-char))
|
||
|
||
(defun powershell-regexp-to-regex (beg end)
|
||
"Turn the text between BEG and END into a regex.
|
||
The text is assumed to be `regexp-opt' output."
|
||
(interactive `(,(region-beginning) ,(region-end)))
|
||
(if (not mark-active)
|
||
(error "Command requires a marked region"))
|
||
(save-restriction
|
||
(narrow-to-region beg end)
|
||
(goto-char (point-min))
|
||
(while (re-search-forward "\\\\(" nil t)
|
||
(replace-match "("))
|
||
(goto-char (point-min))
|
||
(while (re-search-forward "\\\\)" nil t)
|
||
(replace-match ")"))
|
||
(goto-char (point-min))
|
||
(while (re-search-forward "\\\\|" nil t)
|
||
(replace-match "|"))))
|
||
|
||
|
||
;; Taken from About_Keywords
|
||
(defvar powershell-keywords
|
||
(concat "\\_<"
|
||
(regexp-opt
|
||
'("begin" "break" "catch" "class" "continue" "data" "define" "do" "default"
|
||
"dynamicparam" "else" "elseif" "end" "enum" "exit" "filter" "finally"
|
||
"for" "foreach" "from" "function" "hidden" "if" "in" "param" "process"
|
||
"return" "static" "switch" "throw" "trap" "try" "until" "using" "var" "where" "while"
|
||
;; Questionable, specific to workflow sessions
|
||
"inlinescript")
|
||
t)
|
||
"\\_>")
|
||
"PowerShell keywords.")
|
||
|
||
;; Taken from About_Comparison_Operators and some questionable sources :-)
|
||
(defvar powershell-operators
|
||
(concat "\\_<"
|
||
(regexp-opt
|
||
'("-eq" "-ne" "-gt" "-ge" "-lt" "-le"
|
||
;; case sensitive versions
|
||
"-ceq" "-cne" "-cgt" "-cge" "-clt" "-cle"
|
||
;; explicitly case insensitive
|
||
"-ieq" "-ine" "-igt" "-ige" "-ilt" "-ile"
|
||
"-band" "-bor" "-bxor" "-bnot"
|
||
"-and" "-or" "-xor" "-not" "!"
|
||
"-like" "-notlike" "-clike" "-cnotlike" "-ilike" "-inotlike"
|
||
"-match" "-notmatch" "-cmatch" "-cnotmatch" "-imatch" "-inotmatch"
|
||
"-contains" "-notcontains" "-ccontains" "-cnotcontains"
|
||
"-icontains" "-inotcontains"
|
||
"-replace" "-creplace" "-ireplace"
|
||
"-is" "-isnot" "-as" "-f"
|
||
"-in" "-cin" "-iin" "-notin" "-cnotin" "-inotin"
|
||
"-split" "-csplit" "-isplit"
|
||
"-join"
|
||
"-shl" "-shr"
|
||
;; Questionable --> specific to certain contexts
|
||
"-casesensitive" "-wildcard" "-regex" "-exact" ;specific to case
|
||
"-begin" "-process" "-end" ;specific to scriptblock
|
||
) t)
|
||
"\\_>")
|
||
"PowerShell operators.")
|
||
|
||
(defvar powershell-scope-names
|
||
'("global" "local" "private" "script" )
|
||
"Names of scopes in PowerShell mode.")
|
||
|
||
(defvar powershell-variable-drive-names
|
||
(append '("env" "function" "variable" "alias" "hklm" "hkcu" "wsman") powershell-scope-names)
|
||
"Names of scopes in PowerShell mode.")
|
||
|
||
(defconst powershell-variables-regexp
|
||
;; There are 2 syntaxes detected: ${[scope:]name} and $[scope:]name
|
||
;; Match 0 is the entire variable name.
|
||
;; Match 1 is scope when the former syntax is found.
|
||
;; Match 2 is scope when the latter syntax is found.
|
||
(concat
|
||
"\\_<$\\(?:{\\(?:" (regexp-opt powershell-variable-drive-names t)
|
||
":\\)?[^}]+}\\|"
|
||
"\\(?:" (regexp-opt powershell-variable-drive-names t)
|
||
":\\)?[a-zA-Z0-9_]+\\_>\\)")
|
||
"Identifies legal powershell variable names.")
|
||
|
||
(defconst powershell-function-names-regex
|
||
;; Syntax detected is [scope:]verb-noun
|
||
;; Match 0 is the entire name.
|
||
;; Match 1 is the scope if any.
|
||
;; Match 2 is the function name (which must exist)
|
||
(concat
|
||
"\\_<\\(?:" (regexp-opt powershell-scope-names t) ":\\)?"
|
||
"\\([A-Z][a-zA-Z0-9]*-[A-Z0-9][a-zA-Z0-9]*\\)\\_>")
|
||
"Identifies legal function & filter names.")
|
||
|
||
(defconst powershell-object-types-regexp
|
||
;; Syntax is \[name[.name]\] (where the escaped []s are literal)
|
||
;; Only Match 0 is returned.
|
||
"\\[\\(?:[a-zA-Z_][a-zA-Z0-9]*\\)\\(?:\\.[a-zA-Z_][a-zA-Z0-9]*\\)*\\]"
|
||
"Identifies object type references. I.E. [object.data.type] syntax.")
|
||
|
||
(defconst powershell-function-switch-names-regexp
|
||
;; Only Match 0 is returned.
|
||
"\\_<-[a-zA-Z][a-zA-Z0-9]*\\_>"
|
||
"Identifies function parameter names of the form -xxxx.")
|
||
|
||
;; Taken from Get-Variable on a fresh shell, merged with man
|
||
;; about_automatic_variables
|
||
(defvar powershell-builtin-variables-regexp
|
||
(regexp-opt
|
||
'("$" "?"
|
||
"^" "_"
|
||
"args" "ConsoleFileName"
|
||
"Error" "Event"
|
||
"EventArgs"
|
||
"EventSubscriber" "ExecutionContext"
|
||
"false" "Foreach"
|
||
"HOME" "Host"
|
||
"input" "lsCoreCLR"
|
||
"lsLinux" "lsMacOS"
|
||
"lsWindows" "LASTEXITCODE"
|
||
"Matches" "MyInvocation"
|
||
"NestedPromptLevel" "null"
|
||
"PID" "PROFILE"
|
||
"PSBoundParameters" "PSCmdlet"
|
||
"PSCommandPath"
|
||
"PSCulture" "PSDebugContext"
|
||
"PSHOME" "PSITEM"
|
||
"PSScriptRoot" "PSSenderInfo"
|
||
"PSUICulture" "PSVersionTable"
|
||
"PWD" "ReportErrorShowExceptionClass"
|
||
"ReportErrorShowInnerException" "ReportErrorShowSource"
|
||
"ReportErrorShowStackTrace" "Sender"
|
||
"ShellId" "SourceArgs"
|
||
"SourceEventArgs" "StackTrace"
|
||
"this" "true" ) t)
|
||
"The names of the built-in PowerShell variables.
|
||
They are highlighted differently from the other variables.")
|
||
|
||
(defvar powershell-config-variables-regexp
|
||
(regexp-opt
|
||
'("ConfirmPreference" "DebugPreference"
|
||
"ErrorActionPreference" "ErrorView"
|
||
"FormatEnumerationLimit" "InformationPreference"
|
||
"LogCommandHealthEvent"
|
||
"LogCommandLifecycleEvent" "LogEngineHealthEvent"
|
||
"LogEngineLifecycleEvent" "LogProviderHealthEvent"
|
||
"LogProviderLifecycleEvent" "MaximumAliasCount"
|
||
"MaximumDriveCount" "MaximumErrorCount"
|
||
"MaximumFunctionCount" "MaximumHistoryCount"
|
||
"MaximumVariableCount" "OFS"
|
||
"OutputEncoding" "ProgressPreference"
|
||
"PSDefaultParameterValues" "PSEmailServer"
|
||
"PSModuleAutoLoadingPreference" "PSSessionApplicationName"
|
||
"PSSessionConfigurationName" "PSSessionOption"
|
||
"VerbosePreference" "WarningPreference"
|
||
"WhatIfPreference" ) t)
|
||
"Names of variables that configure powershell features.")
|
||
|
||
|
||
(defun powershell-find-syntactic-comments (limit)
|
||
"Find PowerShell comment begin and comment end characters.
|
||
Returns match 1 and match 2 for <# #> comment sequences respectively.
|
||
Returns match 3 and optionally match 4 for #/eol comments.
|
||
Match 4 is returned only if eol is found before LIMIT"
|
||
(when (search-forward "#" limit t)
|
||
(cond
|
||
((looking-back "<#" nil)
|
||
(set-match-data (list (match-beginning 0) (1+ (match-beginning 0))
|
||
(match-beginning 0) (1+ (match-beginning 0)))))
|
||
((looking-at ">")
|
||
(set-match-data (list (match-beginning 0) (match-end 0)
|
||
nil nil
|
||
(match-beginning 0) (match-end 0)))
|
||
(forward-char))
|
||
(t
|
||
(let ((start (point)))
|
||
(if (search-forward "\n" limit t)
|
||
(set-match-data (list (1- start) (match-end 0)
|
||
nil nil nil nil
|
||
(1- start) start
|
||
(match-beginning 0) (match-end 0)))
|
||
(set-match-data (list start (match-end 0)
|
||
nil nil nil nil
|
||
(1- start) start))))))
|
||
t))
|
||
|
||
(defun powershell-find-syntactic-quotes (limit)
|
||
"Find PowerShell hear string begin and end sequences upto LIMIT.
|
||
Returns match 1 and match 2 for @' '@ sequences respectively.
|
||
Returns match 3 and match 4 for @\" \"@ sequences respectively."
|
||
(when (search-forward "@" limit t)
|
||
(cond
|
||
((looking-at "'$")
|
||
(set-match-data (list (match-beginning 0) (1+ (match-beginning 0))
|
||
(match-beginning 0) (1+ (match-beginning 0))))
|
||
(forward-char))
|
||
((looking-back "^'@" nil)
|
||
(set-match-data (list (1- (match-end 0)) (match-end 0)
|
||
nil nil
|
||
(1- (match-end 0)) (match-end 0))))
|
||
((looking-at "\"$")
|
||
(set-match-data (list (match-beginning 0) (1+ (match-beginning 0))
|
||
nil nil
|
||
nil nil
|
||
(match-beginning 0) (1+ (match-beginning 0))))
|
||
(forward-char))
|
||
((looking-back "^\"@" nil)
|
||
(set-match-data (list (1- (match-end 0)) (match-end 0)
|
||
nil nil
|
||
nil nil
|
||
nil nil
|
||
(1- (match-end 0)) (match-end 0)))))
|
||
t))
|
||
(defvar powershell-font-lock-syntactic-keywords
|
||
`((powershell-find-syntactic-comments (1 "!" t t) (2 "!" t t)
|
||
(3 "<" t t) (4 ">" t t))
|
||
(powershell-find-syntactic-quotes (1 "|" t t) (2 "|" t t)
|
||
(3 "|" t t) (4 "|" t t)))
|
||
"A list of regexp's or functions.
|
||
Used to add `syntax-table' properties to
|
||
characters that can't be set by the `syntax-table' alone.")
|
||
|
||
|
||
(defvar powershell-font-lock-keywords-1
|
||
`( ;; Type annotations
|
||
(,powershell-object-types-regexp . font-lock-type-face)
|
||
;; syntaxic keywords
|
||
(,powershell-keywords . font-lock-keyword-face)
|
||
;; operators
|
||
(,powershell-operators . font-lock-builtin-face)
|
||
;; the REQUIRES mark
|
||
("^#\\(REQUIRES\\)" 1 font-lock-warning-face t))
|
||
"Keywords for the first level of font-locking in PowerShell mode.")
|
||
|
||
(defvar powershell-font-lock-keywords-2
|
||
(append
|
||
powershell-font-lock-keywords-1
|
||
`( ;; Built-in variables
|
||
(,(concat "\\$\\(" powershell-builtin-variables-regexp "\\)\\>")
|
||
0 font-lock-builtin-face t)
|
||
(,(concat "\\$\\(" powershell-config-variables-regexp "\\)\\>")
|
||
0 font-lock-builtin-face t)))
|
||
"Keywords for the second level of font-locking in PowerShell mode.")
|
||
|
||
(defvar powershell-font-lock-keywords-3
|
||
(append
|
||
powershell-font-lock-keywords-2
|
||
`( ;; user variables
|
||
(,powershell-variables-regexp
|
||
(0 font-lock-variable-name-face)
|
||
(1 (cons font-lock-type-face '(underline)) t t)
|
||
(2 (cons font-lock-type-face '(underline)) t t))
|
||
;; function argument names
|
||
(,powershell-function-switch-names-regexp
|
||
(0 font-lock-reference-face)
|
||
(1 (cons font-lock-type-face '(underline)) t t)
|
||
(2 (cons font-lock-type-face '(underline)) t t))
|
||
;; function names
|
||
(,powershell-function-names-regex
|
||
(0 font-lock-function-name-face)
|
||
(1 (cons font-lock-type-face '(underline)) t t))))
|
||
"Keywords for the maximum level of font-locking in PowerShell mode.")
|
||
|
||
|
||
(defun powershell-setup-font-lock ()
|
||
"Set up the buffer local value for `font-lock-defaults'."
|
||
;; I use font-lock-syntactic-keywords to set some properties and I
|
||
;; don't want them ignored.
|
||
(set (make-local-variable 'parse-sexp-lookup-properties) t)
|
||
;; This is where all the font-lock stuff actually gets set up. Once
|
||
;; font-lock-defaults has its value, setting font-lock-mode true should
|
||
;; cause all your syntax highlighting dreams to come true.
|
||
(setq font-lock-defaults
|
||
;; The first value is all the keyword expressions.
|
||
'((powershell-font-lock-keywords-1
|
||
powershell-font-lock-keywords-2
|
||
powershell-font-lock-keywords-3)
|
||
;; keywords-only means no strings or comments get fontified
|
||
nil
|
||
;; case-fold (t ignores case)
|
||
t
|
||
;; syntax-alist nothing special here
|
||
nil
|
||
;; syntax-begin - no function defined to move outside syntactic block
|
||
nil
|
||
;; font-lock-syntactic-keywords
|
||
;; takes (matcher (match syntax override lexmatch) ...)...
|
||
(font-lock-syntactic-keywords
|
||
. powershell-font-lock-syntactic-keywords))))
|
||
|
||
(defvar powershell-mode-syntax-table
|
||
(let ((powershell-mode-syntax-table (make-syntax-table)))
|
||
(modify-syntax-entry ?$ "_" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?: "_" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?- "_" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?^ "_" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?\\ "_" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?\{ "(}" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?\} "){" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?\[ "(]" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?\] ")[" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?\( "()" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?\) ")(" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?` "\\" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?_ "w" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?= "." powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?| "." powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?+ "." powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?* "." powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?/ "." powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?' "\"" powershell-mode-syntax-table)
|
||
(modify-syntax-entry ?# "<" powershell-mode-syntax-table)
|
||
powershell-mode-syntax-table)
|
||
"Syntax for PowerShell major mode.")
|
||
|
||
(defvar powershell-mode-map
|
||
(let ((powershell-mode-map (make-keymap)))
|
||
;; (define-key powershell-mode-map "\r" 'powershell-indent-line)
|
||
(define-key powershell-mode-map (kbd "M-\"")
|
||
'powershell-doublequote-selection)
|
||
(define-key powershell-mode-map (kbd "M-'") 'powershell-quote-selection)
|
||
(define-key powershell-mode-map (kbd "C-'") 'powershell-unquote-selection)
|
||
(define-key powershell-mode-map (kbd "C-\"") 'powershell-unquote-selection)
|
||
(define-key powershell-mode-map (kbd "M-`") 'powershell-escape-selection)
|
||
(define-key powershell-mode-map (kbd "C-$")
|
||
'powershell-dollarparen-selection)
|
||
powershell-mode-map)
|
||
"Keymap for PS major mode.")
|
||
|
||
(defun powershell-setup-menu ()
|
||
"Add a menu of PowerShell specific functions to the menu bar."
|
||
(define-key (current-local-map) [menu-bar powershell-menu]
|
||
(cons "PowerShell" (make-sparse-keymap "PowerShell")))
|
||
(define-key (current-local-map) [menu-bar powershell-menu doublequote]
|
||
'(menu-item "DoubleQuote Selection" powershell-doublequote-selection
|
||
:key-sequence(kbd "M-\"")
|
||
:help
|
||
"DoubleQuotes the selection escaping embedded double quotes"))
|
||
(define-key (current-local-map) [menu-bar powershell-menu quote]
|
||
'(menu-item "SingleQuote Selection" powershell-quote-selection
|
||
:key-sequence (kbd "M-'")
|
||
:help
|
||
"SingleQuotes the selection escaping embedded single quotes"))
|
||
(define-key (current-local-map) [menu-bar powershell-menu unquote]
|
||
'(menu-item "UnQuote Selection" powershell-unquote-selection
|
||
:key-sequence (kbd "C-'")
|
||
:help "Un-Quotes the selection un-escaping any escaped quotes"))
|
||
(define-key (current-local-map) [menu-bar powershell-menu escape]
|
||
'(menu-item "Escape Selection" powershell-escape-selection
|
||
:key-sequence (kbd "M-`")
|
||
:help (concat "Escapes variables in the selection"
|
||
" and extends existing escapes.")))
|
||
(define-key (current-local-map) [menu-bar powershell-menu dollarparen]
|
||
'(menu-item "DollarParen Selection" powershell-dollarparen-selection
|
||
:key-sequence (kbd "C-$")
|
||
:help "Wraps the selection in $()")))
|
||
|
||
|
||
;;; Eldoc support
|
||
|
||
(defcustom powershell-eldoc-def-files nil
|
||
"List of files containing function help strings used by function `eldoc-mode'.
|
||
These are the strings function `eldoc-mode' displays as help for
|
||
functions near point. The format of the file must be exactly as
|
||
follows or who knows what happens.
|
||
|
||
(set (intern \"<fcn-name1>\" powershell-eldoc-obarray) \"<helper string1>\")
|
||
(set (intern \"<fcn-name2>\" powershell-eldoc-obarray) \"<helper string2>\")
|
||
...
|
||
|
||
Where <fcn-name> is the name of the function to which <helper string> applies.
|
||
<helper-string> is the string to display when point is near <fcn-name>."
|
||
:type '(repeat string)
|
||
:group 'powershell)
|
||
|
||
(defvar powershell-eldoc-obarray ()
|
||
"Array for file entries by the function `eldoc'.
|
||
`powershell-eldoc-def-files' entries are added into this array.")
|
||
|
||
(defun powershell-eldoc-function ()
|
||
"Return a documentation string appropriate for the current context or nil."
|
||
(let ((word (thing-at-point 'symbol)))
|
||
(if word
|
||
(eval (intern-soft word powershell-eldoc-obarray)))))
|
||
|
||
(defun powershell-setup-eldoc ()
|
||
"Load the function documentation for use with eldoc."
|
||
(when (not (null powershell-eldoc-def-files))
|
||
(set (make-local-variable 'eldoc-documentation-function)
|
||
'powershell-eldoc-function)
|
||
(unless (vectorp powershell-eldoc-obarray)
|
||
(setq powershell-eldoc-obarray (make-vector 41 0))
|
||
(condition-case var (mapc 'load powershell-eldoc-def-files)
|
||
(error (message "*** powershell-setup-eldoc ERROR *** %s" var))))))
|
||
;;; Note: You can create quite a bit of help with these commands:
|
||
;;
|
||
;; function Get-Signature ($Cmd) {
|
||
;; if ($Cmd -is [Management.Automation.PSMethod]) {
|
||
;; $List = @($Cmd)}
|
||
;; elseif ($Cmd -isnot [string]) {
|
||
;; throw ("Get-Signature {<method>|<command>}`n" +
|
||
;; "'$Cmd' is not a method or command")}
|
||
;; else {$List = @(Get-Command $Cmd -ErrorAction SilentlyContinue)}
|
||
;; if (!$List[0] ) {
|
||
;; throw "Command '$Cmd' not found"}
|
||
;; foreach ($O in $List) {
|
||
;; switch -regex ($O.GetType().Name) {
|
||
;; 'AliasInfo' {
|
||
;; Get-Signature ($O.Definition)}
|
||
;; '(Cmdlet|ExternalScript)Info' {
|
||
;; $O.Definition} # not sure what to do with ExternalScript
|
||
;; 'F(unction|ilter)Info'{
|
||
;; if ($O.Definition -match '^param *\(') {
|
||
;; $t = [Management.Automation.PSParser]::tokenize($O.Definition,
|
||
;; [ref]$null)
|
||
;; $c = 1;$i = 1
|
||
;; while($c -and $i++ -lt $t.count) {
|
||
;; switch ($t[$i].Type.ToString()) {
|
||
;; GroupStart {$c++}
|
||
;; GroupEnd {$c--}}}
|
||
;; $O.Definition.substring(0,$t[$i].start + 1)} #needs parsing
|
||
;; else {$O.Name}}
|
||
;; 'PSMethod' {
|
||
;; foreach ($t in @($O.OverloadDefinitions)) {
|
||
;; while (($b=$t.IndexOf('`1[[')) -ge 0) {
|
||
;; $t=$t.remove($b,$t.IndexOf(']]')-$b+2)}
|
||
;; $t}}}}}
|
||
;; get-command|
|
||
;; ?{$_.CommandType -ne 'Alias' -and $_.Name -notlike '*:'}|
|
||
;; %{$_.Name}|
|
||
;; sort|
|
||
;; %{("(set (intern ""$($_.Replace('\','\\'))"" powershell-eldoc-obarray)" +
|
||
;; " ""$(Get-Signature $_|%{$_.Replace('\','\\').Replace('"','\"')})"")"
|
||
;; ).Replace("`r`n"")",""")")} > .\powershell-eldoc.el
|
||
|
||
|
||
(defvar powershell-imenu-expression
|
||
`(("Functions" ,(concat "function " powershell-function-names-regex) 2)
|
||
("Filters" ,(concat "filter " powershell-function-names-regex) 2)
|
||
("Top variables"
|
||
, (concat "^\\(" powershell-object-types-regexp "\\)?\\("
|
||
powershell-variables-regexp "\\)\\s-*=")
|
||
2))
|
||
"List of regexps matching important expressions, for speebar & imenu.")
|
||
|
||
(defun powershell-setup-imenu ()
|
||
"Install `powershell-imenu-expression'."
|
||
(when (require 'imenu nil t)
|
||
;; imenu doc says these are buffer-local by default
|
||
(setq imenu-generic-expression powershell-imenu-expression)
|
||
(setq imenu-case-fold-search nil)
|
||
(imenu-add-menubar-index)))
|
||
|
||
(defun powershell-setup-speedbar ()
|
||
"Install `speedbar-add-supported-extension'."
|
||
(when (require 'speedbar nil t)
|
||
(speedbar-add-supported-extension ".ps1?")))
|
||
|
||
;; A better command would be something like "powershell.exe -NoLogo
|
||
;; -NonInteractive -Command & (buffer-file-name)". But it will just
|
||
;; sit there waiting... The following will only work when .ps1 files
|
||
;; are associated with powershell.exe. And if they don't contain spaces.
|
||
(defvar powershell-compile-command
|
||
'(buffer-file-name)
|
||
"Default command used to invoke a powershell script.")
|
||
|
||
;; The column number will be off whenever tabs are used. Since this is
|
||
;; the default in this mode, we will not capture the column number.
|
||
(setq compilation-error-regexp-alist
|
||
(cons '("At \\(.*\\):\\([0-9]+\\) char:\\([0-9]+\\)" 1 2)
|
||
compilation-error-regexp-alist))
|
||
|
||
|
||
(add-hook 'powershell-mode-hook #'imenu-add-menubar-index)
|
||
|
||
;;;###autoload
|
||
(define-derived-mode powershell-mode prog-mode "PS"
|
||
"Major mode for editing PowerShell scripts.
|
||
|
||
\\{powershell-mode-map}
|
||
Entry to this mode calls the value of `powershell-mode-hook' if
|
||
that value is non-nil."
|
||
(powershell-setup-font-lock)
|
||
(setq-local indent-line-function 'powershell-indent-line)
|
||
(setq-local compile-command powershell-compile-command)
|
||
(setq-local comment-start "#")
|
||
(setq-local comment-start-skip "#+\\s*")
|
||
(setq-local parse-sexp-ignore-comments t)
|
||
;; Support electric-pair-mode
|
||
(setq-local electric-indent-chars
|
||
(append "{}():;," electric-indent-chars))
|
||
(powershell-setup-imenu)
|
||
(powershell-setup-speedbar)
|
||
(powershell-setup-menu)
|
||
(powershell-setup-eldoc))
|
||
|
||
;;; PowerShell inferior mode
|
||
|
||
;;; Code:
|
||
(defcustom powershell-location-of-exe
|
||
(or (executable-find "pwsh") (executable-find "powershell"))
|
||
"A string providing the location of the powershell executable. Since
|
||
the newer PowerShell Core (pwsh.exe) does not replace the older Windows
|
||
PowerShell (powershell.exe) when installed, this attempts to find the
|
||
former first, and only if it doesn't exist, falls back to the latter."
|
||
:group 'powershell
|
||
:type 'string)
|
||
|
||
(defcustom powershell-log-level 3
|
||
"The current log level for powershell internal operations.
|
||
0 = NONE, 1 = Info, 2 = VERBOSE, 3 = DEBUG."
|
||
:group 'powershell
|
||
:type 'integer)
|
||
|
||
(defcustom powershell-squish-results-of-silent-commands t
|
||
"The function `powershell-invoke-command-silently' returns the results
|
||
of a command in a string. PowerShell by default, inserts newlines when
|
||
the output exceeds the configured width of the powershell virtual
|
||
window. In some cases callers might want to get the results with the
|
||
newlines and formatting removed. Set this to true, to do that."
|
||
:group 'powershell
|
||
:type 'boolean)
|
||
|
||
(defvar powershell-prompt-regex "PS [^#$%>]+> "
|
||
"Regexp to match the powershell prompt.
|
||
powershell.el uses this regex to determine when a command has
|
||
completed. Therefore, you need to set this appropriately if you
|
||
explicitly change the prompt function in powershell. Any value
|
||
should include a trailing space, if the powershell prompt uses a
|
||
trailing space, but should not include a trailing newline.
|
||
|
||
The default value will match the default PowerShell prompt.")
|
||
|
||
(defvar powershell-command-reply nil
|
||
"The reply of powershell commands.
|
||
This is retained for housekeeping purposes.")
|
||
|
||
(defvar powershell--max-window-width 0
|
||
"The maximum width of a powershell window.
|
||
You shouldn't need to ever set this. It gets set automatically,
|
||
once, when the powershell starts up.")
|
||
|
||
(defvar powershell-command-timeout-seconds 12
|
||
"The timeout for a powershell command.
|
||
powershell.el will wait this long before giving up.")
|
||
|
||
(defvar powershell--need-rawui-resize t
|
||
"No need to fuss with this. It's intended for internal use
|
||
only. It gets set when powershell needs to be informed that
|
||
emacs has resized its window.")
|
||
|
||
(defconst powershell--find-max-window-width-command
|
||
(concat
|
||
"function _Emacs_GetMaxPhsWindowSize"
|
||
" {"
|
||
" $rawui = (Get-Host).UI.RawUI;"
|
||
" $mpws_exists = ($rawui | Get-Member | Where-Object"
|
||
" {$_.Name -eq \"MaxPhysicalWindowSize\"});"
|
||
" if ($mpws_exists -eq $null) {"
|
||
" 210"
|
||
" } else {"
|
||
" $rawui.MaxPhysicalWindowSize.Width"
|
||
" }"
|
||
" };"
|
||
" _Emacs_GetMaxPhsWindowSize")
|
||
"The powershell logic to determine the max physical window width.")
|
||
|
||
(defconst powershell--set-window-width-fn-name "_Emacs_SetWindowWidth"
|
||
"The name of the function this mode defines in PowerShell to
|
||
set the window width. Intended for internal use only.")
|
||
|
||
(defconst powershell--text-of-set-window-width-ps-function
|
||
;; see
|
||
;; http://blogs.msdn.com/lior/archive/2009/05/27/ResizePowerShellConsoleWindow.aspx
|
||
;;
|
||
;; When making the console window narrower, you mus set the window
|
||
;; size first. When making the console window wider, you must set the
|
||
;; buffer size first.
|
||
|
||
(concat "function " powershell--set-window-width-fn-name
|
||
"([string] $pswidth)"
|
||
" {"
|
||
" $rawui = (Get-Host).UI.RawUI;"
|
||
" $bufsize = $rawui.BufferSize;"
|
||
" $winsize = $rawui.WindowSize;"
|
||
" $cwidth = $winsize.Width;"
|
||
" $winsize.Width = $pswidth;"
|
||
" $bufsize.Width = $pswidth;"
|
||
" if ($cwidth -lt $pswidth) {"
|
||
" $rawui.BufferSize = $bufsize;"
|
||
" $rawui.WindowSize = $winsize;"
|
||
" }"
|
||
" elseif ($cwidth -gt $pswidth) {"
|
||
" $rawui.WindowSize = $winsize;"
|
||
" $rawui.BufferSize = $bufsize;"
|
||
" };"
|
||
" Set-Variable -name rawui -value $null;"
|
||
" Set-Variable -name winsize -value $null;"
|
||
" Set-Variable -name bufsize -value $null;"
|
||
" Set-Variable -name cwidth -value $null;"
|
||
" }")
|
||
|
||
"The text of the powershell function that will be used at runtime to
|
||
set the width of the virtual Window in PowerShell, as the Emacs window
|
||
gets resized.")
|
||
|
||
(defun powershell-log (level text &rest args)
|
||
"Log a message at level LEVEL.
|
||
If LEVEL is higher than `powershell-log-level', the message is
|
||
ignored. Otherwise, it is printed using `message'.
|
||
TEXT is a format control string, and the remaining arguments ARGS
|
||
are the string substitutions (see `format')."
|
||
(if (<= level powershell-log-level)
|
||
(let* ((msg (apply 'format text args)))
|
||
(message "%s" msg))))
|
||
|
||
;; (defun dino-powershell-complete (arg)
|
||
;; "do powershell completion on the given STRING. Pop up a buffer
|
||
;; with the completion list."
|
||
;; (interactive
|
||
;; (list (read-no-blanks-input "\
|
||
;; Stub to complete: ")))
|
||
|
||
;; (let ((proc
|
||
;; (get-buffer-process (current-buffer))))
|
||
;; (comint-proc-query proc (concat "Get-Command " arg "*\n"))
|
||
;; )
|
||
;; )
|
||
|
||
;; (defun dino-powershell-cmd-complete ()
|
||
;; "try to get powershell completion to work."
|
||
;; (interactive)
|
||
;; (let ((proc
|
||
;; (get-buffer-process (current-buffer))))
|
||
;; ;; (comint-proc-query proc "Get-a\t")
|
||
;; ;; (comint-simple-send proc "Get-a\t")
|
||
;; (comint-send-string proc "Get-a\t\n")
|
||
;; ;; (process-send-eof)
|
||
;; )
|
||
;; )
|
||
|
||
(defun powershell--define-set-window-width-function (proc)
|
||
"Sends a function definition to the PowerShell instance
|
||
identified by PROC. The function sets the window width of the
|
||
PowerShell virtual window. Later, the function will be called
|
||
when the width of the emacs window changes."
|
||
(if proc
|
||
(progn
|
||
;;process-send-string
|
||
(comint-simple-send
|
||
proc
|
||
powershell--text-of-set-window-width-ps-function))))
|
||
|
||
(defun powershell--get-max-window-width (buffer-name)
|
||
"Gets the maximum width of the virtual window for PowerShell running
|
||
in the buffer with name BUFFER-NAME.
|
||
|
||
In PowerShell 1.0, the maximum WindowSize.Width for
|
||
PowerShell is 210, hardcoded, I believe. In PowerShell 2.0, the max
|
||
windowsize.Width is provided in the RawUI.MaxPhysicalWindowSize
|
||
property.
|
||
|
||
This function does the right thing, and sets the buffer-local
|
||
`powershell--max-window-width' variable with the correct value."
|
||
(let ((proc (get-buffer-process buffer-name)))
|
||
|
||
(if proc
|
||
(with-current-buffer buffer-name
|
||
(powershell-invoke-command-silently
|
||
proc
|
||
powershell--find-max-window-width-command
|
||
0.90)
|
||
|
||
;; store the retrieved width
|
||
(setq powershell--max-window-width
|
||
(if (and (not (null powershell-command-reply))
|
||
(string-match
|
||
"\\([1-9][0-9]*\\)[ \t\f\v\n]+"
|
||
powershell-command-reply))
|
||
(string-to-number (match-string 1 powershell-command-reply))
|
||
200)))))) ;; could go to 210, but let's use 200 to be safe
|
||
|
||
(defun powershell--set-window-width (proc)
|
||
"Run the PowerShell function that sets the RawUI width
|
||
appropriately for a PowerShell shell.
|
||
|
||
This is necessary to get powershell to do the right thing, as far
|
||
as text formatting, when the emacs window gets resized.
|
||
|
||
The function gets defined in powershell upon powershell startup."
|
||
(let ((ps-width
|
||
(number-to-string (min powershell--max-window-width (window-width)))))
|
||
(progn
|
||
;;(process-send-string
|
||
(comint-simple-send
|
||
proc
|
||
(concat powershell--set-window-width-fn-name
|
||
"('" ps-width "')")))))
|
||
|
||
;;;###autoload
|
||
(defun powershell (&optional buffer prompt-string)
|
||
"Run an inferior PowerShell.
|
||
If BUFFER is non-nil, use it to hold the powershell
|
||
process. Defaults to *PowerShell*.
|
||
|
||
Interactively, a prefix arg means to prompt for BUFFER.
|
||
|
||
If BUFFER exists but the shell process is not running, it makes a
|
||
new shell.
|
||
|
||
If BUFFER exists and the shell process is running, just switch to
|
||
BUFFER.
|
||
|
||
If PROMPT-STRING is non-nil, sets the prompt to the given value.
|
||
|
||
See the help for `shell' for more details. \(Type
|
||
\\[describe-mode] in the shell buffer for a list of commands.)"
|
||
(interactive
|
||
(list
|
||
(and current-prefix-arg
|
||
(read-buffer "Shell buffer: "
|
||
(generate-new-buffer-name "*PowerShell*")))))
|
||
|
||
(setq buffer (get-buffer-create (or buffer "*PowerShell*")))
|
||
(powershell-log 1 "powershell starting up...in buffer %s" (buffer-name buffer))
|
||
(let ((explicit-shell-file-name (if (and (eq system-type 'cygwin)
|
||
(fboundp 'cygwin-convert-file-name-from-windows))
|
||
(cygwin-convert-file-name-from-windows powershell-location-of-exe)
|
||
powershell-location-of-exe)))
|
||
;; set arguments for the powershell exe.
|
||
;; Does this need to be tunable?
|
||
|
||
(shell buffer))
|
||
|
||
;; (powershell--get-max-window-width "*PowerShell*")
|
||
;; (powershell-invoke-command-silently (get-buffer-process "*csdeshell*")
|
||
;; "[Ionic.Csde.Utilities]::Version()" 2.9)
|
||
|
||
;; (comint-simple-send (get-buffer-process "*csdeshell*") "prompt\n")
|
||
|
||
(let ((proc (get-buffer-process buffer)))
|
||
|
||
(make-local-variable 'powershell-prompt-regex)
|
||
(make-local-variable 'powershell-command-reply)
|
||
(make-local-variable 'powershell--max-window-width)
|
||
(make-local-variable 'powershell-command-timeout-seconds)
|
||
(make-local-variable 'powershell-squish-results-of-silent-commands)
|
||
(make-local-variable 'powershell--need-rawui-resize)
|
||
(make-local-variable 'comint-prompt-read-only)
|
||
|
||
;; disallow backspace over the prompt:
|
||
(setq comint-prompt-read-only t)
|
||
|
||
;; We need to tell powershell how wide the emacs window is, because
|
||
;; powershell pads its output to the width it thinks its window is.
|
||
;;
|
||
;; The way it's done: every time the width of the emacs window changes, we
|
||
;; set a flag. Then, before sending a powershell command that is
|
||
;; typed into the buffer, to the actual powershell process, we check
|
||
;; that flag. If it is set, we resize the powershell window appropriately,
|
||
;; before sending the command.
|
||
|
||
;; If we didn't do this, powershell output would get wrapped at a
|
||
;; column width that would be different than the emacs buffer width,
|
||
;; and everything would look ugly.
|
||
|
||
;; get the maximum width for powershell - can't go beyond this
|
||
(powershell--get-max-window-width buffer)
|
||
|
||
;; define the function for use within powershell to resize the window
|
||
(powershell--define-set-window-width-function proc)
|
||
|
||
;; add the hook that sets the flag
|
||
(add-hook 'window-size-change-functions
|
||
#'(lambda (&rest _)
|
||
(setq powershell--need-rawui-resize t)))
|
||
|
||
;; set the flag so we resize properly the first time.
|
||
(setq powershell--need-rawui-resize t)
|
||
|
||
(if prompt-string
|
||
(progn
|
||
;; This sets up a prompt for the PowerShell. The prompt is
|
||
;; important because later, after sending a command to the
|
||
;; shell, the scanning logic that grabs the output looks for
|
||
;; the prompt string to determine that the output is complete.
|
||
(comint-simple-send
|
||
proc
|
||
(concat "function prompt { '" prompt-string "' }"))
|
||
|
||
(setq powershell-prompt-regex prompt-string)))
|
||
|
||
;; hook the kill-buffer action so we can kill the inferior process?
|
||
(add-hook 'kill-buffer-hook 'powershell-delete-process)
|
||
|
||
;; wrap the comint-input-sender with a PS version
|
||
;; must do this after launching the shell!
|
||
(make-local-variable 'comint-input-sender)
|
||
(setq comint-input-sender 'powershell-simple-send)
|
||
|
||
;; set a preoutput filter for powershell. This will trim newlines
|
||
;; after the prompt.
|
||
(add-hook 'comint-preoutput-filter-functions
|
||
'powershell-preoutput-filter-for-prompt)
|
||
|
||
;; send a carriage-return (get the prompt)
|
||
(comint-send-input)
|
||
(accept-process-output proc))
|
||
|
||
;; The launch hooks for powershell has not (yet?) been implemented
|
||
;;(run-hooks 'powershell-launch-hook)
|
||
|
||
;; return the buffer created
|
||
buffer)
|
||
|
||
;; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
|
||
;; Using powershell on emacs23, I get an error:
|
||
;;
|
||
;; ansi-color-process-output: Marker does not point anywhere
|
||
;;
|
||
;; Here's what's happening.
|
||
;;
|
||
;; In order to be able to read the output from powershell, this shell
|
||
;; starts powershell.exe in "interactive mode", using the -i
|
||
;; option. This which has the curious side-effect of turning off the
|
||
;; prompt in powershell. Normally powershell will return its results,
|
||
;; then emit a prompt to indicate that it is ready for more input. In
|
||
;; interactive mode it doesn't emit the prompt. To work around this,
|
||
;; this code (powershell.el) sends an explicit `prompt` command after
|
||
;; sending any user-entered command to powershell. This tells powershell
|
||
;; to explicitly return the prompt, after the results of the prior
|
||
;; command. The prompt then shows up in the powershell buffer. Lovely.
|
||
;;
|
||
;; But, `ansi-color-apply-on-region` gets called after every command
|
||
;; gets sent to powershell. It gets called with args `(begin end)`,
|
||
;; which are both markers. Turns out the very first time this fn is
|
||
;; called, the position for the begin marker is nil.
|
||
;;
|
||
;; `ansi-color-apply-on-region` calls `(goto-char begin)` (effectively),
|
||
;; and when the position on the marker is nil, the call errors with
|
||
;; "Marker does not point anywhere."
|
||
;;
|
||
;; The following advice suppresses the call to
|
||
;; `ansi-color-apply-on-region` when the begin marker points
|
||
;; nowhere.
|
||
(defadvice ansi-color-apply-on-region (around
|
||
powershell-throttle-ansi-colorizing
|
||
(begin end)
|
||
compile)
|
||
(progn
|
||
(let ((start-pos (marker-position begin)))
|
||
(cond
|
||
(start-pos
|
||
(progn
|
||
ad-do-it))))))
|
||
|
||
(defun powershell--silent-cmd-filter (process result)
|
||
"A process filter that captures output from a shell and stores it
|
||
to `powershell-command-reply', rather than allowing the output to
|
||
be displayed in the shell buffer.
|
||
|
||
This function is intended for internal use only."
|
||
(let ((end-of-result
|
||
(string-match (concat ".*\n\\(" powershell-prompt-regex "\\)[ \n]*\\'")
|
||
result)))
|
||
(if (and end-of-result (numberp end-of-result))
|
||
|
||
(progn
|
||
;; Store everything except the follow-on prompt.
|
||
;; The result probably includes a final newline!
|
||
(setq result (substring result 0 (match-beginning 1)))
|
||
|
||
(if powershell-squish-results-of-silent-commands
|
||
(setq result
|
||
(replace-regexp-in-string "\n" "" result)))
|
||
|
||
(setq powershell-command-reply
|
||
(concat powershell-command-reply result)))
|
||
|
||
(progn
|
||
(if powershell-squish-results-of-silent-commands
|
||
(setq result
|
||
(replace-regexp-in-string "\n" "" result)))
|
||
|
||
(setq powershell-command-reply
|
||
(concat powershell-command-reply result))
|
||
|
||
;; recurse. For very very long output, the recursion can
|
||
;; cause stack overflow. Careful!
|
||
(accept-process-output process powershell-command-timeout-seconds)))))
|
||
|
||
(defun powershell-invoke-command-silently (proc command
|
||
&optional timeout-seconds)
|
||
"In the PowerShell instance PROC, invoke COMMAND silently.
|
||
Neither the COMMAND is echoed nor the results to the associated
|
||
buffer. Use TIMEOUT-SECONDS as the timeout, waiting for a
|
||
response. The COMMAND should be a string, and need not be
|
||
terminated with a newline.
|
||
|
||
This is helpful when, for example, doing setup work. Or other sneaky
|
||
stuff, such as resetting the size of the PowerShell virtual window.
|
||
|
||
Returns the result of the command, a string, without the follow-on
|
||
command prompt. The result will probably end in a newline. This result
|
||
is also stored in the buffer-local variable `powershell-command-reply'.
|
||
|
||
In some cases the result can be prepended with the command prompt, as
|
||
when, for example, several commands have been send in succession and the
|
||
results of the prior command were not fully processed by the application.
|
||
|
||
If a PowerShell buffer is not the current buffer, this function
|
||
should be invoked within a call to `with-current-buffer' or
|
||
similar in order to insure that the buffer-local values of
|
||
`powershell-command-reply', `powershell-prompt-regex', and
|
||
`powershell-command-timeout-seconds' are used.
|
||
|
||
Example:
|
||
|
||
(with-current-buffer powershell-buffer-name
|
||
(powershell-invoke-command-silently
|
||
proc
|
||
command-string
|
||
1.90))"
|
||
|
||
(let ((old-timeout powershell-command-timeout-seconds)
|
||
(original-filter (process-filter proc)))
|
||
|
||
(setq powershell-command-reply nil)
|
||
|
||
(if timeout-seconds
|
||
(setq powershell-command-timeout-seconds timeout-seconds))
|
||
|
||
(set-process-filter proc 'powershell--silent-cmd-filter)
|
||
|
||
;; Send the command plus the "prompt" command. The filter
|
||
;; will know the command is finished when it sees the command
|
||
;; prompt.
|
||
;;
|
||
(process-send-string proc (concat command "\nprompt\n"))
|
||
|
||
(accept-process-output proc powershell-command-timeout-seconds)
|
||
|
||
;; output of the command is now available in powershell-command-reply
|
||
|
||
;; Trim prompt from the beginning of the output.
|
||
;; this can happen for the first command through
|
||
;; the shell. I think there's a race condition.
|
||
(if (and powershell-command-reply
|
||
(string-match (concat "^" powershell-prompt-regex "\\(.*\\)\\'")
|
||
powershell-command-reply))
|
||
(setq powershell-command-reply
|
||
(substring powershell-command-reply
|
||
(match-beginning 1)
|
||
(match-end 1))))
|
||
|
||
;; restore the original filter
|
||
(set-process-filter proc original-filter)
|
||
|
||
;; restore the original timeout
|
||
(if timeout-seconds
|
||
(setq powershell-command-timeout-seconds old-timeout))
|
||
|
||
;; the result:
|
||
powershell-command-reply))
|
||
|
||
(defun powershell-delete-process (&optional proc)
|
||
"Delete the current buffer process or PROC."
|
||
(or proc
|
||
(setq proc (get-buffer-process (current-buffer))))
|
||
(and (processp proc)
|
||
(delete-process proc)))
|
||
|
||
(defun powershell-preoutput-filter-for-prompt (string)
|
||
"Trim the newline from STRING, the prompt that we get back from
|
||
powershell. This fn is set into the preoutput filters, so the
|
||
newline is trimmed before being put into the output buffer."
|
||
(if (string-match (concat powershell-prompt-regex "\n\\'") string)
|
||
(substring string 0 -1) ;; remove newline
|
||
string))
|
||
|
||
(defun powershell-simple-send (proc string)
|
||
"Override of the comint-simple-send function, with logic
|
||
specifically designed for powershell. This just sends STRING,
|
||
plus the prompt command.
|
||
|
||
When running as an inferior shell with stdin/stdout redirected,
|
||
powershell is in noninteractive mode. This means no prompts get
|
||
emitted when a PS command completes. This makes it difficult for
|
||
a comint mode to determine when the command has completed.
|
||
Therefore, we send an explicit request for the prompt, after
|
||
sending the actual (primary) command. When the primary command
|
||
completes, PowerShell then responds to the \"prompt\" command,
|
||
and emits the prompt.
|
||
|
||
This insures we get and display the prompt."
|
||
;; Tell PowerShell to resize its virtual window, if necessary. We do
|
||
;; this by calling a resize function in the PowerShell, before sending
|
||
;; the user-entered command to the shell.
|
||
;;
|
||
;; PowerShell keeps track of its \"console\", and formats its output
|
||
;; according to the width it thinks it is using. This is true even when
|
||
;; powershell is invoked with the - argument, which tells it to use
|
||
;; stdin as input.
|
||
|
||
;; Therefore, if the user has resized the emacs window since the last
|
||
;; PowerShell command, we need to tell PowerShell to change the size
|
||
;; of its virtual window. Calling that function does not change the
|
||
;; size of a window that is visible on screen - it only changes the
|
||
;; size of the virtual window that PowerShell thinks it is using. We
|
||
;; do that by invoking the PowerShell function that this module
|
||
;; defined for that purpose.
|
||
;;
|
||
(if powershell--need-rawui-resize
|
||
(progn
|
||
(powershell--set-window-width proc)
|
||
(setq powershell--need-rawui-resize nil)))
|
||
(comint-simple-send proc (concat string "\n"))
|
||
(comint-simple-send proc "prompt\n"))
|
||
|
||
;; Notes on TAB for completion.
|
||
;; -------------------------------------------------------
|
||
;; Emacs calls comint-dynamic-complete when the TAB key is pressed in a shell.
|
||
;; This is set up in shell-mode-map.
|
||
;;
|
||
;; comint-dynamic-complete calls the functions in
|
||
;; comint-dynamic-complete-functions, until one of them returns
|
||
;; non-nil.
|
||
;;
|
||
;; comint-dynamic-complete-functions is a good thing to set in the mode hook.
|
||
;;
|
||
;; The default value for that var in a powershell shell is:
|
||
;; (comint-replace-by-expanded-history
|
||
;; shell-dynamic-complete-environment-variable
|
||
;; shell-dynamic-complete-command
|
||
;; shell-replace-by-expanded-directory
|
||
;; comint-dynamic-complete-filename)
|
||
|
||
;; (defun powershell-dynamic-complete-command ()
|
||
;; "Dynamically complete the command at point. This function is
|
||
;; similar to `comint-dynamic-complete-filename', except that it
|
||
;; searches the commands from powershell and then the `exec-path'
|
||
;; (minus the trailing Emacs library path) for completion candidates.
|
||
|
||
;; Completion is dependent on the value of
|
||
;; `shell-completion-execonly', plus those that effect file
|
||
;; completion. See `powershell-dynamic-complete-as-command'.
|
||
|
||
;; Returns t if successful."
|
||
;; (interactive)
|
||
;; (let ((filename (comint-match-partial-filename)))
|
||
;; (if (and filename
|
||
;; (save-match-data (not (string-match "[~/]" filename)))
|
||
;; (eq (match-beginning 0)
|
||
;; (save-excursion (shell-backward-command 1) (point))))
|
||
;; (prog2 (message "Completing command name...")
|
||
;; (powershell-dynamic-complete-as-command)))))
|
||
|
||
;; (defun powershell-dynamic-complete-as-command ()
|
||
;; "Dynamically complete at point as a command.
|
||
;; See `shell-dynamic-complete-filename'. Returns t if successful."
|
||
;; (let* ((filename (or (comint-match-partial-filename) ""))
|
||
;; (filenondir (file-name-nondirectory filename))
|
||
;; (path-dirs (cdr (reverse exec-path)))
|
||
;; (cwd (file-name-as-directory (expand-file-name default-directory)))
|
||
;; (ignored-extensions
|
||
;; (and comint-completion-fignore
|
||
;; (mapconcat (function (lambda (x) (concat (regexp-quote x) "$")))
|
||
;; comint-completion-fignore "\\|")))
|
||
;; (dir "") (comps-in-dir ())
|
||
;; (file "") (abs-file-name "") (completions ()))
|
||
|
||
;; ;; Go thru each cmd in powershell's lexicon, finding completions.
|
||
|
||
;; ;; Go thru each dir in the search path, finding completions.
|
||
;; (while path-dirs
|
||
;; (setq dir (file-name-as-directory (comint-directory (or (car path-dirs) ".")))
|
||
;; comps-in-dir (and (file-accessible-directory-p dir)
|
||
;; (file-name-all-completions filenondir dir)))
|
||
;; ;; Go thru each completion found, to see whether it should be used.
|
||
;; (while comps-in-dir
|
||
;; (setq file (car comps-in-dir)
|
||
;; abs-file-name (concat dir file))
|
||
;; (if (and (not (member file completions))
|
||
;; (not (and ignored-extensions
|
||
;; (string-match ignored-extensions file)))
|
||
;; (or (string-equal dir cwd)
|
||
;; (not (file-directory-p abs-file-name)))
|
||
;; (or (null shell-completion-execonly)
|
||
;; (file-executable-p abs-file-name)))
|
||
;; (setq completions (cons file completions)))
|
||
;; (setq comps-in-dir (cdr comps-in-dir)))
|
||
;; (setq path-dirs (cdr path-dirs)))
|
||
;; ;; OK, we've got a list of completions.
|
||
;; (let ((success (let ((comint-completion-addsuffix nil))
|
||
;; (comint-dynamic-simple-complete filenondir completions))))
|
||
;; (if (and (memq success '(sole shortest)) comint-completion-addsuffix
|
||
;; (not (file-directory-p (comint-match-partial-filename))))
|
||
;; (insert " "))
|
||
;; success)))
|
||
|
||
(provide 'powershell)
|
||
|
||
;;; powershell.el ends here
|