(concat "(" (buffer-string) ")")))))))
(cdr (assq sym mdw-config)))
+;; Local variables hacking.
+
+(defun run-local-vars-mode-hook ()
+ "Run a hook for the major-mode after local variables have been processed."
+ (run-hooks (intern (concat (symbol-name major-mode)
+ "-local-variables-hook"))))
+(add-hook 'hack-local-variables-hook 'run-local-vars-mode-hook)
+
;; Set up the load path convincingly.
(dolist (dir (append (and (boundp 'debian-emacs-flavor)
(and (library-exists-p file)
(autoload symbol file docstring interactivep type)))
+(defun mdw-kick-menu-bar (&optional frame)
+ "Regenerate FRAME's menu bar so it doesn't have empty menus."
+ (interactive)
+ (unless frame (setq frame (selected-frame)))
+ (let ((old (frame-parameter frame 'menu-bar-lines)))
+ (set-frame-parameter frame 'menu-bar-lines 0)
+ (set-frame-parameter frame 'menu-bar-lines old)))
+
;; Splitting windows.
(unless (fboundp 'scroll-bar-columns)
((eq side 'left) 1)
(t 2))))
+(defun mdw-horizontal-window-overhead ()
+ "Computes the horizontal window overhead.
+This is the number of columns used by fringes, scroll bars and other such
+cruft."
+ (if (not window-system)
+ 1
+ (let ((tot 0))
+ (dolist (what '(scroll-bar fringe))
+ (dolist (side '(left right))
+ (incf tot (funcall (intern (concat (symbol-name what) "-columns"))
+ side))))
+ tot)))
+
+(defun mdw-split-window-horizontally (&optional width)
+ "Split a window horizontally.
+Without a numeric argument, split the window approximately in
+half. With a numeric argument WIDTH, allocate WIDTH columns to
+the left-hand window (if positive) or -WIDTH columns to the
+right-hand window (if negative). Space for scroll bars and
+fringes is not taken out of the allowance for WIDTH, unlike
+\\[split-window-horizontally]."
+ (interactive "P")
+ (split-window-horizontally
+ (cond ((null width) nil)
+ ((>= width 0) (+ width (mdw-horizontal-window-overhead)))
+ ((< width 0) width))))
+
(defun mdw-divvy-window (&optional width)
"Split a wide window into appropriate widths."
(interactive "P")
77)
(t 78)))
(let* ((win (selected-window))
- (sb-width (if (not window-system)
- 1
- (let ((tot 0))
- (dolist (what '(scroll-bar fringe))
- (dolist (side '(left right))
- (incf tot
- (funcall (intern (concat (symbol-name what)
- "-columns"))
- side))))
- tot)))
+ (sb-width (mdw-horizontal-window-overhead))
(c (/ (+ (window-width) sb-width)
(+ width sb-width))))
(while (> c 1)
(other-window 1))
(select-window win)))
+;; Don't raise windows unless I say so.
+
+(defvar mdw-inhibit-raise-frame nil
+ "*Whether `raise-frame' should do nothing when the frame is mapped.")
+
+(defadvice raise-frame
+ (around mdw-inhibit (&optional frame) activate compile)
+ "Don't actually do anything if `mdw-inhibit-raise-frame' is true, and the
+frame is actually mapped on the screen."
+ (if mdw-inhibit-raise-frame
+ (make-frame-visible frame)
+ ad-do-it))
+
+(defmacro mdw-advise-to-inhibit-raise-frame (function)
+ "Advise the FUNCTION not to raise frames, even if it wants to."
+ `(defadvice ,function
+ (around mdw-inhibit-raise (&rest hunoz) activate compile)
+ "Don't raise the window unless you have to."
+ (let ((mdw-inhibit-raise-frame t))
+ ad-do-it)))
+
+(mdw-advise-to-inhibit-raise-frame select-frame-set-input-focus)
+
;; Transient mark mode hacks.
(defadvice exchange-point-and-mark
("\\subparagraph{%s}" . "\\subparagraph*{%s}"))
org-export-latex-classes)))
+(setq org-export-docbook-xslt-proc-command "xsltproc --output %o %s %i"
+ org-export-docbook-xsl-fo-proc-command "fop %i.safe %o"
+ org-export-docbook-xslt-stylesheet
+ "/usr/share/xml/docbook/stylesheet/docbook-xsl/fo/docbook.xsl")
+
+;; Some hacks to do with window placement.
+
+(defun mdw-clobber-other-windows-showing-buffer (buffer-or-name)
+ "Arrange that no windows on other frames are showing BUFFER-OR-NAME."
+ (interactive "bBuffer: ")
+ (let ((home-frame (selected-frame))
+ (buffer (get-buffer buffer-or-name))
+ (safe-buffer (get-buffer "*scratch*")))
+ (mapc (lambda (frame)
+ (or (eq frame home-frame)
+ (mapc (lambda (window)
+ (and (eq (window-buffer window) buffer)
+ (set-window-buffer window safe-buffer)))
+ (window-list frame))))
+ (frame-list))))
+
+(defvar mdw-inhibit-walk-windows nil
+ "If non-nil, then `walk-windows' does nothing.
+This is used by advice on `switch-to-buffer-other-frame' to inhibit finding
+buffers in random frames.")
+
+(defadvice walk-windows (around mdw-inhibit activate)
+ "If `mdw-inhibit-walk-windows' is non-nil, then do nothing."
+ (and (not mdw-inhibit-walk-windows)
+ ad-do-it))
+
+(defadvice switch-to-buffer-other-frame
+ (around mdw-always-new-frame activate)
+ "Always make a new frame.
+Even if an existing window in some random frame looks tempting."
+ (let ((mdw-inhibit-walk-windows t)) ad-do-it))
+
+(defadvice display-buffer (before mdw-inhibit-other-frames activate)
+ "Don't try to do anything fancy with other frames.
+Pretend they don't exist. They might be on other display devices."
+ (ad-set-arg 2 nil))
+
;;;--------------------------------------------------------------------------
;;; Mail and news hacking.
(setenv "REAL_MOVEMAIL" try))
(setq path (cdr path)))))
+(eval-after-load "erc"
+ '(load "~/.ercrc.el"))
+
;;;--------------------------------------------------------------------------
;;; Utility functions.
(select-window window)))))
(defvar mdw-good-url-browsers
- '((w3m . mdw-w3m-browse-url)
- browse-url-w3
- browse-url-mozilla)
+ '(browse-url-mozilla
+ browse-url-generic
+ (w3m . mdw-w3m-browse-url)
+ browse-url-w3)
"List of good browsers for mdw-good-url-browsers.
Each item is a browser function name, or a cons (CHECK . FUNC).
A symbol FOO stands for (FOO . FOO).")
;; Utility functions.
-(defun mdw-tabify (s)
- "Tabify the string S. This is a horrid hack."
- (save-excursion
- (save-match-data
- (let (start end)
- (beginning-of-line)
- (setq start (point-marker))
+(defun mdw-maybe-tabify (s)
+ "Tabify or untabify the string S, according to `indent-tabs-mode'."
+ (let ((tabfun (if indent-tabs-mode #'tabify #'untabify)))
+ (with-temp-buffer
+ (save-match-data
(insert s "\n")
- (setq end (point-marker))
- (tabify start end)
- (setq s (buffer-substring start (1- end)))
- (delete-region start end)
- (set-marker start nil)
- (set-marker end nil)
- s))))
+ (let ((start (point-min)) (end (point-max)))
+ (funcall tabfun (point-min) (point-max))
+ (setq s (buffer-substring (point-min) (1- (point-max)))))))))
(defun mdw-examine-fill-prefixes (l)
"Given a list of dynamic fill prefixes, pick one which matches
at the start of a line, and match data must be saved."
(cond ((not l) nil)
((looking-at (car (car l)))
- (mdw-tabify (apply (function concat)
- (mapcar (function mdw-do-prefix-match)
- (cdr (car l))))))
+ (mdw-maybe-tabify (apply #'concat
+ (mapcar #'mdw-do-prefix-match
+ (cdr (car l))))))
(t (mdw-examine-fill-prefixes (cdr l)))))
(defun mdw-maybe-car (p)
(mdw-whitespace-mode 1)
(and (fboundp 'gtags-mode)
(gtags-mode))
- (outline-minor-mode t)
- (hs-minor-mode t)
+ (if (fboundp 'hs-minor-mode)
+ (trap (hs-minor-mode t))
+ (outline-minor-mode t))
(reveal-mode t)
(trap (turn-on-font-lock)))
(add-hook 'delete-frame-functions 'mdw-last-one-out-turn-off-the-lights)
;;;--------------------------------------------------------------------------
+;;; Where is point?
+
+(defvar mdw-point-overlay
+ (let ((ov (make-overlay 0 0))
+ (s "."))
+ (overlay-put ov 'priority 2)
+ (put-text-property 0 1 'display '(left-fringe vertical-bar) s)
+ (overlay-put ov 'before-string s)
+ (delete-overlay ov)
+ ov)
+ "An overlay used for showing where point is in the selected window.")
+
+(defun mdw-remove-point-overlay ()
+ "Remove the current-point overlay."
+ (delete-overlay mdw-point-overlay))
+
+(defun mdw-update-point-overlay ()
+ "Mark the current point position with an overlay."
+ (if (not mdw-point-overlay-mode)
+ (mdw-remove-point-overlay)
+ (overlay-put mdw-point-overlay 'window (selected-window))
+ (if (bolp)
+ (move-overlay mdw-point-overlay
+ (point) (1+ (point)) (current-buffer))
+ (move-overlay mdw-point-overlay
+ (1- (point)) (point) (current-buffer)))))
+
+(defvar mdw-point-overlay-buffers nil
+ "List of buffers using `mdw-point-overlay-mode'.")
+
+(define-minor-mode mdw-point-overlay-mode
+ "Indicate current line with an overlay."
+ :global nil
+ (let ((buffer (current-buffer)))
+ (setq mdw-point-overlay-buffers
+ (mapcan (lambda (buf)
+ (if (and (buffer-live-p buf)
+ (not (eq buf buffer)))
+ (list buf)))
+ mdw-point-overlay-buffers))
+ (if mdw-point-overlay-mode
+ (setq mdw-point-overlay-buffers
+ (cons buffer mdw-point-overlay-buffers))))
+ (cond (mdw-point-overlay-buffers
+ (add-hook 'pre-command-hook 'mdw-remove-point-overlay)
+ (add-hook 'post-command-hook 'mdw-update-point-overlay))
+ (t
+ (mdw-remove-point-overlay)
+ (remove-hook 'pre-command-hook 'mdw-remove-point-overlay)
+ (remove-hook 'post-command-hook 'mdw-update-point-overlay))))
+
+(define-globalized-minor-mode mdw-global-point-overlay-mode
+ mdw-point-overlay-mode
+ (lambda () (if (not (minibufferp)) (mdw-point-overlay-mode t))))
+
+;;;--------------------------------------------------------------------------
+;;; Fullscreen-ness.
+
+(defvar mdw-full-screen-parameters
+ '((menu-bar-lines . 0)
+ ;(vertical-scroll-bars . nil)
+ )
+ "Frame parameters to set when making a frame fullscreen.")
+
+(defvar mdw-full-screen-save
+ '(width height)
+ "Extra frame parameters to save when setting fullscreen.")
+
+(defun mdw-toggle-full-screen (&optional frame)
+ "Show the FRAME fullscreen."
+ (interactive)
+ (when window-system
+ (cond ((frame-parameter frame 'fullscreen)
+ (set-frame-parameter frame 'fullscreen nil)
+ (modify-frame-parameters
+ nil
+ (or (frame-parameter frame 'mdw-full-screen-saved)
+ (mapcar (lambda (assoc)
+ (assq (car assoc) default-frame-alist))
+ mdw-full-screen-parameters))))
+ (t
+ (let ((saved (mapcar (lambda (param)
+ (cons param (frame-parameter frame param)))
+ (append (mapcar #'car
+ mdw-full-screen-parameters)
+ mdw-full-screen-save))))
+ (set-frame-parameter frame 'mdw-full-screen-saved saved))
+ (modify-frame-parameters frame mdw-full-screen-parameters)
+ (set-frame-parameter frame 'fullscreen 'fullboth)))))
+
+;;;--------------------------------------------------------------------------
;;; General fontification.
(defmacro mdw-define-face (name &rest body)
(mdw-define-face default
(((type w32)) :family "courier new" :height 85)
- (((type x)) :family "6x13" :height 130)
+ (((type x)) :family "6x13" :foundry "trad" :height 130)
(((type color)) :foreground "white" :background "black")
(t nil))
(mdw-define-face fixed-pitch
(((type w32)) :family "courier new" :height 85)
- (((type x)) :family "6x13" :height 130)
+ (((type x)) :family "6x13" :foundry "trad" :height 130)
(t :foreground "white" :background "black"))
(if (>= emacs-major-version 23)
(mdw-define-face variable-pitch
(((type tty) (class color)) :background "blue")
(((type tty) (class mono)) :inverse-video t)
(t :background "grey30"))
+(mdw-define-face match
+ (((type tty) (class color)) :background "blue")
+ (((type tty) (class mono)) :inverse-video t)
+ (t :background "blue"))
+(mdw-define-face mc/cursor-face
+ (((type tty) (class mono)) :inverse-video t)
+ (t :background "red"))
(mdw-define-face minibuffer-prompt
(t :weight bold))
(mdw-define-face mode-line
(((class color)) :foreground "yellow" :background "blue"
:box (:line-width 1 :style released-button))
(t :inverse-video t))
+(mdw-define-face nobreak-space
+ (((type tty)))
+ (t :inherit escape-glyph :underline t))
(mdw-define-face scroll-bar
(t :foreground "black" :background "lightgrey"))
(mdw-define-face fringe
(((class color)) :background "red")
(t :inverse-video t))
(mdw-define-face highlight
- (((class color)) :background "DarkSeaGreen4")
+ (((type x) (class color)) :background "DarkSeaGreen4")
+ (((type tty) (class color)) :background "cyan")
(t :inverse-video t))
(mdw-define-face holiday-face
(mdw-define-face comint-highlight-input
(t nil))
+(mdw-define-face dired-directory
+ (t :foreground "cyan" :weight bold))
+(mdw-define-face dired-symlink
+ (t :foreground "cyan"))
+(mdw-define-face dired-perm-write
+ (t nil))
+
(mdw-define-face trailing-whitespace
(((class color)) :background "red")
(t :inverse-video t))
(((type tty)) :foreground "yellow") (t :foreground "burlywood2"))
(mdw-define-face mdw-number-face
(t :foreground "yellow"))
+(mdw-define-face mdw-trivial-face)
(mdw-define-face font-lock-function-name-face
(t :slant italic))
(mdw-define-face font-lock-keyword-face
(mdw-define-face font-lock-string-face
(((class mono)) :weight bold)
(((class color)) :foreground "SkyBlue1"))
+
(mdw-define-face message-separator
(t :background "red" :foreground "white" :weight bold))
(mdw-define-face message-cited-text
(((type tty)) :foreground "green") (t :foreground "SeaGreen1"))
(mdw-define-face message-header-name
(((type tty)) :foreground "green") (t :foreground "SeaGreen1"))
+(mdw-define-face which-func
+ (t nil))
+(mdw-define-face diff-header
+ (t nil))
(mdw-define-face diff-index
(t :weight bold))
(mdw-define-face diff-file-header
(t :foreground "red"))
(mdw-define-face diff-context
(t nil))
+(mdw-define-face diff-refine-change
+ (((class color) (type x)) :background "RoyalBlue4")
+ (t :underline t))
+
+(mdw-define-face dylan-header-background
+ (((class color) (type x)) :background "NavyBlue")
+ (t :background "blue"))
+
+(mdw-define-face magit-diff-add
+ (t :foreground "green"))
+(mdw-define-face magit-diff-del
+ (t :foreground "red"))
+(mdw-define-face magit-diff-file-header
+ (t :weight bold))
+(mdw-define-face magit-diff-hunk-header
+ (t :foreground "SkyBlue1"))
+(mdw-define-face magit-item-highlight
+ (((type tty)) :background "blue")
+ (t :background "DarkSeaGreen4"))
+(mdw-define-face magit-log-head-label-remote
+ (((type tty)) :background "cyan" :foreground "green")
+ (t :background "grey11" :foreground "DarkSeaGreen2" :box t))
+(mdw-define-face magit-log-head-label-local
+ (((type tty)) :background "cyan" :foreground "yellow")
+ (t :background "grey11" :foreground "LightSkyBlue1" :box t))
+(mdw-define-face magit-log-head-label-tags
+ (((type tty)) :background "red" :foreground "yellow")
+ (t :background "LemonChiffon1" :foreground "goldenrod4" :box t))
+(mdw-define-face magit-log-graph
+ (((type tty)) :foreground "magenta")
+ (t :foreground "grey80"))
(mdw-define-face erc-input-face
(t :foreground "red"))
(mdw-define-face woman-italic
(t :slant italic))
+(eval-after-load "rst"
+ '(progn
+ (mdw-define-face rst-level-1-face
+ (t :foreground "SkyBlue1" :weight bold))
+ (mdw-define-face rst-level-2-face
+ (t :foreground "SeaGreen1" :weight bold))
+ (mdw-define-face rst-level-3-face
+ (t :weight bold))
+ (mdw-define-face rst-level-4-face
+ (t :slant italic))
+ (mdw-define-face rst-level-5-face
+ (t :underline t))
+ (mdw-define-face rst-level-6-face
+ ())))
+
(mdw-define-face p4-depot-added-face
(t :foreground "green"))
(mdw-define-face p4-depot-branch-op-face
(mdw-define-face p4-diff-ins-face
(t :foreground "green"))
+(mdw-define-face w3m-anchor-face
+ (t :foreground "SkyBlue1" :underline t))
+(mdw-define-face w3m-arrived-anchor-face
+ (t :foreground "SkyBlue1" :underline t))
+
(mdw-define-face whizzy-slice-face
(t :background "grey10"))
(mdw-define-face whizzy-error-face
(t :background "darkred"))
+;; Ellipses used to indicate hidden text (and similar).
+(mdw-define-face mdw-ellipsis-face
+ (((type tty)) :foreground "blue") (t :foreground "grey60"))
+(let ((dollar (make-glyph-code ?$ 'mdw-ellipsis-face))
+ (backslash (make-glyph-code ?\ 'mdw-ellipsis-face))
+ (dot (make-glyph-code ?. 'mdw-ellipsis-face))
+ (bar (make-glyph-code ?| mdw-ellipsis-face)))
+ (set-display-table-slot standard-display-table 0 dollar)
+ (set-display-table-slot standard-display-table 1 backslash)
+ (set-display-table-slot standard-display-table 4
+ (vector dot dot dot))
+ (set-display-table-slot standard-display-table 5 bar))
+
;;;--------------------------------------------------------------------------
;;; C programming configuration.
(arglist-cont-nonempty . mdw-c-lineup-arglist)
(topmost-intro . mdw-c-indent-extern-mumble)
(cpp-define-intro . 0)
+ (knr-argdecl . 0)
(inextern-lang . [0])
(label . 0)
(case-label . +)
(access-label . -)
(inclass . +)
(inline-open . ++)
- (statement-cont . 0)
+ (statement-cont . +)
(statement-case-intro . +)))
t))
"explicit" ;C++
"export" ;C++
"extern" ;K&R, C89
- "false" ;C++, C9X macro
"float" ;K&R, C89
"for" ;K&R, C89
;; "fortran" ;K&R
"struct" ;K&R, C89
"switch" ;K&R, C89
"template" ;C++
- "this" ;C++
"throw" ;C++
- "true" ;C++, C9X macro
"try" ;C++
"this" ;C++
"typedef" ;C89
"__typeof__" ;GCC
"__volatile__" ;GCC
))
+ (c-constants
+ (mdw-regexps "false" ;C++, C9X macro
+ "this" ;C++
+ "true" ;C++, C9X macro
+ ))
(preprocessor-keywords
(mdw-regexps "assert" "define" "elif" "else" "endif" "error"
"ident" "if" "ifdef" "ifndef" "import" "include"
(list (concat "\\<\\(" c-keywords "\\)\\>")
'(0 font-lock-keyword-face))
+ (list (concat "\\<\\(" c-constants "\\)\\>")
+ '(0 font-lock-variable-name-face))
+
;; Handle numbers too.
;;
;; This looks strange, I know. It corresponds to the
"for" "goto" "if" "implements" "import" "instanceof"
"int" "interface" "long" "native" "new" "package"
"private" "protected" "public" "return" "short"
- "static" "super" "switch" "synchronized" "this"
- "throw" "throws" "transient" "try" "void" "volatile"
- "while"
+ "static" "switch" "synchronized" "throw" "throws"
+ "transient" "try" "void" "volatile" "while"))
- "false" "null" "true")))
+ (java-constants
+ (mdw-regexps "false" "null" "super" "this" "true")))
(setq font-lock-keywords
(list
(list (concat "\\<\\(" java-keywords "\\)\\>")
'(0 font-lock-keyword-face))
+ ;; Handle the magic constants defined above.
+ (list (concat "\\<\\(" java-constants "\\)\\>")
+ '(0 font-lock-variable-name-face))
+
;; Handle numbers too.
;;
;; The following isn't quite right, but it's close enough.
(mdw-post-config-mode-hack))
;;;--------------------------------------------------------------------------
+;;; Javascript programming configuration.
+
+(defun mdw-javascript-style ()
+ (setq js-indent-level 2)
+ (setq js-expr-indent-offset 0))
+
+(defun mdw-fontify-javascript ()
+
+ ;; Other stuff.
+ (mdw-javascript-style)
+ (setq js-auto-indent-flag t)
+
+ ;; Now define things to be fontified.
+ (make-local-variable 'font-lock-keywords)
+ (let ((javascript-keywords
+ (mdw-regexps "abstract" "boolean" "break" "byte" "case" "catch"
+ "char" "class" "const" "continue" "debugger" "default"
+ "delete" "do" "double" "else" "enum" "export" "extends"
+ "final" "finally" "float" "for" "function" "goto" "if"
+ "implements" "import" "in" "instanceof" "int"
+ "interface" "let" "long" "native" "new" "package"
+ "private" "protected" "public" "return" "short"
+ "static" "super" "switch" "synchronized" "throw"
+ "throws" "transient" "try" "typeof" "var" "void"
+ "volatile" "while" "with" "yield"
+
+ "boolean" "byte" "char" "double" "float" "int" "long"
+ "short" "void"))
+ (javascript-constants
+ (mdw-regexps "false" "null" "undefined" "Infinity" "NaN" "true"
+ "arguments" "this")))
+
+ (setq font-lock-keywords
+ (list
+
+ ;; Handle the keywords defined above.
+ (list (concat "\\_<\\(" javascript-keywords "\\)\\_>")
+ '(0 font-lock-keyword-face))
+
+ ;; Handle the predefined constants defined above.
+ (list (concat "\\_<\\(" javascript-constants "\\)\\_>")
+ '(0 font-lock-variable-name-face))
+
+ ;; Handle numbers too.
+ ;;
+ ;; The following isn't quite right, but it's close enough.
+ (list (concat "\\_<\\("
+ "0\\([xX][0-9a-fA-F]+\\|[0-7]+\\)\\|"
+ "[0-9]+\\(\\.[0-9]*\\|\\)"
+ "\\([eE]\\([-+]\\|\\)[0-9]+\\|\\)\\)"
+ "[lLfFdD]?")
+ '(0 mdw-number-face))
+
+ ;; And anything else is punctuation.
+ (list "\\(\\s.\\|\\s(\\|\\s)\\|\\s\\\\|\\s/\\)"
+ '(0 mdw-punct-face)))))
+
+ (mdw-post-config-mode-hack))
+
+;;;--------------------------------------------------------------------------
+;;; Scala programming configuration.
+
+(defun mdw-fontify-scala ()
+
+ ;; Comment filling.
+ (setq mdw-fill-prefix mdw-c-comment-fill-prefix)
+
+ ;; Define things to be fontified.
+ (make-local-variable 'font-lock-keywords)
+ (let ((scala-keywords
+ (mdw-regexps "abstract" "case" "catch" "class" "def" "do" "else"
+ "extends" "final" "finally" "for" "forSome" "if"
+ "implicit" "import" "lazy" "match" "new" "object"
+ "override" "package" "private" "protected" "return"
+ "sealed" "throw" "trait" "try" "type" "val"
+ "var" "while" "with" "yield"))
+ (scala-constants
+ (mdw-regexps "false" "null" "super" "this" "true"))
+ (punctuation "[-!%^&*=+:@#~/?\\|`]"))
+
+ (setq font-lock-keywords
+ (list
+
+ ;; Magical identifiers between backticks.
+ (list (concat "`\\([^`]+\\)`")
+ '(1 font-lock-variable-name-face))
+
+ ;; Handle the keywords defined above.
+ (list (concat "\\_<\\(" scala-keywords "\\)\\_>")
+ '(0 font-lock-keyword-face))
+
+ ;; Handle the constants defined above.
+ (list (concat "\\_<\\(" scala-constants "\\)\\_>")
+ '(0 font-lock-variable-name-face))
+
+ ;; Magical identifiers between backticks.
+ (list (concat "`\\([^`]+\\)`")
+ '(1 font-lock-variable-name-face))
+
+ ;; Handle numbers too.
+ ;;
+ ;; As usual, not quite right.
+ (list (concat "\\_<\\("
+ "0\\([xX][0-9a-fA-F]+\\|[0-7]+\\)\\|"
+ "[0-9]+\\(\\.[0-9]*\\|\\)"
+ "\\([eE]\\([-+]\\|\\)[0-9]+\\|\\)\\)"
+ "[lLfFdD]?")
+ '(0 mdw-number-face))
+
+ ;; Identifiers with trailing operators.
+ (list (concat "_\\(" punctuation "\\)+")
+ '(0 mdw-trivial-face))
+
+ ;; And everything else is punctuation.
+ (list "\\(\\s.\\|\\s(\\|\\s)\\|\\s\\\\|\\s/\\)"
+ '(0 mdw-punct-face)))
+
+ font-lock-syntactic-keywords
+ (list
+
+ ;; Single quotes around characters. But not when used to quote
+ ;; symbol names. Ugh.
+ (list (concat "\\('\\)"
+ "\\(" "."
+ "\\|" "\\\\" "\\(" "\\\\\\\\" "\\)*"
+ "u+" "[0-9a-fA-F]\\{4\\}"
+ "\\|" "\\\\" "[0-7]\\{1,3\\}"
+ "\\|" "\\\\" "." "\\)"
+ "\\('\\)")
+ '(1 "\"")
+ '(4 "\"")))))
+
+ (mdw-post-config-mode-hack))
+
+;;;--------------------------------------------------------------------------
;;; C# programming configuration.
;; Make indentation nice.
;; Now define things to be fontified.
(make-local-variable 'font-lock-keywords)
(let ((csharp-keywords
- (mdw-regexps "abstract" "as" "base" "bool" "break"
- "byte" "case" "catch" "char" "checked"
- "class" "const" "continue" "decimal" "default"
- "delegate" "do" "double" "else" "enum"
- "event" "explicit" "extern" "false" "finally"
- "fixed" "float" "for" "foreach" "goto"
- "if" "implicit" "in" "int" "interface"
- "internal" "is" "lock" "long" "namespace"
- "new" "null" "object" "operator" "out"
- "override" "params" "private" "protected" "public"
- "readonly" "ref" "return" "sbyte" "sealed"
- "short" "sizeof" "stackalloc" "static" "string"
- "struct" "switch" "this" "throw" "true"
- "try" "typeof" "uint" "ulong" "unchecked"
- "unsafe" "ushort" "using" "virtual" "void"
- "volatile" "while" "yield")))
+ (mdw-regexps "abstract" "as" "bool" "break" "byte" "case" "catch"
+ "char" "checked" "class" "const" "continue" "decimal"
+ "default" "delegate" "do" "double" "else" "enum"
+ "event" "explicit" "extern" "finally" "fixed" "float"
+ "for" "foreach" "goto" "if" "implicit" "in" "int"
+ "interface" "internal" "is" "lock" "long" "namespace"
+ "new" "object" "operator" "out" "override" "params"
+ "private" "protected" "public" "readonly" "ref"
+ "return" "sbyte" "sealed" "short" "sizeof"
+ "stackalloc" "static" "string" "struct" "switch"
+ "throw" "try" "typeof" "uint" "ulong" "unchecked"
+ "unsafe" "ushort" "using" "virtual" "void" "volatile"
+ "while" "yield"))
+
+ (csharp-constants
+ (mdw-regexps "base" "false" "null" "this" "true")))
(setq font-lock-keywords
(list
(list (concat "\\<\\(" csharp-keywords "\\)\\>")
'(0 font-lock-keyword-face))
+ ;; Handle the magic constants defined above.
+ (list (concat "\\<\\(" csharp-constants "\\)\\>")
+ '(0 font-lock-variable-name-face))
+
;; Handle numbers too.
;;
;; The following isn't quite right, but it's close enough.
"Major mode for editing C# code.")
;;;--------------------------------------------------------------------------
+;;; F# programming configuration.
+
+(setq fsharp-indent-offset 2)
+
+(defun mdw-fontify-fsharp ()
+
+ (let ((punct "=<>+-*/|&%!@?"))
+ (do ((i 0 (1+ i)))
+ ((>= i (length punct)))
+ (modify-syntax-entry (aref punct i) ".")))
+
+ (modify-syntax-entry ?_ "_")
+ (modify-syntax-entry ?( "(")
+ (modify-syntax-entry ?) ")")
+
+ (setq indent-tabs-mode nil)
+
+ (let ((fsharp-keywords
+ (mdw-regexps "abstract" "and" "as" "assert" "atomic"
+ "begin" "break"
+ "checked" "class" "component" "const" "constraint"
+ "constructor" "continue"
+ "default" "delegate" "do" "done" "downcast" "downto"
+ "eager" "elif" "else" "end" "exception" "extern"
+ "finally" "fixed" "for" "fori" "fun" "function"
+ "functor"
+ "global"
+ "if" "in" "include" "inherit" "inline" "interface"
+ "internal"
+ "lazy" "let"
+ "match" "measure" "member" "method" "mixin" "module"
+ "mutable"
+ "namespace" "new"
+ "object" "of" "open" "or" "override"
+ "parallel" "params" "private" "process" "protected"
+ "public" "pure"
+ "rec" "recursive" "return"
+ "sealed" "sig" "static" "struct"
+ "tailcall" "then" "to" "trait" "try" "type"
+ "upcast" "use"
+ "val" "virtual" "void" "volatile"
+ "when" "while" "with"
+ "yield"))
+
+ (fsharp-builtins
+ (mdw-regexps "asr" "land" "lor" "lsl" "lsr" "lxor" "mod"
+ "base" "false" "null" "true"))
+
+ (bang-keywords
+ (mdw-regexps "do" "let" "return" "use" "yield"))
+
+ (preprocessor-keywords
+ (mdw-regexps "if" "indent" "else" "endif")))
+
+ (setq font-lock-keywords
+ (list (list (concat "\\(^\\|[^\"]\\)"
+ "\\(" "(\\*"
+ "[^*]*\\*+"
+ "\\(" "[^)*]" "[^*]*" "\\*+" "\\)*"
+ ")"
+ "\\|"
+ "//.*"
+ "\\)")
+ '(2 font-lock-comment-face))
+
+ (list (concat "'" "\\("
+ "\\\\"
+ "\\(" "[ntbr'\\]"
+ "\\|" "[0-9][0-9][0-9]"
+ "\\|" "u" "[0-9a-fA-F]\\{4\\}"
+ "\\|" "U" "[0-9a-fA-F]\\{8\\}"
+ "\\)"
+ "\\|"
+ "." "\\)" "'"
+ "\\|"
+ "\"" "[^\"\\]*"
+ "\\(" "\\\\" "\\(.\\|\n\\)"
+ "[^\"\\]*" "\\)*"
+ "\\(\"\\|\\'\\)")
+ '(0 font-lock-string-face))
+
+ (list (concat "\\_<\\(" bang-keywords "\\)!" "\\|"
+ "^#[ \t]*\\(" preprocessor-keywords "\\)\\_>"
+ "\\|"
+ "\\_<\\(" fsharp-keywords "\\)\\_>")
+ '(0 font-lock-keyword-face))
+ (list (concat "\\<\\(" fsharp-builtins "\\)\\_>")
+ '(0 font-lock-variable-name-face))
+
+ (list (concat "\\_<"
+ "\\(" "0[bB][01]+" "\\|"
+ "0[oO][0-7]+" "\\|"
+ "0[xX][0-9a-fA-F]+" "\\)"
+ "\\(" "lf\\|LF" "\\|"
+ "[uU]?[ysnlL]?" "\\)"
+ "\\|"
+ "\\_<"
+ "[0-9]+" "\\("
+ "[mMQRZING]"
+ "\\|"
+ "\\(\\.[0-9]*\\)?"
+ "\\([eE][-+]?[0-9]+\\)?"
+ "[fFmM]?"
+ "\\|"
+ "[uU]?[ysnlL]?"
+ "\\)")
+ '(0 mdw-number-face))
+
+ (list "\\(\\s.\\|\\s(\\|\\s)\\|\\s\\\\|\\s/\\)"
+ '(0 mdw-punct-face)))))
+
+ (mdw-post-config-mode-hack))
+
+(defun mdw-fontify-inferior-fsharp ()
+ (mdw-fontify-fsharp)
+ (setq font-lock-keywords
+ (append (list (list "^[#-]" '(0 font-lock-comment-face))
+ (list "^>" '(0 font-lock-keyword-face)))
+ font-lock-keywords)))
+
+;;;--------------------------------------------------------------------------
;;; Go programming configuration.
(defun mdw-fontify-go ()
"default" "defer" "else" "fallthrough" "for"
"func" "go" "goto" "if" "import"
"interface" "map" "package" "range" "return"
- "select" "struct" "switch" "type" "var")))
+ "select" "struct" "switch" "type" "var"))
+ (go-intrinsics
+ (mdw-regexps "bool" "byte" "complex64" "complex128" "error"
+ "float32" "float64" "int" "uint8" "int16" "int32"
+ "int64" "rune" "string" "uint" "uint8" "uint16"
+ "uint32" "uint64" "uintptr" "void"
+ "false" "iota" "nil" "true"
+ "init" "main"
+ "append" "cap" "copy" "delete" "imag" "len" "make"
+ "new" "panic" "real" "recover")))
(setq font-lock-keywords
(list
;; Handle the keywords defined above.
(list (concat "\\<\\(" go-keywords "\\)\\>")
'(0 font-lock-keyword-face))
+ (list (concat "\\<\\(" go-intrinsics "\\)\\>")
+ '(0 font-lock-variable-name-face))
+
+ ;; Strings and characters.
+ (list (concat "'"
+ "\\(" "[^\\']" "\\|"
+ "\\\\"
+ "\\(" "[abfnrtv\\'\"]" "\\|"
+ "[0-7]\\{3\\}" "\\|"
+ "x" "[0-9A-Fa-f]\\{2\\}" "\\|"
+ "u" "[0-9A-Fa-f]\\{4\\}" "\\|"
+ "U" "[0-9A-Fa-f]\\{8\\}" "\\)" "\\)"
+ "'"
+ "\\|"
+ "\""
+ "\\(" "[^\n\\\"]+" "\\|" "\\\\." "\\)*"
+ "\\(\"\\|$\\)"
+ "\\|"
+ "`" "[^`]+" "`")
+ '(0 font-lock-string-face))
;; Handle numbers too.
;;
;; Now define fontification things.
(make-local-variable 'font-lock-keywords)
(let ((perl-keywords
- (mdw-regexps "and" "cmp" "continue" "do" "else" "elsif" "eq"
- "for" "foreach" "ge" "gt" "goto" "if"
+ (mdw-regexps "and" "break" "cmp" "continue" "do" "else" "elsif" "eq"
+ "for" "foreach" "ge" "given" "gt" "goto" "if"
"last" "le" "lt" "local" "my" "ne" "next" "or"
- "package" "redo" "require" "return" "sub"
- "undef" "unless" "until" "use" "while")))
+ "our" "package" "redo" "require" "return" "sub"
+ "undef" "unless" "until" "use" "when" "while")))
(setq font-lock-keywords
(list
(list
;; Set up the keywords defined above.
- (list (concat "\\<\\(" keywords "\\)\\>")
+ (list (concat "\\_<\\(" keywords "\\)\\_>")
'(0 font-lock-keyword-face))
;; At least numbers are simpler than C.
- (list (concat "\\<0\\([xX][0-9a-fA-F_]+\\|[0-7_]+\\)\\|"
- "\\<[0-9][0-9_]*\\(\\.[0-9_]*\\|\\)"
+ (list (concat "\\_<0\\([xX][0-9a-fA-F_]+\\|[0-7_]+\\)\\|"
+ "\\_<[0-9][0-9_]*\\(\\.[0-9_]*\\|\\)"
"\\([eE]\\([-+]\\|\\)[0-9_]+\\|[lL]\\|\\)")
'(0 mdw-number-face))
(mdw-post-config-mode-hack))
;;;--------------------------------------------------------------------------
-;;; ARM assembler programming configuration.
-
-;; There doesn't appear to be an Emacs mode for this yet.
-;;
-;; Better do something about that, I suppose.
-
-(defvar arm-assembler-mode-map nil)
-(defvar arm-assembler-abbrev-table nil)
-(defvar arm-assembler-mode-syntax-table (make-syntax-table))
-
-(or arm-assembler-mode-map
- (progn
- (setq arm-assembler-mode-map (make-sparse-keymap))
- (define-key arm-assembler-mode-map "\C-m" 'arm-assembler-newline)
- (define-key arm-assembler-mode-map [C-return] 'newline)
- (define-key arm-assembler-mode-map "\t" 'tab-to-tab-stop)))
-
-(defun arm-assembler-mode ()
- "Major mode for ARM assembler programs"
- (interactive)
-
- ;; Do standard major mode things.
- (kill-all-local-variables)
- (use-local-map arm-assembler-mode-map)
- (setq local-abbrev-table arm-assembler-abbrev-table)
- (setq major-mode 'arm-assembler-mode)
- (setq mode-name "ARM assembler")
-
- ;; Set up syntax table.
- (set-syntax-table arm-assembler-mode-syntax-table)
- (modify-syntax-entry ?; ; Nasty hack
- "<" arm-assembler-mode-syntax-table)
- (modify-syntax-entry ?\n ">" arm-assembler-mode-syntax-table)
- (modify-syntax-entry ?_ "_" arm-assembler-mode-syntax-table)
-
- (make-local-variable 'comment-start)
- (setq comment-start ";")
- (make-local-variable 'comment-end)
- (setq comment-end "")
- (make-local-variable 'comment-column)
- (setq comment-column 48)
- (make-local-variable 'comment-start-skip)
- (setq comment-start-skip ";+[ \t]*")
-
- ;; Play with indentation.
- (make-local-variable 'indent-line-function)
- (setq indent-line-function 'indent-relative-maybe)
-
- ;; Set fill prefix.
- (mdw-standard-fill-prefix "\\([ \t]*;+[ \t]*\\)")
-
- ;; Fiddle with fontification.
- (make-local-variable 'font-lock-keywords)
- (setq font-lock-keywords
- (list
-
- ;; Handle numbers too.
- ;;
- ;; The following isn't quite right, but it's close enough.
- (list (concat "\\("
- "&[0-9a-fA-F]+\\|"
- "\\<[0-9]+\\(\\.[0-9]*\\|_[0-9a-zA-Z]+\\|\\)"
- "\\)")
- '(0 mdw-number-face))
-
- ;; Do something about operators.
- (list "^[^ \t]*[ \t]+\\(GET\\|LNK\\)[ \t]+\\([^;\n]*\\)"
- '(1 font-lock-keyword-face)
- '(2 font-lock-string-face))
- (list ":[a-zA-Z]+:"
- '(0 font-lock-keyword-face))
-
- ;; Do menemonics and directives.
- (list "^[^ \t]*[ \t]+\\([a-zA-Z]+\\)"
- '(1 font-lock-keyword-face))
-
- ;; And anything else is punctuation.
- (list "\\(\\s.\\|\\s(\\|\\s)\\|\\s\\\\|\\s/\\)"
- '(0 mdw-punct-face)))
-
- (mdw-post-config-mode-hack))
- (run-hooks 'arm-assembler-mode-hook))
-
-;;;--------------------------------------------------------------------------
;;; Assembler mode.
(defun mdw-fontify-asm ()
(modify-syntax-entry ?' "\"")
(modify-syntax-entry ?. "w")
+ (modify-syntax-entry ?; "."
+ )
+ (modify-syntax-entry asm-comment-char "<b")
+ (modify-syntax-entry ?\n ">")
(setf fill-prefix nil)
(mdw-standard-fill-prefix "\\([ \t]*;+[ \t]*\\)"))
+(define-derived-mode x86-asm-mode asm-mode "x86 assembler"
+ "Assembler mode variant which uses `#' as the comment character."
+ (set (make-variable-buffer-local 'asm-comment-char) ?#))
+
+(define-derived-mode arm-asm-mode asm-mode "ARM assembler"
+ "Assembler mode variant which uses `@' as the comment character."
+ (set (make-variable-buffer-local 'asm-comment-char) ?@))
+
;;;--------------------------------------------------------------------------
;;; TCL configuration.
(mdw-post-config-mode-hack))
;;;--------------------------------------------------------------------------
+;;; Dylan programming configuration.
+
+(defun mdw-fontify-dylan ()
+
+ (make-local-variable 'font-lock-keywords)
+
+ ;; Horrors. `dylan-mode' sets the `major-mode' name after calling this
+ ;; hook, which undoes all of our configuration.
+ (setq major-mode 'dylan-mode)
+ (font-lock-set-defaults)
+
+ (let* ((word "[-_a-zA-Z!*@<>$%]+")
+ (dylan-keywords (mdw-regexps
+
+ "C-address" "C-callable-wrapper" "C-function"
+ "C-mapped-subtype" "C-pointer-type" "C-struct"
+ "C-subtype" "C-union" "C-variable"
+
+ "above" "abstract" "afterwards" "all"
+ "begin" "below" "block" "by"
+ "case" "class" "cleanup" "constant" "create"
+ "define" "domain"
+ "else" "elseif" "end" "exception" "export"
+ "finally" "for" "from" "function"
+ "generic"
+ "handler"
+ "if" "in" "instance" "interface" "iterate"
+ "keyed-by"
+ "let" "library" "local"
+ "macro" "method" "module"
+ "otherwise"
+ "profiling"
+ "select" "slot" "subclass"
+ "table" "then" "to"
+ "unless" "until" "use"
+ "variable" "virtual"
+ "when" "while"))
+ (sharp-keywords (mdw-regexps
+ "all-keys" "key" "next" "rest" "include"
+ "t" "f")))
+ (setq font-lock-keywords
+ (list (list (concat "\\<\\(" dylan-keywords
+ "\\|" "with\\(out\\)?-" word
+ "\\)\\>")
+ '(0 font-lock-keyword-face))
+ (list (concat "\\<" word ":" "\\|"
+ "#\\(" sharp-keywords "\\)\\>")
+ '(0 font-lock-variable-name-face))
+ (list (concat "\\("
+ "\\([-+]\\|\\<\\)[0-9]+" "\\("
+ "\\(\\.[0-9]+\\)?" "\\([eE][-+][0-9]+\\)?"
+ "\\|" "/[0-9]+"
+ "\\)"
+ "\\|" "\\.[0-9]+" "\\([eE][-+][0-9]+\\)?"
+ "\\|" "#b[01]+"
+ "\\|" "#o[0-7]+"
+ "\\|" "#x[0-9a-zA-Z]+"
+ "\\)\\>")
+ '(0 mdw-number-face))
+ (list (concat "\\("
+ "\\s.\\|\\s(\\|\\s)\\|\\s\\\\|\\s/\\|"
+ "\\_<[-+*/=<>:&|]+\\_>"
+ "\\)")
+ '(0 mdw-punct-face)))))
+
+ (mdw-post-config-mode-hack))
+
+;;;--------------------------------------------------------------------------
+;;; Algol 68 configuration.
+
+(setq a68-indent-step 2)
+
+(defun mdw-fontify-algol-68 ()
+
+ ;; Fix up the syntax table.
+ (modify-syntax-entry ?# "!" a68-mode-syntax-table)
+ (dolist (ch '(?- ?+ ?= ?< ?> ?* ?/ ?| ?&))
+ (modify-syntax-entry ch "." a68-mode-syntax-table))
+
+ (make-local-variable 'font-lock-keywords)
+
+ (let ((not-comment
+ (let ((word "COMMENT"))
+ (do ((regexp (concat "[^" (substring word 0 1) "]+")
+ (concat regexp "\\|"
+ (substring word 0 i)
+ "[^" (substring word i (1+ i)) "]"))
+ (i 1 (1+ i)))
+ ((>= i (length word)) regexp)))))
+ (setq font-lock-keywords
+ (list (list (concat "\\<COMMENT\\>"
+ "\\(" not-comment "\\)\\{0,5\\}"
+ "\\(\\'\\|\\<COMMENT\\>\\)")
+ '(0 font-lock-comment-face))
+ (list (concat "\\<CO\\>"
+ "\\([^C]+\\|C[^O]\\)\\{0,5\\}"
+ "\\($\\|\\<CO\\>\\)")
+ '(0 font-lock-comment-face))
+ (list "\\<[A-Z_]+\\>"
+ '(0 font-lock-keyword-face))
+ (list (concat "\\<"
+ "[0-9]+"
+ "\\(\\.[0-9]+\\)?"
+ "\\([eE][-+]?[0-9]+\\)?"
+ "\\>")
+ '(0 mdw-number-face))
+ (list "\\s.\\|\\s(\\|\\s)\\|\\s\\\\|\\s/"
+ '(0 mdw-punct-face)))))
+
+ (mdw-post-config-mode-hack))
+
+;;;--------------------------------------------------------------------------
;;; REXX configuration.
(defun mdw-rexx-electric-* ()
(defun mdw-fontify-haskell ()
;; Fiddle with syntax table to get comments right.
- (modify-syntax-entry ?' "\"")
- (modify-syntax-entry ?- ". 123")
- (modify-syntax-entry ?{ ". 1b")
- (modify-syntax-entry ?} ". 4b")
+ (modify-syntax-entry ?' "_")
+ (modify-syntax-entry ?- ". 12")
(modify-syntax-entry ?\n ">")
+ ;; Make punctuation be punctuation
+ (let ((punct "=<>+-*/|&%!@?$.^:#`"))
+ (do ((i 0 (1+ i)))
+ ((>= i (length punct)))
+ (modify-syntax-entry (aref punct i) ".")))
+
;; Set fill prefix.
(mdw-standard-fill-prefix "\\([ \t]*{?--?[ \t]*\\)")
;; Fiddle with fontification.
(make-local-variable 'font-lock-keywords)
(let ((haskell-keywords
- (mdw-regexps "as" "case" "ccall" "class" "data" "default"
- "deriving" "do" "else" "foreign" "hiding" "if"
- "import" "in" "infix" "infixl" "infixr" "instance"
- "let" "module" "newtype" "of" "qualified" "safe"
- "stdcall" "then" "type" "unsafe" "where")))
+ (mdw-regexps "as"
+ "case" "ccall" "class"
+ "data" "default" "deriving" "do"
+ "else" "exists"
+ "forall" "foreign"
+ "hiding"
+ "if" "import" "in" "infix" "infixl" "infixr" "instance"
+ "let"
+ "mdo" "module"
+ "newtype"
+ "of"
+ "proc"
+ "qualified"
+ "rec"
+ "safe" "stdcall"
+ "then" "type"
+ "unsafe"
+ "where"))
+ (control-sequences
+ (mdw-regexps "ACK" "BEL" "BS" "CAN" "CR" "DC1" "DC2" "DC3" "DC4"
+ "DEL" "DLE" "EM" "ENQ" "EOT" "ESC" "ETB" "ETX" "FF"
+ "FS" "GS" "HT" "LF" "NAK" "NUL" "RS" "SI" "SO" "SOH"
+ "SP" "STX" "SUB" "SYN" "US" "VT")))
(setq font-lock-keywords
(list
- (list "--.*$"
+ (list (concat "{-" "[^-]*" "\\(-+[^-}][^-]*\\)*"
+ "\\(-+}\\|-*\\'\\)"
+ "\\|"
+ "--.*$")
'(0 font-lock-comment-face))
- (list (concat "\\<\\(" haskell-keywords "\\)\\>")
+ (list (concat "\\_<\\(" haskell-keywords "\\)\\_>")
'(0 font-lock-keyword-face))
- (list (concat "\\<0\\([xX][0-9a-fA-F]+\\|[0-7]+\\)\\|"
- "\\<[0-9][0-9_]*\\(\\.[0-9]*\\|\\)"
+ (list (concat "'\\("
+ "[^\\]"
+ "\\|"
+ "\\\\"
+ "\\(" "[abfnrtv\\\"']" "\\|"
+ "^" "\\(" control-sequences "\\|"
+ "[]A-Z@[\\^_]" "\\)" "\\|"
+ "\\|"
+ "[0-9]+" "\\|"
+ "[oO][0-7]+" "\\|"
+ "[xX][0-9A-Fa-f]+"
+ "\\)"
+ "\\)'")
+ '(0 font-lock-string-face))
+ (list "\\_<[A-Z]\\(\\sw+\\|\\s_+\\)*\\_>"
+ '(0 font-lock-variable-name-face))
+ (list (concat "\\_<0\\([xX][0-9a-fA-F]+\\|[oO][0-7]+\\)\\|"
+ "\\_<[0-9]+\\(\\.[0-9]*\\|\\)"
"\\([eE]\\([-+]\\|\\)[0-9]+\\|\\)")
'(0 mdw-number-face))
(list "\\(\\s.\\|\\s(\\|\\s)\\|\\s\\\\|\\s/\\)"
;;;--------------------------------------------------------------------------
;;; Erlang configuration.
-(setq erlang-electric-commannds
- '(erlang-electric-newline erlang-electric-semicolon))
+(setq erlang-electric-commands nil)
(defun mdw-fontify-erlang ()
(run-hooks 'mdw-sgml-mode-hook))
;;;--------------------------------------------------------------------------
+;;; Configuration files.
+
+(defvar mdw-conf-quote-normal nil
+ "*Control syntax category of quote characters `\"' and `''.
+If this is `t', consider quote characters to be normal
+punctuation, as for `conf-quote-normal'. If this is `nil' then
+leave quote characters as quotes. If this is a list, then
+consider the quote characters in the list to be normal
+punctuation. If this is a single quote character, then consider
+that character only to be normal punctuation.")
+(defun mdw-conf-quote-normal-acceptable-value-p (value)
+ "Is the VALUE is an acceptable value for `mdw-conf-quote-normal'?"
+ (or (booleanp value)
+ (every (lambda (v) (memq v '(?\" ?')))
+ (if (listp value) value (list value)))))
+(put 'mdw-conf-quote-normal 'safe-local-variable
+ 'mdw-conf-quote-normal-acceptable-value-p)
+
+(defun mdw-fix-up-quote ()
+ "Apply the setting of `mdw-conf-quote-normal'."
+ (let ((flag mdw-conf-quote-normal))
+ (cond ((eq flag t)
+ (conf-quote-normal t))
+ ((not flag)
+ nil)
+ (t
+ (let ((table (copy-syntax-table (syntax-table))))
+ (mapc (lambda (ch) (modify-syntax-entry ch "." table))
+ (if (listp flag) flag (list flag)))
+ (set-syntax-table table)
+ (and font-lock-mode (font-lock-fontify-buffer)))))))
+(add-hook 'conf-mode-local-variables-hook 'mdw-fix-up-quote t t)
+
+;;;--------------------------------------------------------------------------
;;; Shell scripts.
(defun mdw-setup-sh-script-mode ()
(let ((executable-set-magic #'(lambda (s &rest r) s)))
(sh-set-shell shell-name)))
+ ;; Don't insert here-document scaffolding automatically.
+ (local-set-key "<" 'self-insert-command)
+
;; Now enable my keys and the fontification.
(mdw-misc-mode-config)
(setq sh-indentation 2)
(setq sh-basic-offset 2))
+(setq sh-shell-file "/bin/sh")
+
+;; Awful hacking to override the shell detection for particular scripts.
+(defmacro define-custom-shell-mode (name shell)
+ `(defun ,name ()
+ (interactive)
+ (set (make-local-variable 'sh-shell-file) ,shell)
+ (sh-mode)))
+(define-custom-shell-mode bash-mode "/bin/bash")
+(define-custom-shell-mode rc-mode "/usr/bin/rc")
+(put 'sh-shell-file 'permanent-local t)
+
+;; Hack the rc syntax table. Backquotes aren't paired in rc.
+(eval-after-load "sh-script"
+ '(or (assq 'rc sh-mode-syntax-table-input)
+ (let ((frag '(nil
+ ?# "<"
+ ?\n ">#"
+ ?\" "\"\""
+ ?\' "\"\'"
+ ?$ "'"
+ ?\` "."
+ ?! "_"
+ ?% "_"
+ ?. "_"
+ ?^ "_"
+ ?~ "_"
+ ?, "_"
+ ?= "."
+ ?< "."
+ ?> "."))
+ (assoc (assq 'rc sh-mode-syntax-table-input)))
+ (if assoc
+ (rplacd assoc frag)
+ (setq sh-mode-syntax-table-input
+ (cons (cons 'rc frag)
+ sh-mode-syntax-table-input))))))
+
;;;--------------------------------------------------------------------------
;;; Emacs shell mode.
(save-match-data
(replace-regexp-in-string "\\..*$" "" (system-name)))
" "
- (eshell/pwd)
+ (let* ((pwd (eshell/pwd)) (npwd (length pwd))
+ (home (expand-file-name "~")) (nhome (length home)))
+ (if (and (>= npwd nhome)
+ (or (= nhome npwd)
+ (= (elt pwd nhome) ?/))
+ (string= (substring pwd 0 nhome) home))
+ (concat "~" (substring pwd (length home)))
+ pwd))
right)))
(setq eshell-prompt-function 'mdw-eshell-prompt)
(setq eshell-prompt-regexp "^\\[[^]>]+\\(\\]\\|>>?\\)")
-(defalias 'eshell/e 'find-file)
-(defalias 'eshell/w3m 'w3m-goto-url)
+(defun eshell/e (file) (find-file file) nil)
+(defun eshell/ee (file) (find-file-other-window file) nil)
+(defun eshell/w3m (url) (w3m-goto-url url) nil)
(mdw-define-face eshell-prompt (t :weight bold))
(mdw-define-face eshell-ls-archive (t :weight bold :foreground "red"))
(modify-syntax-entry ?\n ">" messages-mode-syntax-table)
(setq comment-start "# ")
(setq comment-end "")
- (turn-on-font-lock-if-enabled)
(run-hooks 'messages-mode-hook))
(defun cpp-messages-mode ()
"\\)\\>\\|[0-9]+\\|$\\)\\)")
'(1 font-lock-keyword-face)))
messages-mode-keywords)))
- (turn-on-font-lock-if-enabled)
(run-hooks 'cpp-messages-mode-hook))
(add-hook 'messages-mode-hook 'mdw-misc-mode-config t)
(modify-syntax-entry ?\n ">" mallow-driver-mode-syntax-table)
(setq comment-start "%# ")
(setq comment-end "")
- (turn-on-font-lock-if-enabled)
(run-hooks 'mallow-driver-mode-hook))
(add-hook 'mallow-driver-hook 'mdw-misc-mode-config t)
'("\\(\\s.\\|\\s(\\|\\s)\\|\\s\\\\|\\s/\\)" (0 mdw-punct-face))))
(setq font-lock-defaults
'(nfast-debug-mode-keywords nil nil nil nil))
- (turn-on-font-lock-if-enabled)
(run-hooks 'nfast-debug-mode-hook))
;;;--------------------------------------------------------------------------
;; Not much fontification needed.
(make-local-variable 'font-lock-keywords)
(setq font-lock-keywords
- (list
- (list "\\(\\s.\\|\\s(\\|\\s)\\|\\s\\\\|\\s/\\)"
- '(0 mdw-punct-face))))
+ (list (list (concat "\\("
+ "\\_<[-+]?"
+ "\\(" "[0-9]+/[0-9]+"
+ "\\|" "\\(" "[0-9]+" "\\(\\.[0-9]*\\)?" "\\|"
+ "\\.[0-9]+" "\\)"
+ "\\([dDeEfFlLsS][-+]?[0-9]+\\)?"
+ "\\)"
+ "\\|"
+ "#"
+ "\\(" "x" "[-+]?"
+ "[0-9A-Fa-f]+" "\\(/[0-9A-Fa-f]+\\)?"
+ "\\|" "o" "[-+]?" "[0-7]+" "\\(/[0-7]+\\)?"
+ "\\|" "b" "[-+]?" "[01]+" "\\(/[01]+\\)?"
+ "\\|" "[0-9]+" "r" "[-+]?"
+ "[0-9a-zA-Z]+" "\\(/[0-9a-zA-Z]+\\)?"
+ "\\)"
+ "\\)\\_>")
+ '(0 mdw-number-face))
+ (list "\\(\\s.\\|\\s(\\|\\s)\\|\\s\\\\|\\s/\\)"
+ '(0 mdw-punct-face))))
(mdw-post-config-mode-hack))
(indent-for-tab-command)))
(defun mdw-setup-m4 ()
+
+ ;; Inexplicably, Emacs doesn't match braces in m4 mode. This is very
+ ;; annoying: fix it.
+ (modify-syntax-entry ?{ "(")
+ (modify-syntax-entry ?} ")")
+
+ ;; Fill prefix.
(mdw-standard-fill-prefix "\\([ \t]*\\(?:#+\\|\\<dnl\\>\\)[ \t]*\\)"))
;;;--------------------------------------------------------------------------
(define-key term-raw-map [M-left] 'term-send-meta-left)
(define-key term-raw-map [?\e ?\M-O ?D] 'term-send-meta-left)))
+(defadvice term-exec (before program-args-list compile activate)
+ "If the PROGRAM argument is a list, interpret it as (PROGRAM . SWITCHES).
+This allows you to pass a list of arguments through `ansi-term'."
+ (let ((program (ad-get-arg 2)))
+ (if (listp program)
+ (progn
+ (ad-set-arg 2 (car program))
+ (ad-set-arg 4 (cdr program))))))
+
+(defun ssh (host)
+ "Open a terminal containing an ssh session to the HOST."
+ (interactive "sHost: ")
+ (ansi-term (list "ssh" host) (format "ssh@%s" host)))
+
+(defvar git-grep-command
+ "env PAGER=cat git grep --no-color -nH -e "
+ "*The default command for \\[git-grep].")
+
+(defvar git-grep-history nil)
+
+(defun git-grep (command-args)
+ "Run `git grep' with user-specified args and collect output in a buffer."
+ (interactive
+ (list (read-shell-command "Run git grep (like this): "
+ git-grep-command 'git-grep-history)))
+ (grep command-args))
+
;;;--------------------------------------------------------------------------
;;; Inferior Emacs Lisp.
~mdw / profile / blobdiff