DeCarabas/Init-Files
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Some tweaks

Browse source
This commit is contained in:
John Doty 2012-10-06 16:49:27 -07:00
parent 79f0af91c0
commit 92130e2524
4 changed files with 230 additions and 187 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.emacs.d/init.el
View file

@ -317,6 +317,8 @@
(interactive) (interactive)
(indent-region (point-min) (point-max) nil)) (indent-region (point-min) (point-max) nil))
;; (global-set-key (read-kbd-macro "C-i") 'indent-buffer)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; C# Mode support ;;; C# Mode support
;;; ;;;

14
WindowsPowershell/Profile.ps1
View file

@ -71,3 +71,17 @@ function prompt
return ' ' return ' '
} }
function Get-APFile($Path, $Cockpit="BLUINFDPXYIH802:80")
{
$localFile = join-path $pwd (split-path -leaf $Path)
$uri = "http://$Cockpit/files?cmd=get&path=$Path"
Write-Host "Getting $Path to $localFile via $uri"
(New-Object System.Net.Webclient).DownloadFile($uri, $localFile)
}
function Get-Url($Url)
{
(New-Object System.Net.Webclient).DownloadString($Url)
}

BIN
site-lisp/cc-mode/5.32.3/cc-mode-5.32.3.tar
View file

Binary file not shown.

381
site-lisp/powershell-mode.el
View file

