Mercurial > emacs
view lisp/progmodes/cc-subword.el @ 98007:883843ca3292
* verilog-mode.el (verilog-library-extensions): Enable .sv
filename extensions to call verilog-mode.
(verilog-auto, verilog-auto-inst, verilog-faq)
(verilog-submit-bug-report): Update author support URLs.
(verilog-delete-auto, verilog-auto-inout-module)
(verilog-auto-inout-comp, verilog-auto): Add AUTOINOUTCOMP for
creating complemented testbench modules. Suggested by Yishay
Belkind.
(verilog-auto-inst-port, verilog-simplify-range-expression): When
verilog-auto-inst-param-value is set, don't require a
AUTO_TEMPLATE to expand parameter substitutions. Suggested by
Yishay Belkind.
(verilog-auto-inst-param-value): Add safe variable.
(verilog-re-search-forward, verilog-re-search-backward): Fix
returning wrong search results on Emacs 22.1.
(verilog-modi-cache-results, verilog-auto): Fix warning message
about "toggling font-lock-mode."
(verilog-auto): Fix loosing font-lock on errors.
(verilog-auto-inst-param-value, verilog-mode-version)
(verilog-mode-version-date, verilog-read-inst-param-value)
(verilog-auto-inst, verilog-auto-inst-param)
(verilog-auto-inst-port, verilog-simplify-range-expression): Allow
parameters to be replaced with their values, on the expansion of
an AUTOINST with Verilog 2001 style parameter settings. Suggested
by David Rogoff.
* verilog-mode.el (verilog-beg-block-re-ordered, verilog-calc-1):
Better support for the property statement. Sometimes this keyword
introduces a statement which requires an endproperty keyword, and
sometimes it doesn't, dependening on the work before the property
word. If property is prefixed with assert, assume or cover
keyword, then the statement is ended with a ';' Otherwise,
property is like task or specify, and is followed by some number
of statements, which are ended with an endproperty keyword.
(electric-verilog-tab): Support Emacs 22.2 style handling of tab
in a highlighted region: indent each line in region according to
mode. Supply this so it works in XEmacs and older Emacs.
author | Dan Nicolaescu <dann@ics.uci.edu> |
---|---|
date | Fri, 05 Sep 2008 22:13:55 +0000 |
parents | 52b7a8c22af5 |
children | a9dc0e7c3f2b |
line wrap: on
line source
;;; cc-subword.el --- Handling capitalized subwords in a nomenclature ;; Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. ;; Author: Masatake YAMATO ;; This file is part of GNU Emacs. ;; GNU Emacs is free software: you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by ;; the Free Software Foundation, either version 3 of the License, or ;; (at your option) any later version. ;; GNU Emacs is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; GNU General Public License for more details. ;; You should have received a copy of the GNU General Public License ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. ;;; Commentary: ;; This package provides `subword' oriented commands and a minor mode ;; (`c-subword-mode') that substitutes the common word handling ;; functions with them. ;; In spite of GNU Coding Standards, it is popular to name a symbol by ;; mixing uppercase and lowercase letters, e.g. "GtkWidget", ;; "EmacsFrameClass", "NSGraphicsContext", etc. Here we call these ;; mixed case symbols `nomenclatures'. Also, each capitalized (or ;; completely uppercase) part of a nomenclature is called a `subword'. ;; Here are some examples: ;; Nomenclature Subwords ;; =========================================================== ;; GtkWindow => "Gtk" and "Window" ;; EmacsFrameClass => "Emacs", "Frame" and "Class" ;; NSGraphicsContext => "NS", "Graphics" and "Context" ;; The subword oriented commands defined in this package recognize ;; subwords in a nomenclature to move between them and to edit them as ;; words. ;; In the minor mode, all common key bindings for word oriented ;; commands are overridden by the subword oriented commands: ;; Key Word oriented command Subword oriented command ;; ============================================================ ;; M-f `forward-word' `c-forward-subword' ;; M-b `backward-word' `c-backward-subword' ;; M-@ `mark-word' `c-mark-subword' ;; M-d `kill-word' `c-kill-subword' ;; M-DEL `backward-kill-word' `c-backward-kill-subword' ;; M-t `transpose-words' `c-transpose-subwords' ;; M-c `capitalize-word' `c-capitalize-subword' ;; M-u `upcase-word' `c-upcase-subword' ;; M-l `downcase-word' `c-downcase-subword' ;; ;; Note: If you have changed the key bindings for the word oriented ;; commands in your .emacs or a similar place, the keys you've changed ;; to are also used for the corresponding subword oriented commands. ;; To make the mode turn on automatically, put the following code in ;; your .emacs: ;; ;; (add-hook 'c-mode-common-hook ;; (lambda () (c-subword-mode 1))) ;; ;; Acknowledgment: ;; The regular expressions to detect subwords are mostly based on ;; the old `c-forward-into-nomenclature' originally contributed by ;; Terry_Glanfield dot Southern at rxuk dot xerox dot com. ;; TODO: ispell-word and subword oriented C-w in isearch. ;;; Code: (eval-when-compile (let ((load-path (if (and (boundp 'byte-compile-dest-file) (stringp byte-compile-dest-file)) (cons (file-name-directory byte-compile-dest-file) load-path) load-path))) (load "cc-bytecomp" nil t))) (cc-require 'cc-defs) (cc-require 'cc-cmds) (defvar c-subword-mode-map (let ((map (make-sparse-keymap))) (dolist (cmd '(forward-word backward-word mark-word kill-word backward-kill-word transpose-words capitalize-word upcase-word downcase-word)) (let ((othercmd (let ((name (symbol-name cmd))) (string-match "\\(.*-\\)\\(word.*\\)" name) (intern (concat "c-" (match-string 1 name) "sub" (match-string 2 name)))))) (if (fboundp 'command-remapping) (define-key map (vector 'remap cmd) othercmd) (substitute-key-definition cmd othercmd map global-map)))) map) "Keymap used in command `c-subword-mode' minor mode.") ;;;###autoload (define-minor-mode c-subword-mode "Mode enabling subword movement and editing keys. In spite of GNU Coding Standards, it is popular to name a symbol by mixing uppercase and lowercase letters, e.g. \"GtkWidget\", \"EmacsFrameClass\", \"NSGraphicsContext\", etc. Here we call these mixed case symbols `nomenclatures'. Also, each capitalized (or completely uppercase) part of a nomenclature is called a `subword'. Here are some examples: Nomenclature Subwords =========================================================== GtkWindow => \"Gtk\" and \"Window\" EmacsFrameClass => \"Emacs\", \"Frame\" and \"Class\" NSGraphicsContext => \"NS\", \"Graphics\" and \"Context\" The subword oriented commands activated in this minor mode recognize subwords in a nomenclature to move between subwords and to edit them as words. \\{c-subword-mode-map}" nil nil c-subword-mode-map (c-update-modeline)) (defun c-forward-subword (&optional arg) "Do the same as `forward-word' but on subwords. See the command `c-subword-mode' for a description of subwords. Optional argument ARG is the same as for `forward-word'." (interactive "p") (unless arg (setq arg 1)) (c-keep-region-active) (cond ((< 0 arg) (dotimes (i arg (point)) (c-forward-subword-internal))) ((> 0 arg) (dotimes (i (- arg) (point)) (c-backward-subword-internal))) (t (point)))) (put 'c-forward-subword 'CUA 'move) (defun c-backward-subword (&optional arg) "Do the same as `backward-word' but on subwords. See the command `c-subword-mode' for a description of subwords. Optional argument ARG is the same as for `backward-word'." (interactive "p") (c-forward-subword (- (or arg 1)))) (defun c-mark-subword (arg) "Do the same as `mark-word' but on subwords. See the command `c-subword-mode' for a description of subwords. Optional argument ARG is the same as for `mark-word'." ;; This code is almost copied from `mark-word' in GNU Emacs. (interactive "p") (cond ((and (eq last-command this-command) (mark t)) (set-mark (save-excursion (goto-char (mark)) (c-forward-subword arg) (point)))) (t (push-mark (save-excursion (c-forward-subword arg) (point)) nil t)))) (put 'c-backward-subword 'CUA 'move) (defun c-kill-subword (arg) "Do the same as `kill-word' but on subwords. See the command `c-subword-mode' for a description of subwords. Optional argument ARG is the same as for `kill-word'." (interactive "p") (kill-region (point) (c-forward-subword arg))) (defun c-backward-kill-subword (arg) "Do the same as `backward-kill-word' but on subwords. See the command `c-subword-mode' for a description of subwords. Optional argument ARG is the same as for `backward-kill-word'." (interactive "p") (c-kill-subword (- arg))) (defun c-transpose-subwords (arg) "Do the same as `transpose-words' but on subwords. See the command `c-subword-mode' for a description of subwords. Optional argument ARG is the same as for `transpose-words'." (interactive "*p") (transpose-subr 'c-forward-subword arg)) (defun c-downcase-subword (arg) "Do the same as `downcase-word' but on subwords. See the command `c-subword-mode' for a description of subwords. Optional argument ARG is the same as for `downcase-word'." (interactive "p") (let ((start (point))) (downcase-region (point) (c-forward-subword arg)) (when (< arg 0) (goto-char start)))) (defun c-upcase-subword (arg) "Do the same as `upcase-word' but on subwords. See the command `c-subword-mode' for a description of subwords. Optional argument ARG is the same as for `upcase-word'." (interactive "p") (let ((start (point))) (upcase-region (point) (c-forward-subword arg)) (when (< arg 0) (goto-char start)))) (defun c-capitalize-subword (arg) "Do the same as `capitalize-word' but on subwords. See the command `c-subword-mode' for a description of subwords. Optional argument ARG is the same as for `capitalize-word'." (interactive "p") (let ((count (abs arg)) (start (point)) (advance (if (< arg 0) nil t))) (dotimes (i count) (if advance (progn (re-search-forward (concat "[" c-alpha "]") nil t) (goto-char (match-beginning 0))) (c-backward-subword)) (let* ((p (point)) (pp (1+ p)) (np (c-forward-subword))) (upcase-region p pp) (downcase-region pp np) (goto-char (if advance np p)))) (unless advance (goto-char start)))) ;; ;; Internal functions ;; (defun c-forward-subword-internal () (if (and (save-excursion (let ((case-fold-search nil)) (re-search-forward (concat "\\W*\\(\\([" c-upper "]*\\W?\\)[" c-lower c-digit "]*\\)") nil t))) (> (match-end 0) (point))) ; So we don't get stuck at a ; "word-constituent" which isn't c-upper, ; c-lower or c-digit (goto-char (cond ((< 1 (- (match-end 2) (match-beginning 2))) (1- (match-end 2))) (t (match-end 0)))) (forward-word 1))) (defun c-backward-subword-internal () (if (save-excursion (let ((case-fold-search nil)) (re-search-backward (concat "\\(\\(\\W\\|[" c-lower c-digit "]\\)\\([" c-upper "]+\\W*\\)" "\\|\\W\\w+\\)") nil t))) (goto-char (cond ((and (match-end 3) (< 1 (- (match-end 3) (match-beginning 3))) (not (eq (point) (match-end 3)))) (1- (match-end 3))) (t (1+ (match-beginning 0))))) (backward-word 1))) (cc-provide 'cc-subword) ;; arch-tag: 2be9d294-7f30-4626-95e6-9964bb93c7a3 ;;; cc-subword.el ends here