From 1c957668b97d7935bd0df99d57e524f6fe2e1cbe Mon Sep 17 00:00:00 2001 From: Mathias De Wachter Date: Wed, 3 Sep 2014 12:06:50 -0400 Subject: [PATCH] added C-c TAB as complete in cider editor --- elpa/cider-0.7.0/cider-mode.el | 2 +- .../groovy-mode-autoloads.el | 44 ++ elpa/groovy-mode-20131129/groovy-mode-pkg.el | 1 + elpa/groovy-mode-20131129/groovy-mode-pkg.elc | Bin 0 -> 653 bytes elpa/groovy-mode-20131129/groovy-mode.el | 635 ++++++++++++++++++ elpa/groovy-mode-20131129/groovy-mode.elc | Bin 0 -> 54599 bytes 6 files changed, 681 insertions(+), 1 deletion(-) create mode 100644 elpa/groovy-mode-20131129/groovy-mode-autoloads.el create mode 100644 elpa/groovy-mode-20131129/groovy-mode-pkg.el create mode 100644 elpa/groovy-mode-20131129/groovy-mode-pkg.elc create mode 100644 elpa/groovy-mode-20131129/groovy-mode.el create mode 100644 elpa/groovy-mode-20131129/groovy-mode.elc diff --git a/elpa/cider-0.7.0/cider-mode.el b/elpa/cider-0.7.0/cider-mode.el index d92bff41a..ec6fdd597 100644 --- a/elpa/cider-0.7.0/cider-mode.el +++ b/elpa/cider-0.7.0/cider-mode.el @@ -56,7 +56,7 @@ entirely." (define-key map (kbd "M-.") 'cider-jump-to-var) (define-key map (kbd "M-,") 'cider-jump-back) (define-key map (kbd "C-c M-.") 'cider-jump-to-resource) - (define-key map (kbd "M-TAB") 'complete-symbol) + (define-key map (kbd "C-c TAB") 'complete-symbol) (define-key map (kbd "C-M-x") 'cider-eval-defun-at-point) (define-key map (kbd "C-c C-c") 'cider-eval-defun-at-point) (define-key map (kbd "C-x C-e") 'cider-eval-last-sexp) diff --git a/elpa/groovy-mode-20131129/groovy-mode-autoloads.el b/elpa/groovy-mode-20131129/groovy-mode-autoloads.el new file mode 100644 index 000000000..1974d3ff9 --- /dev/null +++ b/elpa/groovy-mode-20131129/groovy-mode-autoloads.el @@ -0,0 +1,44 @@ +;;; groovy-mode-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + + +;;;### (autoloads (groovy-mode groovy-mode-hook) "groovy-mode" "groovy-mode.el" +;;;;;; (21411 60555 568140 496000)) +;;; Generated autoloads from groovy-mode.el + +(add-to-list 'auto-mode-alist '("\\.groovy\\'" . groovy-mode)) + +(defvar groovy-mode-hook nil "\ +*Hook called by `groovy-mode'.") + +(custom-autoload 'groovy-mode-hook "groovy-mode" t) + +(autoload 'groovy-mode "groovy-mode" "\ +Major mode for editing Groovy code. + +The hook `c-mode-common-hook' is run with no args at mode +initialization, then `groovy-mode-hook'. + +Key bindings: +\\{groovy-mode-map} + +\(fn)" t nil) + +(add-to-list 'interpreter-mode-alist '("groovy" . groovy-mode)) + +;;;*** + +;;;### (autoloads nil nil ("groovy-mode-pkg.el") (21411 60555 586843 +;;;;;; 563000)) + +;;;*** + +(provide 'groovy-mode-autoloads) +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; groovy-mode-autoloads.el ends here diff --git a/elpa/groovy-mode-20131129/groovy-mode-pkg.el b/elpa/groovy-mode-20131129/groovy-mode-pkg.el new file mode 100644 index 000000000..c73e9bb9b --- /dev/null +++ b/elpa/groovy-mode-20131129/groovy-mode-pkg.el @@ -0,0 +1 @@ +(define-package "groovy-mode" "20131129" "Groovy mode derived mode" (quote nil)) diff --git a/elpa/groovy-mode-20131129/groovy-mode-pkg.elc b/elpa/groovy-mode-20131129/groovy-mode-pkg.elc new file mode 100644 index 0000000000000000000000000000000000000000..35a6880ced4440a8c2b8a8f32ae6154923cce18d GIT binary patch literal 653 zcmbtR!A`?44Bfduz}4yrB$}?>Cb9Jbng$x;26yBoUK_1-swCYszMixL#I)mla_pD) zY`Nz@kdI+JU1a0MEDL!y9r(94fVM#a(#kZHUTCC(8kA0`l) z1d>UX<@2**yDJ6N1Gi>a^?zYc*6A=wJ{1#@550r-6<}S1X}xar7y1BjA{v?>m3F70 zI!6xFk+IPdl#$L`&852!UF$rcQsFdzI@w(0^9v4T0tXup(y+$>?))}+2o+AA-k0k& z$O=Hxv|Ey$=WNA2G15@1k!c=f++D literal 0 HcmV?d00001 diff --git a/elpa/groovy-mode-20131129/groovy-mode.el b/elpa/groovy-mode-20131129/groovy-mode.el new file mode 100644 index 000000000..70ddb18bd --- /dev/null +++ b/elpa/groovy-mode-20131129/groovy-mode.el @@ -0,0 +1,635 @@ +;;; groovy-mode.el --- Groovy mode derived mode + +;; Author: Russel Winder +;; Created: 2006-08-01 +;; Version: 20131129 + +;;;; NB Version number is date and time yyyymmddhhMM in GMT (aka UTC). + +;; Copyright (C) 2006,2009-10,2012,2013 Russel Winder + +;; This program 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 2 of the License, or +;; (at your option) any later version. +;; +;; This program 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 this program; if not, write +;; to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +;;; Authors: +;; +;; Russel Winder , 2006-- +;; Jim Morris , 2009-- + +;;; Commentary: +;; +;; This mode was initially developed using the Java and Awk modes that are part of CC Mode (the 5.31 source +;; was used) and C# Mode from Dylan R. E. Moonfire (the 0.5.0 source was used). This +;; code may contain some code fragments from those sources that was cut-and-pasted then edited. All other +;; code was newly entered by the author. Obviously changes have been made since then. +;; +;; NB This derived mode requires CC Mode 5.31 or later for the virtual semicolon code to work. +;; +;; There appears to be a problem in CC Mode 5.31 such that csharp-mode and groovy-mode crash XEmacs 21.4 if +;; the files are byte compiled. + +;;; Bugs: +;; +;; Bug tracking is currently (2013-06-06) handled using the GitHub issue tracker at https://github.com/russel/Emacs-Groovy-Mode/issues + +;;; Versions: +;; +;; 0.1.0 - will be the initial release when it is ready :-) + +;;; Notes: +;; +;; Need to think about the `*.', `?.', `.&' and `.@' operators. Also, `..' and `..<'. This probably means +;; changing `c-after-id-concat-ops' but also `c-operators'. +;; +;; Need to deal with operator overloading (groovy has this but Java does not) so `c-overloadable-operators' +;; needs investigating. +;; +;; Need to investigate how to support the triple string delimiters for multi-line strings. +;; +;; Should we support GString / template markup ( e.g. `<%' and `%>') specially? +;; +;; Need to think whether Groovy needs a different c-decl-prefix-re compared to Java. Certainly, Java will +;; have to change to handle the generics. +;; +;; Probably need to change `c-block-prefix-disallowed-chars' as Groovy is not the same as Java. +;; +;; Probably need to change `c-type-decl-suffix-key' as Groovy is not the same as Java. + +;;; Changes: +;; +;; See the history in the Bazaar branch. + +;;; Code: + +(require 'cc-mode) + +;; CSharp mode comment says: These are only required at compile time to get the sources for the language +;; constants. (The cc-fonts require and the font-lock related constants could additionally be put inside an +;; (eval-after-load "font-lock" ...) but then some trickery is necessary to get them compiled.) +(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-mode" nil t) ; C# mode has this + (load "cc-fonts" nil t) ; C# mode has this + (load "cc-langs" nil t) ; C# mode has this + (load "cc-bytecomp" nil t) ; Awk mode has this +)) + +(eval-and-compile + (c-add-language 'groovy-mode 'java-mode)) + +;; Groovy allows `?.' as well as `.' for creating identifiers. +(c-lang-defconst c-identifier-ops + groovy '((left-assoc "." "?."))) + +;; Groovy allows operators such as `*.', `?.', `.&' and `.@'. Java mode puts `*' here to deal with +;; import statement usage which we need for Groovy. +(c-lang-defconst c-after-id-concat-ops + groovy '( "*" "&" "@" )) + +;;;; Should really do something with `c-string-escaped-newlines' and `c-multiline-string-start-char' to +;;;; handle the triple delimeter multiline strings. + +;; Because of the above we have to redefine `c_operators' because no other language has `.&' and +;; `.@' operators. + +(c-lang-defconst c-operators + "List describing all operators, along with their precedence and +associativity. The order in the list corresponds to the precedence of +the operators: The operators in each element is a group with the same +precedence, and the group has higher precedence than the groups in all +following elements. The car of each element describes the type of of +the operator group, and the cdr is a list of the operator tokens in +it. The operator group types are: + +'prefix Unary prefix operators. +'postfix Unary postfix operators. +'postfix-if-paren + Unary postfix operators if and only if the chars have + parenthesis syntax. +'left-assoc Binary left associative operators (i.e. a+b+c means (a+b)+c). +'right-assoc Binary right associative operators (i.e. a=b=c means a=(b=c)). +'right-assoc-sequence + Right associative operator that constitutes of a + sequence of tokens that separate expressions. All the + tokens in the group are in this case taken as + describing the sequence in one such operator, and the + order between them is therefore significant. + +Operators containing a character with paren syntax are taken to match +with a corresponding open/close paren somewhere else. A postfix +operator with close paren syntax is taken to end a postfix expression +started somewhere earlier, rather than start a new one at point. Vice +versa for prefix operators with open paren syntax. + +Note that operators like \".\" and \"->\" which in language references +often are described as postfix operators are considered binary here, +since CC Mode treats every identifier as an expression." + + groovy `( + ;; Primary. + ,@(c-lang-const c-identifier-ops) + + (postfix-if-paren "<" ">") ; Templates. + + (prefix "super") + + ;; Postfix. + (left-assoc "." "*." "?." ".&" ".@") + + (postfix "++" "--" "[" "]" "(" ")" "<:" ":>") + + ;; Unary. + (prefix "++" "--" "+" "-" "!" "~" "new" "(" ")") + + ;; Multiplicative. + (left-assoc "*" "/" "%") + + ;; Additive. + (left-assoc "+" "-") + + ;; Shift. + (left-assoc "<<" ">>" ">>>") + + ;; Relational. + (left-assoc "<" ">" "<=" ">=" "instanceof" "<=>") + + ;; Matching. + (left-assoc "=~" "==~" ) + + ;; Equality. + (left-assoc "==" "!=" ) + + ;; Bitwise and. + (left-assoc "&") + + ;; Bitwise exclusive or. + (left-assoc "^") + + ;; Bitwise or. + (left-assoc "|") + + ;; Logical and. + (left-assoc "&&") + + ;; Logical or. + (left-assoc "||") + + ;; Conditional. + (right-assoc-sequence "?" ":") + + ;; Assignment. + (right-assoc ,@(c-lang-const c-assignment-operators)) + + ;; Exception. + ;(prefix "throw") ; Java mode didn't have this but c++ mode does. Humm... + + ;; Sequence. + (left-assoc ",") + + ;; Separator for parameter list and code in a closure. + (left-assoc "->") + )) + +;; Groovy can overload operators where Java cannot. +(c-lang-defconst c-overloadable-operators + groovy '("+" "-" "*" "/" "%" + "&" "|" "^" "~" "<<" ">>" ">>>" + "==" "!=" ">" "<" ">=" "<=" + "<=>" + "=~" "==~" + "++" "--" "+=" "-=" "*=" "/=" "%=" + "&=" "|=" "^=" "~=" "<<=" ">>=" ">>>=" + "!" "&&" "||")) + +;; Groovy allows newline to terminate a statement unlike Java and like Awk. We draw on the Awk +;; Mode `Virtual semicolon material. The idea is to say when an EOL is a `virtual semicolon, +;; i.e. a statement terminator. + +(c-lang-defconst c-stmt-delim-chars + groovy "^;{}\n\r?:") + +(c-lang-defconst c-stmt-delim-chars-with-comma + groovy "^;,{}\n\r?:") + +;; Is there a virtual semicolon at POS or point? +;; +;; A virtual semicolon is considered to lie just after the last non-syntactic-whitespace +;; character on a line where the EOL is the statement terminator. A real semicolon never +;; counts as a virtual one. +(defun groovy-at-vsemi-p ( &optional pos ) + (save-excursion + (let ((pos-or-point (if pos (goto-char pos) (point)))) + (if (eq pos-or-point (point-min)) + nil + (and + (not (char-equal (char-before) ?\;)) + (groovy-ws-or-comment-to-eol-p pos-or-point) + (groovy-not-in-statement-p pos-or-point) + (groovy-not-if-or-else-etc-p pos-or-point)))))) + +(c-lang-defconst c-at-vsemi-p-fn + groovy 'groovy-at-vsemi-p) + +;; see if end of line or comment on rest of line +(defun groovy-ws-or-comment-to-eol-p ( pos ) + (save-excursion + (goto-char pos) + (skip-chars-forward " \t") + (or + (char-equal (char-after) ?\n) + (looking-at "/[/*].*")))) + +(defun groovy-not-in-statement-p ( pos ) + (save-excursion + (goto-char pos) + (if (equal (point) (point-min)) + nil + (backward-char 1) + (or + (not (looking-at "[=+*%<{:]")) + (if (char-equal (char-after) ?>) + (if (equal (point) (point-min)) + nil + (char-equal (char-before) ?-))))))) + +;; check for case of if(stuff) and nothing else on line +;; ie +;; if(x > y) +;; +;; if(x < y) do somehting will not match +;; else blah blah will not match either +(defun groovy-not-if-or-else-etc-p ( pos ) + (save-excursion + (goto-char pos) + (back-to-indentation) + (not + (or + (and (looking-at "if") ; make sure nothing else on line + (progn (forward-sexp 2) + (groovy-ws-or-comment-to-eol-p (point)))) + (and (looking-at "}?else") + (progn (forward-char) + (forward-sexp 1) + (groovy-ws-or-comment-to-eol-p (point)))))))) + +(defun groovy-vsemi-status-unknown-p () nil) + +(c-lang-defconst c-vsemi-status-unknown-p-fn + groovy 'c-groovy-vsemi-status-unknown-p) + + +;; Java does not do this but perhaps it should? +(c-lang-defconst c-type-modifier-kwds + groovy '("volatile" "transient")) + +(c-lang-defconst c-typeless-decl-kwds + groovy (append (c-lang-const c-class-decl-kwds) + (c-lang-const c-brace-list-decl-kwds) + '("def"))) + +;;;; Should we be tinkering with `c-block-stmt-1-key' or `c-block-stmt-2-key' to deal with closures +;;;; following what appears to be function calls or even field names? + +;; Groovy allows use of `<%' and `%>' in template expressions. +;(c-lang-defconst c-other-op-syntax-tokens +; groovy '( "<%" "%>" )) + +;; Groovy does not allow the full set of Java keywords in the moifier category and, of course, there is the +;; `def' modifier which Groovy introduces to support dynamic typing. Should `const' be treated +;; as reserved here as it is in Java? +(c-lang-defconst c-modifier-kwds + groovy '( "abstract" "def" "final" "private" "protected" "public" "static" "synchronized" )) + +;; Java does not define these pseudo-kewords as keywords, why not? + +(c-lang-defconst c-constant-kwds + groovy '( "true" "false" "null" )) + +;; Why does Java mode not put `super' into the `c-primary-expr-kwds? + +(c-lang-defconst c-primary-expr-kwds + groovy '( "this" "super" )) + +;; Groovy does not allow anonymous classes as Java does. +(c-lang-defconst c-inexpr-class-kwds + groovy nil) + +(c-lang-defconst c-inexpr-brace-list-kwds + groovy nil) + +;;;; Should we be changing `c-opt-inexpr-brace-list-key' to deal with closures after function calls and +;;;; field expressions? + +;; We need to include the "as" for the cast and "in" for for. +(c-lang-defconst c-other-kwds + groovy '( "in" "as" )) + + +(defconst groovy-font-lock-keywords-1 (c-lang-const c-matchers-1 groovy) + "Minimal highlighting for Groovy mode. +Fontifies nothing except the syntactic fontification of strings and +comments.") + +(defconst groovy-font-lock-keywords-2 (c-lang-const c-matchers-2 groovy) + "Fast normal highlighting for Groovy mode. +In addition to `java-font-lock-keywords-1', this adds fontification of +keywords, simple types, declarations that are easy to recognize, the +user defined types on `java-font-lock-extra-types', and the doc +comment styles specified by `c-doc-comment-style'.") + +(defconst groovy-font-lock-keywords-3 (c-lang-const c-matchers-3 groovy) + "Accurate normal highlighting for Groovy mode. +Like `java-font-lock-keywords-2' but detects declarations in a more +accurate way that works in most cases for arbitrary types without the +need for `java-font-lock-extra-types'.") + +(defvar groovy-font-lock-keywords groovy-font-lock-keywords-3 + "Default expressions to highlight in Groovy mode.") + +(defun groovy-font-lock-keywords-2 () + (c-compose-keywords-list groovy-font-lock-keywords-2)) +(defun groovy-font-lock-keywords-3 () + (c-compose-keywords-list groovy-font-lock-keywords-3)) +(defun groovy-font-lock-keywords () + (c-compose-keywords-list groovy-font-lock-keywords)) + +(defvar groovy-mode-syntax-table nil + "Syntax table used in Groovy mode buffers.") +(or groovy-mode-syntax-table + (setq groovy-mode-syntax-table + (funcall (c-lang-const c-make-mode-syntax-table groovy)))) + +;(modify-syntax-entry ?: "_" groovy-mode-syntax-table) + +(defvar groovy-mode-abbrev-table nil + "Abbreviation table used in groovy-mode buffers.") +(c-define-abbrev-table 'groovy-mode-abbrev-table + ;; Keywords that if they occur first on a line might alter the syntactic context, and which + ;; therefore should trigger reindentation when they are completed. + '(("else" "else" c-electric-continued-statement 0) + ("while" "while" c-electric-continued-statement 0) + ("catch" "catch" c-electric-continued-statement 0) + ("finally" "finally" c-electric-continued-statement 0))) + +;; Jim Morris proposed changing to the following definition of groovy-mode-map 2009-11-27, but this change +;; has not made so as to continue to use the same code structure as still used in the Java mode. + +;(defvar groovy-mode-map (let ((map (c-make-inherited-keymap))) +; ;; Add bindings which are only useful for Groovy +; map) +; "Keymap used in groovy-mode buffers.") + +(defvar groovy-mode-map () + "Keymap used in groovy-mode buffers.") +(if groovy-mode-map + nil + (setq groovy-mode-map (c-make-inherited-keymap)) + ;; add bindings which are only useful for Groovy + ) + +;(easy-menu-define c-groovy-menu groovy-mode-map "Groovy Mode Commands" +; (cons "Groovy" (c-lang-const c-mode-menu groovy))) + +;;; Autoload mode trigger +;;;###autoload +(add-to-list 'auto-mode-alist '("\\.groovy\\'" . groovy-mode)) + +;; Custom variables +;;;###autoload +(defcustom groovy-mode-hook nil + "*Hook called by `groovy-mode'." + :type 'hook + :group 'c) + + +;;; The following are used to overide cc-mode indentation behavior to match groovy + +;; if we are in a closure that has an argument eg ends with -> (excluding comment) then +;; change indent else lineup with previous one +(defun groovy-mode-fix-closure-with-argument (langelem) + (save-excursion + (back-to-indentation) + (c-backward-syntactic-ws) + (backward-char 2) + (if (looking-at "->") ; if the line has a -> in it + (vector (+ (current-indentation) c-basic-offset)) ; then indent from base + 0))) + +;; A helper function from: http://mihai.bazon.net/projects/emacs-javascript-mode/javascript.el +;; Originally named js-lineup-arglist, renamed to groovy-lineup-arglist +(defun groovy-lineup-arglist (langelem) + ;; the "DWIM" in c-mode doesn't Do What I Mean. + ;; see doc of c-lineup-arglist for why I redefined this + (save-excursion + (let ((indent-pos (point))) + ;; Normal case. Indent to the token after the arglist open paren. + (goto-char (c-langelem-2nd-pos c-syntactic-element)) + (if (and c-special-brace-lists + (c-looking-at-special-brace-list)) + ;; Skip a special brace list opener like "({". + (progn (c-forward-token-2) + (forward-char)) + (forward-char)) + (let ((arglist-content-start (point))) + (c-forward-syntactic-ws) + (when (< (point) indent-pos) + (goto-char arglist-content-start) + (skip-chars-forward " \t")) + (vector (current-column)))))) + +(defun is-groovy-mode () + "return t if we are in groovy mode else nil" + (eq major-mode 'groovy-mode)) + +(defun groovy-is-label (the-list) + (let ((ret nil)) + (dolist (elt the-list) + (if (eq 'label (car elt)) + (setq ret t))) + ret)) + +(defun groovy-backtrack-open-paren () + (let ((counter 0)) + (while (<= 0 counter) + (skip-chars-backward "^}]){[(") + (cond ((or (equal ?\] (preceding-char)) + (equal ?\) (preceding-char)) + (equal ?} (preceding-char))) + (setq counter (1+ counter))) + ((or (equal ?\[ (preceding-char)) + (equal ?\( (preceding-char)) + (equal ?{ (preceding-char))) + (setq counter (1- counter)))) + (backward-char 1)))) + +(defun groovy-named-parameter-list-anchor-points () + (save-excursion + (beginning-of-line) + (c-backward-syntactic-ws) + (if (equal ?, (preceding-char)) + (let* ((second-anchor (progn (groovy-backtrack-open-paren) + (point))) + (first-anchor (progn (beginning-of-line) + (c-forward-syntactic-ws) + (point)))) + (cons first-anchor second-anchor)) + nil))) + +;; use defadvice to override the syntactic type if we have a +;; statement-cont, see if previous line has a virtual semicolon and if +;; so make it statement. +(defadvice c-guess-basic-syntax (after c-guess-basic-syntax-groovy activate) + (catch 'exit-early + (when (is-groovy-mode) + (if (groovy-is-label ad-return-value) + (progn + (let ((anchor-points (groovy-named-parameter-list-anchor-points))) + (if anchor-points + (setq ad-return-value `((arglist-cont-nonempty ,(car anchor-points) ,(cdr anchor-points)))) + (throw 'exit-early 1))))) + + (save-excursion + (let* ((ankpos (progn + (beginning-of-line) + (c-backward-syntactic-ws) + (beginning-of-line) + (c-forward-syntactic-ws) + (point))) ; position to previous non-blank line + (curelem (c-langelem-sym (car ad-return-value)))) + (end-of-line) + (cond + ((eq 'statement-cont curelem) + (when (groovy-at-vsemi-p) ; if there is a virtual semi there then make it a statement + (setq ad-return-value `((statement ,ankpos))))) + + ((eq 'topmost-intro-cont curelem) + (when (groovy-at-vsemi-p) ; if there is a virtual semi there then make it a top-most-intro + (setq ad-return-value `((topmost-intro ,ankpos))))) + + )))))) + +;; This disables bracelists, as most of the time in groovy they are closures +;; We need to check we are currently in groovy mode +(defadvice c-inside-bracelist-p (around groovy-c-inside-bracelist-p activate) + (if (not (is-groovy-mode)) + ad-do-it + (setq ad-return-value nil))) + + +;; based on java-function-regexp +;; Complicated regexp to match method declarations in interfaces or classes +;; A nasty test case is: +;; else if(foo instanceof bar) { +;; which will get mistaken for a function as Groovy does not require types on arguments +;; so we need to check for empty parens or comma separated list, or type args +(defvar groovy-function-regexp + (concat + "^[ \t]*" ; leading white space + "\\(public\\|private\\|protected\\|" ; some of these 8 keywords + "abstract\\|final\\|static\\|" + "synchronized\\|native|def" + "\\|[ \t\n\r]\\)*" ; or whitespace + "[a-zA-Z0-9_$]*" ; optional return type + "[ \t\n\r]*[[]?[]]?" ; (could be array) + "[ \t\n\r]+" ; whitespace + "\\([a-zA-Z0-9_$]+\\)" ; the name we want + "[ \t\n\r]*" ; optional whitespace + "(" ; open the param list + "[ \t]*" ; optional whitespace + "\\(" + "[ \t\n\r]*\\|" ; empty parens or + "[a-zA-Z0-9_$]+\\|" ; single param or + ".+?,.+?\\|" ; multi comma separated params or + "[a-zA-Z0-9_$]+" ; a type + "[ \t\n\r]*[[]?[]]?" ; optional array + "[ \t\n\r]+[a-zA-Z0-9_$]+" ; and param + "\\)" + "[ \t\n\r]*" ; optional whitespace + ")" ; end the param list + "[ \t\n\r]*" ; whitespace +; "\\(throws\\([, \t\n\r]\\|[a-zA-Z0-9_$]\\)+\\)?{" + "\\(throws[^{;]+\\)?" ; optional exceptions + "[;{]" ; ending ';' (interfaces) or '{' + ; TODO groovy interfaces don't need to end in ; + ) + "Matches method names in groovy code, select match 2") + +(defvar groovy-class-regexp + "^[ \t\n\r]*\\(final\\|abstract\\|public\\|[ \t\n\r]\\)*class[ \t\n\r]+\\([a-zA-Z0-9_$]+\\)[^;{]*{" + "Matches class names in groovy code, select match 2") + +(defvar groovy-interface-regexp + "^[ \t\n\r]*\\(abstract\\|public\\|[ \t\n\r]\\)*interface[ \t\n\r]+\\([a-zA-Z0-9_$]+\\)[^;]*;" + "Matches interface names in groovy code, select match 2") + +(defvar groovy-imenu-regexp + (list (list nil groovy-function-regexp 2) + (list ".CLASSES." groovy-class-regexp 2) + (list ".INTERFACES." groovy-interface-regexp 2) + (list ".CLOSURES." "def[ \t]+\\([a-zA-Z_][a-zA-Z0-9_]*\\)[ \t]*=[ \t]*{" 1)) + "Imenu expression for Groovy") + + +;; Setup imenu to extract functions, classes, interfaces and closures assigned to variables +(defvar cc-imenu-groovy-generic-expression + groovy-imenu-regexp + "Imenu generic expression for Groovy mode. See `imenu-generic-expression'.") + +;;; The entry point into the mode +;;;###autoload +(defun groovy-mode () + "Major mode for editing Groovy code. + +The hook `c-mode-common-hook' is run with no args at mode +initialization, then `groovy-mode-hook'. + +Key bindings: +\\{groovy-mode-map}" + (interactive) + (kill-all-local-variables) + (c-initialize-cc-mode t) + (set-syntax-table groovy-mode-syntax-table) + (setq major-mode 'groovy-mode + mode-name "Groovy" + local-abbrev-table groovy-mode-abbrev-table + abbrev-mode t) + (use-local-map groovy-mode-map) + (c-init-language-vars groovy-mode) + (c-common-init 'groovy-mode) + ;;(easy-menu-add groovy-menu) + (cc-imenu-init cc-imenu-groovy-generic-expression) + (c-run-mode-hooks 'c-mode-common-hook 'groovy-mode-hook) + + ;; quick fix for misalignment of statements with = + (setq c-label-minimum-indentation 0) + + ;; fix for indentation after a closure param list + (c-set-offset 'statement 'groovy-mode-fix-closure-with-argument) + + ;; get arglists (in groovy lists or maps) to align properly + (c-set-offset 'arglist-close '(c-lineup-close-paren)) + (c-set-offset 'arglist-cont 0) + (c-set-offset 'arglist-cont-nonempty '(groovy-lineup-arglist)) + (c-set-offset 'arglist-intro '+) + (c-set-offset 'label '+) + + (c-update-modeline)) + +;;;###autoload +(add-to-list 'interpreter-mode-alist '("groovy" . groovy-mode)) + +(provide 'groovy-mode) + +;;; groovy-mode.el ends here diff --git a/elpa/groovy-mode-20131129/groovy-mode.elc b/elpa/groovy-mode-20131129/groovy-mode.elc new file mode 100644 index 0000000000000000000000000000000000000000..2fb913eee0ccf3172fc69f86705b85489a43687e GIT binary patch literal 54599 zcmeI53wK+`k>@$PnX|HdMkh0wFv(=cdj;7dDG3zbv>vo1%W}qvEqg3wG6_LNAP7>3 zK!CebMhse!JT{>U3XBd*l1V@qV*B8xHI1`n5irtnZKeyX(VQ zXV~qncSi@&Xc&Du?nghL4Wn8msx)p_E4Q0fepee-{@xg%J!*()a z=}y*nZ}tXNagM5DuL|DgZ-&J=*j`bB&B^hJN-8q^&Pr=9+A63wQ2fFCpRohXSf?pMp3sj9FC^ZPA?jaI=i5(Kb($yD{8f9G>&?m@u1%uuU}kM zmerlnY`A+Etyl-kzM*RuBmK8}H(KqCdwWslWwcr?N2`P0aGxGz-mI;yMfVZJhI8;@yK>G=nfmFTE5i5M_9*n1>9^wsKW_@F~?OVO40*VYV6 zP{xA)E?&I2x^q13mAi~kRBG2N6+YF=?OIhoYJBQ^8tsx#Y4X(Kv(c_sD_4@lYLx`Q ztMznZg9LI^Tj@ly)+oGIO(oXITBD{~Bb`Xr8kN;HNUUs>qOEc7n^}L{i@IGSsi<4- z?CzEao#Fnhv)_wS)E51&^Qseoc6)pMVb9>`=x{Ra45#Gn@Aih%{vJbI9vx1i)z#Hh z0c+7Wv(dCi>Y%qbEq5l9Q8y~Bm!i_W^%BFk7Om0>RXtf#JN7_1C93>xXL?$JrE3&& zmCt>ZlPzX+*c*4Iqw#!eI){fnQDL{d-<#&TvNG3~m85a1fj¬B0e>bg%!q+}|r7 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 literal 0 HcmV?d00001