@ -1,213 +1,240 @@
;; powershell-mode.el, version 0.5jd ;;; powershell-mode.el --- Mode for editing Powershell scripts
;; Copyright (C) 2009, 2010 Frédéric Perrin
;; Author: Frédéric Perrin <frederic (dot) perrin (arobas) resel (dot) fr>
;; Keywords: Powershell, Monad, MSH
;; 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/>.
;;; Comment:
;; This is still WIP.
;; ;;
;; Author: John Doty (http://friendlyhedgehog.com) ;; This was written from scratch, without using Vivek Sharma's code:
;; Based on the work by Vivek Sharma (http://www.viveksharma.com/techlog) ;; it had issues I wanted to correct, but unfortunately there were no
;; Provides: Major mode for editing PS (PowerShell) scripts ;; licence indication, and Vivek didn't answered my mails.
;; Last Updated: 04/29/11
;; ;;
;; DONE ;; This is still pretty basic: there is indentation, syntax
;; - Indentation support (done) ;; hilighting, speedbar/imenu support. The indentation is pretty naïve
;; - support here strings (done) ;; but robust, and sufficient for my current needs.
;;
;; TODO
;; - C# class support
;; - PowerShell v2 support
;;
;; CHANGES
;; 0.1 - initial version with text highlighting support and indenting
;; 0.2 - fixed file based on feedback to handle xemacs and syntax file changes
;; 0.3 - updated to reflect Monad --> PowerShell name change
;; 0.4 - added manual indentation support, not totally what I'd like, but good enough
;; 0.5 - update from Richard Bielawski (email address excluded till he grants permission to
;; include it :) - Many thanks Richard! Fixes: indenting fixed, elseif keyword added,
;; visiting file bug fixed, standard comment support added. I only tested with latest
;; EmacsWin32, YMMV
;; 0.5jd - JohnDoty started to work on this; nothing quite yet.
(setq debug-on-error t)
;; custom hooks (defvar powershell-indent 4
(defvar powershell-mode-hook nil) "Amount of horizontal space to indent after, for instance, an
opening brace")
;; default mode map, really simple (defvar powershell-continuation-indent 2
(defvar powershell-mode-map "Amount of horizontal space to indent a continuation line")
(let ((powershell-mode-map (make-keymap)))
;; (define-key powershell-mode-map "\r" 'powershell-indent-line)
(define-key powershell-mode-map "\t" 'powershell-indent-line)
;; (define-key powershell-mode-map "{" 'powershell-electric-brace)
;; (define-key powershell-mode-map "}" 'powershell-electric-brace)
powershell-mode-map)
"Keymap for PS major mode")
(defvar powershell-indent-width 4) (defvar powershell-continued-regexp ".*\\(|[\\t ]*\\|`\\)$"
"Regexp matching a continued line (ending either with an
explicit backtick, or with a pipe).")
;; make braces indent properly (defun powershell-continuation-line-p ()
(defun powershell-electric-brace (arg) "Returns t is the current line is a continuation line (i.e. the
"Correct indentation for squigly brace" previous line is a continued line, ending with a backtick or a pipe"
(interactive "P")
(self-insert-command (prefix-numeric-value arg))
(unless
(save-excursion
(beginning-of-line)
(or
;; (looking-at "$\w+") ;Don't do this in a variable
(looking-at "{\s*|[^}]") ;Don't do this in an open procedure block
(looking-at "\"[^\"]*$")) ;Don't do this in a open string
)
(powershell-indent-line)
(forward-char 1)
)
)
;(add-to-list 'auto-mode-alist '("\\.ps1\\'" . powershell-mode))
;; Function to control indenting.
(defun powershell-indent-line ()
"Indent current PowerShell script line"
(interactive) (interactive)
(save-excursion
(forward-line -1)
(looking-at powershell-continued-regexp)))
;; Set the point to beginning of line. (defun powershell-indent-line-amount ()
"Returns the column to which the current line ought to be indented."
(interactive)
(beginning-of-line) (beginning-of-line)
(if (bobp) (let ((closing-paren (looking-at "[\t ]*[])}]")))
(indent-line-to 0) ;; a very simple indentation method: if on a continuation line (i.e. the
;; previous line ends with a trailing backtick or pipe), we indent relative
(let ((not-indented t) (lines-back 0) cur-indent) ;; to the continued line; otherwise, we indent relative to the ([{ that
(if (looking-at "^[ \t]*}") ; Check for closing brace ;; opened the current block.
(if (powershell-continuation-line-p)
(progn (progn
(save-excursion (while (powershell-continuation-line-p)
(forward-line -1) (forward-line -1))
(setq lines-back (+ lines-back 1)) (+ (current-indentation) powershell-continuation-indent))
(if (looking-at "^[ \t]*{") ; If now looking at opening block (condition-case nil
(setq cur-indent (current-indentation)) ;; duplicate indent
(setq cur-indent (- (current-indentation) powershell-indent-width)))
)
;; Safety check to make sure we don't indent negative.
(if (< cur-indent 0)
(setq cur-indent 0)))
(save-excursion
(if (looking-at "^[ \t]*{") ; Opening block
(progn (progn
(forward-line -1) (backward-up-list)
(setq lines-back (+ lines-back 1)) ;; indentation relative to the opening paren: if there is text (no
(setq cur-indent (current-indentation)) ;; comment) after the opening paren, vertically align the block
(setq not-indented nil)) ;; with this text; if we were looking at the closing paren, reset
;; the indentation; otherwise, indent the block by powershell-indent.
(cond ((not (looking-at ".[\t ]*\\(#.*\\)?$"))
(forward-char)
(skip-chars-forward " \t")
(current-column))
(closing-paren
(current-indentation))
(t
(+ (current-indentation) powershell-indent))))
(scan-error ;; most likely, we are at the top-level
0)))))
(while not-indented (defun powershell-indent-line ()
(forward-line -1) "Indent the current line of powershell mode, leaving the point
(setq lines-back (+ lines-back 1)) in place if it is inside the meat of the line"
(if (looking-at "^[ \t]*}") ; Closing block (interactive)
(progn (let ((savep (> (current-column) (current-indentation)))
(setq cur-indent (current-indentation)) (amount (save-excursion (powershell-indent-line-amount))))
(setq not-indented nil)) (if savep
(save-excursion (indent-line-to amount))
(indent-line-to amount))))
(if (looking-at "^[ \t]*{") ; Opening block
(progn ;; Taken from <http://www.manning.com/payette/AppCexcerpt.pdf> which seems the
(setq cur-indent (+ (current-indentation) powershell-indent-width)) ;; closest to a grammar definition for powershell. It is not complete, and
(setq not-indented nil)) ;; contains some inaccuracies (e.g. it says that variables match \$[:alnum:]+,
;; so $_ is not a variable it seems...)
(if (looking-at "^[ \t]*\\(if\\|for\\|foreach\\|function\\|filter\\|else\\|do\\|while\\)\\>") (defvar powershell-keywords
(progn (regexp-opt '("begin" "break" "catch" "continue" "data" "do" "dynamicparam"
(setq cur-indent (current-indentation)) "else" "elseif" "end" "exit" "filter" "finally" "for" "foreach"
(forward-line 1) "from" "function" "if" "in" "param" "process" "return"
(setq lines-back (- lines-back 1)) "switch" "throw" "trap" "try" "until" "while"))
(if (looking-at "^[ \t]*{") ; Has block "Powershell keywords")
(setq not-indented nil)
(if (equal lines-back 0) ; No block
(progn
(setq cur-indent (+ cur-indent powershell-indent-width))
(setq not-indented nil))
(setq not-indented nil)))
)
(if (bobp) (defvar powershell-operators
(setq not-indented nil))))))))) (regexp-opt '("and" "as" "band" "bnot" "bor" "bxor" "casesensitive"
(if cur-indent "ccontains" "ceq" "cge" "cgt" "cle" "clike" "clt" "cmatch"
(indent-line-to cur-indent) "cne" "cnotcontains" "cnotlike" "cnotmatch" "contains"
(indent-line-to 0))))) "creplace" "eq" "exact" "f" "file" "ge" "gt" "icontains"
"ieq" "ige" "igt" "ile" "ilike" "ilt" "imatch" "ine"
"inotcontains" "inotlike" "inotmatch" "ireplace" "is"
"isnot" "le" "like" "lt" "match" "ne" "not" "notcontains"
"notlike" "notmatch" "or" "replace" "wildcard"))
"Powershell operators")
;; only defined one keyword list right now (defvar powershell-scope-names
(regexp-opt
'("env" "function" "global" "local" "private" "script" "variable"))
"Names of scopes in Powershell mode.")
(defconst powershell-font-lock-keywords-3 ;; Taken from Get-Variable on a fresh shell, merged with man
(list ;; about_automatic_variables
'("\\<\\(d\\(?:o\\|efault\\)\\|else\\(if\\)?\\|f\\(?:oreach\\|unction\\|ilter\\)\\|if\\|switch\\|t\\(?:hrow\\|rap\\)\\|w\\(?:here\\|hile\\)\\)\\>" . font-lock-keyword-face) (defvar powershell-builtin-variables
'("$[a-zA-Z0-9_\\.:{}]+\\>" . font-lock-variable-name-face) (regexp-opt
'("\\<\\w+-\\w+\\>" . font-lock-function-name-face) '("^" "_" "$" "?" "Args" "ConfirmPreference" "ConsoleFileName"
'("\\<-\\w+\\>" . font-lock-builtin-face) "DebugPreference" "Error" "ErrorActionPreference" "ErrorView"
'("@'[A-z0-9\n\t ]+'@" . font-lock-string-face) "ExecutionContext" "foreach" "FormatEnumerationLimit" "HOME" "Host"
'("@\"[A-z0-9\n\t ]+\"@" . font-lock-string-face) "Input" "LASTEXITCODE" "MaximumAliasCount" "MaximumDriveCount"
'("\\(-\\)\\([a-z][a-zA-Z0-9]+\\)" . font-lock-type-face)) "MaximumErrorCount" "MaximumFunctionCount" "MaximumHistoryCount"
"Maximum highlighting for PowerShell major mode") "MaximumVariableCount" "MyInvocation" "NestedPromptLevel" "OFS"
"OutputEncoding" "PID" "PROFILE" "PSHOME" "PWD" "ProgressPreference"
"ReportErrorShowExceptionClass" "ReportErrorShowInnerException"
"ReportErrorShowSource" "ReportErrorShowStackTrace" "ShellId"
"ShouldProcessPreference" "ShouldProcessReturnPreference" "StackTrace"
"VerbosePreference" "WarningPreference" "WhatIfPreference" "false"
"input" "lastWord" "line" "null" "true" ))
"Names of the built-in Powershell variables. They are hilighted
differently from the other variables.")
(defvar powershell-font-lock-keywords-1
`(;; Type annotations
("\\[\\([[:word:].]+\\(\\[\\]\\)?\\)\\]" 1 font-lock-type-face)
;; syntaxic keywords
(,(concat "\\<" powershell-keywords "\\>") . font-lock-keyword-face)
;; operators
(,(concat "\\<-" 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 powershell-font-lock-keywords-3 (defvar powershell-font-lock-keywords-2
"Maximum highlighting for PowerShell major mode") (append
powershell-font-lock-keywords-1
`(;; Built-in variables
(,(concat "\\$\\(" powershell-builtin-variables "\\)\\>")
1 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
`(;; Variables in curly brackets
("\\${\\([^}]+\\)}" 1 font-lock-variable-name-face)
;; Variables, with a scope
(,(concat "\\$\\(" powershell-scope-names "\\):"
"\\([[:alnum:]_]+\\)")
(1 (cons font-lock-type-face '(underline)))
(2 font-lock-variable-name-face))
;; Variables, without a scope. XXX: unify this with the
;; previous rule?
("\\$\\([[:alnum:]_]+\\)" 1 font-lock-variable-name-face)
;; hilight properties, but not the methods (personnal preference)
("\\.\\([[:alnum:]_.]+\\)\\>\\s *[^(]" 1 font-lock-variable-name-face)))
"Keywords for the maximum level of font-locking in Powershell mode.")
;; is adding punctuation to word syntax appropriate??
(defvar powershell-mode-syntax-table (make-syntax-table)
"Syntax table for Powershell mode")
(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 ?_ "w" powershell-mode-syntax-table)
(modify-syntax-entry ?# "<" powershell-mode-syntax-table) (modify-syntax-entry ?# "<" powershell-mode-syntax-table)
(modify-syntax-entry ?\n ">" powershell-mode-syntax-table) (modify-syntax-entry ?\n ">" powershell-mode-syntax-table)
;; Powershell uses a backtick as its escape character.
(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)
powershell-mode-syntax-table)
"Syntax for PowerShell major mode")
(defvar powershell-imenu-expression
`(("Functions" "function \\(\\w+\\)" 1)
("Top variables" ,(concat "^\\$\\(" powershell-scope-names "\\)?:?"
"\\([[:alnum:]_]+\\)")
2))
"List of regexps matching important expressions, for speebar & imenu.")
(defvar powershell-imenu-expressions (if (require 'speedbar nil t)
'((nil "^\\(?:function\\|Add-Class\\)\\s-+\\([-a-z0-9A-Z_^:.]+\\)[^-a-z0-9A-Z_^:.]" 1)) (speedbar-add-supported-extension ".ps1?"))
"alist of regexp identifying the start of powershell definitions"
)
(defun powershell-setup-imenu () (require 'compile nil t)
"Installs powershell-imenu-expression." ;; A better command would be something like "powershell.exe -NoLogo
(require 'imenu t) ;; -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")
;; imenu doc says these 3 are buffer-local by default ;; The column number will be off whenever tabs are used. Since this is
(setq imenu-generic-expression powershell-imenu-expressions) ;; the default in this mode, we will not capture the column number.
(imenu-add-menubar-index) (setq compilation-error-regexp-alist
(require 'which-func t) (cons '("At \\(.*\\):\\([0-9]+\\) char:\\([0-9]+\\)" 1 2)
(which-function-mode t) compilation-error-regexp-alist))
)
;; the hook is automatically run by derived-mode
(defvar powershell-mode-hook '(imenu-add-menubar-index)
"Hook run after the initialization of Powershell mode.")
(defun powershell-mode () (define-derived-mode powershell-mode fundamental-mode "PS"
"Major mode for editing PowerShell files" "A major mode for editing Powershell script files."
(interactive) (set (make-local-variable 'indent-line-function) 'powershell-indent-line)
(kill-all-local-variables)
(setq major-mode 'powershell-mode)
(setq mode-name "PS")
(set-syntax-table powershell-mode-syntax-table)
(use-local-map powershell-mode-map)
(set (make-local-variable 'font-lock-defaults) (set (make-local-variable 'font-lock-defaults)
'(powershell-font-lock-keywords)) '((powershell-font-lock-keywords-1
powershell-font-lock-keywords-2
(make-local-variable 'compile-command) powershell-font-lock-keywords-3)
(if buffer-file-name nil t))
(setq compile-command (format "PowerShell -noprofile -nologo -command %s"
(expand-file-name buffer-file-name))))
; Here we register our line indentation function with Emacs. Now Emacs will
; call our function every time line indentation is required (like when the
; user calls indent-region).
;; (make-local-variable 'indent-line-function)
;; (setq indent-line-function 'powershell-indent-line)
; Set indentation defaults.
(make-local-variable 'powershell-indent-width)
(set (make-local-variable 'comment-start) "# ") (set (make-local-variable 'comment-start) "# ")
(powershell-setup-imenu) (set (make-local-variable 'comment-start-skip) "#+\\s*")
(run-hooks 'powershell-mode-hook)) ;; not sure why this is not the default
(set (make-local-variable 'parse-sexp-ignore-comments) t)
(set-syntax-table powershell-mode-syntax-table)
(set (make-local-variable 'imenu-generic-expression)
powershell-imenu-expression)
(set (make-local-variable 'imenu-case-fold-search) nil)
(set (make-local-variable 'compile-command) powershell-compile-command))
(provide 'powershell-mode) (provide 'powershell-mode)