diff options
Diffstat (limited to 'support/emacs/scala-mode.el')
-rw-r--r-- | support/emacs/scala-mode.el | 770 |
1 files changed, 0 insertions, 770 deletions
diff --git a/support/emacs/scala-mode.el b/support/emacs/scala-mode.el deleted file mode 100644 index bdddeeb479..0000000000 --- a/support/emacs/scala-mode.el +++ /dev/null @@ -1,770 +0,0 @@ -;;; scala.el - Major mode for editing Scala code. -;;; $Id$ - -;;; TODO -;;; - make automatic indentation work in all cases -;;; - support more Emacs variants (especially XEmacs) - -(require 'easymenu) -(require 'cl) -(require 'regexp-opt) - -(defconst scala-mode-version "0.3 ($Revision$)") -(defconst scala-bug-e-mail "Michel.Schinz@epfl.ch") -(defconst scala-web-url "http://scala.epfl.ch/") - -;; XEmacs compatibility -;; (note that XEmacs is not supported currently, the function below -;; only works around a single incompatibility). - -;;(defun scala-regexp-opt-charset (cset) -;; (regexp-opt-charset (if (integerp ?a) -;; cset -;; (mapcar #'char-to-string cset)))) -(defun scala-regexp-opt-charset (chars) - ;; - ;; Return a regexp to match a character in CHARS. - ;; - ;; The basic idea is to find character ranges. Also we take care in the - ;; position of character set meta characters in the character set regexp. - ;; - (let* ((charmap (make-char-table 'case-table)) - (start -1) (end -2) - (charset "") - (bracket "") (dash "") (caret "")) - ;; - ;; Make a character map but extract character set meta characters. - (dolist (char chars) - (case char - (?\] - (setq bracket "]")) - (?^ - (setq caret "^")) - (?- - (setq dash "-")) - (otherwise - (aset charmap char t)))) - ;; - ;; Make a character set from the map using ranges where applicable. - (map-char-table - (lambda (c v) - (when v - (if (= (1- c) end) (setq end c) - (if (> end (+ start 2)) - (setq charset (format "%s%c-%c" charset start end)) - (while (>= end start) - (setq charset (format "%s%c" charset start)) - (incf start))) - (setq start c end c)))) - charmap) - (when (>= end start) - (if (> end (+ start 2)) - (setq charset (format "%s%c-%c" charset start end)) - (while (>= end start) - (setq charset (format "%s%c" charset start)) - (incf start)))) - ;; - ;; Make sure a caret is not first and a dash is first or last. - (if (and (string-equal charset "") (string-equal bracket "")) - (concat "[" dash caret "]") - (concat "[" bracket charset caret dash "]")))) - -;; Customization - -(defgroup scala - nil - "Mode to edit Scala code." - :group 'languages) - -(defcustom scala-indent-step 2 - "Indentation step." - :type 'integer - :group 'scala) - -(defconst scala-number-re - "[[:digit:]]+\\(\\.[[:digit:]]+\\)?\\([eE][+-]?[[:digit:]]+\\)?[fl]?" - "Regular expression matching a Scala number (integer or float).") - -(defconst scala-string-re - "\"\\([^\"\\\\]\\|\\\\\.\\)*\"" - "Regular expression matching a Scala string literal.") - -(defconst scala-char-re - "'\\([^\\\\]\\|\\(\\\\[^']\\)\\)'" - "Regular expression matching a Scala character literal.") - -(defconst scala-literal-re - (concat "\\(" "\\(" scala-number-re "\\)" - "\\|" "\\(" scala-string-re "\\)" - "\\|" "\\(" scala-char-re "\\)" "\\)") - "Regular expression matching any Scala literal.") - -(defconst scala-most-special-chars (mapcar 'identity "<>+-*/|@#%&!?$^`~") - "List of almost all Scala special characters. -Not included in this list are the special characters which are -reserved keywords when used alone.") - -(defconst scala-all-special-chars (append (mapcar 'identity ":;,=") - scala-most-special-chars) - "List of all Scala special characters.") - -(defconst scala-most-special-char-re - (scala-regexp-opt-charset scala-most-special-chars) - "Regular expression matching a single Scala special character") - -(defconst scala-all-special-char-re - (scala-regexp-opt-charset scala-all-special-chars) - "Regular expression matching a single Scala special character") - -(defconst scala-keywords-re - (regexp-opt '("abstract" "case" "class" "catch" "def" "do" "else" "extends" - "final" "finally" "for" "if" "implicit" "import" "new" "match" - "object" "override" "package" "private" "protected" "requires" - "return" "sealed" "super" "this" "throw" "trait" "try" "type" - "val" "var" "with" "while" "yield") - 'words)) - -(defconst scala-constants-re - (regexp-opt '("true" "false" "null") 'words)) - -(defconst scala-special-ident-re - (concat "\\(" scala-all-special-char-re "\\{2,\\}" - "\\|" scala-most-special-char-re "+" - "\\)")) - -(defconst scala-ident-re - (let* ((varid-re "[[:alnum:]]+") - (id-re (concat "\\(" varid-re "\\|" scala-special-ident-re "\\)"))) - (concat id-re - "\\(" "_+" "\\(" id-re "\\)?" "\\)*")) - "Regular expression matching a Scala identifier.") - -(defconst scala-var-ident-re - (concat "[[:lower:]][[:alnum:]]*" "\\(_" scala-ident-re "\\)*") - "Relgular expression matching a Scala 'variable' identifier.") - -(defconst scala-qual-ident-re - (concat scala-ident-re "\\(" "\\." scala-ident-re "\\)*")) - -(defconst scala-capitalized-ident-re - (concat "\\(\\)\\([[:upper:]]" scala-ident-re "\\)")) - -(defconst scala-expr-start-re - (concat - (regexp-opt '("if" "else" "for" "do" "yield") 'words) "\\|" - (regexp-opt '("=" "=>") t))) - -(defconst scala-expr-starter - (mapcar (lambda (pair) (cons (car pair) (concat "\\<" (cdr pair) "\\>"))) - '(("else" . "if") - ("yield" . "for") - ("do" . "for") - ("extends" . "class") - ("with" . "class") - ("=>" . "case")))) - -(defconst scala-expr-middle-re - (regexp-opt (mapcar #'car scala-expr-starter) 'words)) - -(defconst scala-compound-expr-re - "\\<else\\s +if\\>") - -(defun scala-special-char-p (char) - (and char - (string-match scala-all-special-char-re (string char)))) - -(defun scala-looking-at-special-identifier (regexp) - (and (not (scala-special-char-p (char-before))) - (looking-at regexp) - (not (scala-special-char-p (char-after (match-end 0)))))) - -(defconst scala-comment-begin-or-end-re - (concat "\\(" "^/\\*.*" "\\|" "^//.*" "\\|" ".*\\*/$" "\\)")) - -(defun scala-search-special-identifier-forward (limit) - (ignore-errors - (while (and (search-forward-regexp scala-special-ident-re limit) - (save-match-data - (string-match scala-comment-begin-or-end-re - (match-string-no-properties 0))))) - t)) - -;; Movement - -(defun scala-when-looking-at* (regexp &optional thunk) - (let ((saved-match-data (match-data))) - (if (looking-at regexp) - (progn (goto-char (match-end 0)) - (set-match-data saved-match-data) - (or (not thunk) (funcall thunk))) - (set-match-data saved-match-data) - nil))) - -(defmacro scala-when-looking-at (regexp &rest body) - (if body - `(scala-when-looking-at* ,regexp (lambda () ,@body)) - `(scala-when-looking-at* ,regexp))) - -(defun scala-forward-spaces (&optional limit) - (if limit - (save-restriction - (narrow-to-region (point) limit) - (forward-comment 100000)) - (forward-comment 100000))) - -(defun scala-backward-spaces () - (forward-comment -100000)) - -(defun scala-looking-at-backward (re) - (save-excursion - (when (= 0 (skip-syntax-backward "w_")) (backward-char)) - (looking-at re))) - -(defmacro scala-point-after (&rest body) - `(save-excursion - ,@body - (point))) - -(defmacro scala-move-if (&rest body) - (let ((pt-sym (make-symbol "point")) - (res-sym (make-symbol "result"))) - `(let ((,pt-sym (point)) - (,res-sym ,(cons 'progn body))) - (unless ,res-sym (goto-char ,pt-sym)) - ,res-sym))) - -(defun scala-forward-ident () - ;; Move forward over an identifier. - (scala-forward-spaces) - (if (looking-at scala-ident-re) - (goto-char (match-end 0)) - (forward-char)) - t) - -(defun scala-backward-ident () - ;; Move backward over an identifier. - (scala-backward-spaces) - (if (scala-looking-at-backward scala-ident-re) - (goto-char (match-beginning 0)) - (backward-char)) - t) - -(defun scala-forward-qual-ident () - ;; Move forward over a qualifier identifier. - (scala-forward-spaces) - (if (looking-at scala-qual-ident-re) - (goto-char (match-end 0)) - (forward-char)) - t) - -(defun scala-backward-qual-ident () - ;; Move backward over a qualifier identifier. - (scala-backward-spaces) - (if (scala-looking-at-backward scala-qual-ident-re) - (goto-char (match-beginning 0)) - (backward-char)) - t) - -(defun scala-forward-simple-type () - ;; Move forward over a simple type (as defined by the grammar). - ;; Works only when point is at the beginning of a simple type - ;; (modulo initial spaces/comments). - (cond ((eobp) nil) - ((= (char-after) ?\() - ;; Parenthesized type - (forward-sexp) - t) - (t - ;; Type designator - (scala-forward-qual-ident) - (scala-forward-spaces) - (cond ((eobp) nil) - ((= (char-after) ?\[) - ;; Type arguments - (forward-sexp)) - ((= (char-after) ?\#) - ;; Type selection - (forward-char) - (scala-forward-ident))) - t))) - -(defun scala-forward-type1 () - ;; Move forward over a type1 (as defined by the grammar). - ;; Works only when point is at the beginning of a type (modulo - ;; initial spaces/comments). - (scala-forward-spaces) - (scala-when-looking-at "\\<class\\>" - (forward-word 1) (scala-forward-spaces)) - (scala-forward-simple-type) - (while (scala-when-looking-at "\\s *\\<with\\>\\s *") - (if (and (not (eobp)) (= (char-after) ?\{)) - (forward-sexp) ;skip refinement - (scala-forward-simple-type))) - t) - -(defun scala-forward-type () - ;; Move forward over a type. - (cond ((eobp) nil) - ((= (char-after) ?\() - ;; Function type (several arguments) - (forward-sexp) - (scala-when-looking-at "\\s *=>\\s *" (scala-forward-type)) - t) - (t - ;; Type1 or function type with one argument - (scala-forward-type1) - (scala-when-looking-at "\\s *=>\\s *" (scala-forward-type)) - t))) - -(defun scala-forward-type-param () - ;; Move over a type parameter - ;; variance - (scala-when-looking-at "\\s *[-+]\\s *") - (scala-forward-ident) - ;; bounds - (while (scala-when-looking-at "\\s *[<>][:%]\\s *") - (scala-forward-type)) - t) - -(defun scala-forward-literal () - ;; Move forward over an integer, float, character or string literal. - (scala-forward-spaces) - (scala-when-looking-at scala-literal-re) - t) - -;;; Indentation -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun scala-parse-partial-sexp () - (parse-partial-sexp (point-min) (point))) - -(defun scala-in-comment-p () - "Return t iff the point is inside a comment." - ;; The two branches of the "if" below do not have the same behaviour - ;; when the point is on the comment beginning/ending character(s). - (if font-lock-mode - (eq (get-text-property (point) 'face) 'font-lock-comment-face) - (save-excursion (comment-beginning)))) - -(defun scala-in-string-p () - "Return t iff the point is inside a string." - (if font-lock-mode - (eq (get-text-property (point) 'face) 'font-lock-string-face) - (let ((limit (point))) - (beginning-of-line) - (loop while (search-forward-regexp "\\(^\\|[^\\\\]\\)\"" limit 'move) - count (not (scala-in-comment-p)) into quotes - finally return (oddp quotes))))) - -(defun scala-indentation () - "Return the suggested indentation for the current line." - (save-excursion - (beginning-of-line) - (or (and (scala-in-comment-p) - (not (= (char-after) ?\/)) - (scala-comment-indentation)) - (scala-indentation-from-following) - (scala-indentation-from-preceding) - (scala-indentation-from-block) - 0))) - -(defun scala-comment-indentation () - ;; Return suggested indentation inside of a comment. - (forward-line -1) - (beginning-of-line) - (skip-syntax-forward " ") - (if (looking-at "/\\*") - (+ 1 (current-column)) - (current-column))) - -(defun scala-block-indentation () - (let ((block-start-eol (scala-point-after (end-of-line))) - (block-after-spc (scala-point-after (scala-forward-spaces)))) - (if (> block-after-spc block-start-eol) - (+ (current-indentation) scala-indent-step) - (current-column)))) - -(defun scala-indentation-from-following () - ;; Return suggested indentation based on the following part of the - ;; current expression. Return nil if indentation cannot be guessed. - (save-excursion - (scala-forward-spaces (scala-point-after (end-of-line))) - (cond - ((eobp) nil) - ((= (char-syntax (char-after)) ?\)) - (let ((parse-sexp-ignore-comments t)) - (goto-char (1+ (scan-sexps (1+ (point)) -1)))) - (- (scala-block-indentation) scala-indent-step)) - ((looking-at scala-expr-middle-re) - ;; [...] this is a somewhat of a hack. - (let ((matching-kw (cdr (assoc (match-string-no-properties 0) - scala-expr-starter)))) - (while (and (search-backward-regexp matching-kw nil t) - (or (scala-in-comment-p) (scala-in-string-p))))) - (scala-move-if (backward-word 1) - (looking-at scala-compound-expr-re)) - (current-column))))) - -(defun scala-indentation-from-preceding () - ;; Return suggested indentation based on the preceding part of the - ;; current expression. Return nil if indentation cannot be guessed. - (save-excursion - (scala-backward-spaces) - (when (and (not (bobp)) - (or (eq (char-syntax (char-before)) ?\() - (progn - (when (eq (char-before) ?\)) - (backward-sexp) - (scala-backward-spaces)) - (scala-looking-at-backward scala-expr-start-re)))) - (+ (current-indentation) scala-indent-step)))) - -(defun scala-indentation-from-block () - ;; Return suggested indentation based on the current block. - (save-excursion - (let* ((state (scala-parse-partial-sexp)) - (block-start (nth 1 state))) - (if (not block-start) - 0 - (goto-char (1+ block-start)) - (scala-block-indentation))))) - -(defun scala-indent-line-to (column) - "Indent current line to COLUMN and perhaps move point. -The point is moved iff it is currently in the indentation, in which -case it is brought to the end of that indentation. Otherwise it does -not move." - (if (<= (current-column) (current-indentation)) - (indent-line-to column) - (save-excursion (indent-line-to column)))) - -(defun scala-indent-line () - "Indent current line as smartly as possible. -When called repeatedly, indent each time one stop further on the right." - (interactive) - (if (or (eq last-command this-command) - (eq last-command 'scala-undent-line)) - (scala-indent-line-to (+ (current-indentation) scala-indent-step)) - (let ((indentation (scala-indentation))) - (scala-indent-line-to indentation)))) - -(defun scala-undent-line () - "Indent line to previous tab stop." - (interactive) - (scala-indent-line-to (max 0 (- (current-indentation) scala-indent-step)))) - -(defun scala-electric-brace () - "Insert a brace, and if alone on a non-comment line, reindent." - (interactive) - (let ((on-empty-line-p (save-excursion - (beginning-of-line) - (looking-at "^\\s *$")))) - (call-interactively 'self-insert-command) - (when on-empty-line-p (scala-indent-line)))) - -;;; Syntax highlighting -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun scala-mark-borders (funs) - (loop for (fun . flag) in funs - if flag collect (point-marker) - while (funcall fun) - if flag collect (point-marker))) - -(defun scala-make-match (funs) - (let ((start-mark (point-marker)) - (markers (scala-mark-borders funs)) - (end-mark (point-marker))) - (cons start-mark (cons end-mark markers)))) - -(defconst scala-binding-end-re - (regexp-opt '(":" "=" "=>" ";" "<-"))) - -(defun scala-match-and-skip-binding (limit) - (skip-chars-forward " ()") - (and (not (or (looking-at "\\<\\(extends\\|with\\)\\>\\|{") - (scala-looking-at-special-identifier scala-binding-end-re))) - (ignore-errors - (save-restriction - (narrow-to-region (point-min) limit) - (let ((matches (scala-make-match - '((scala-forward-ident . t) - ((lambda () - (scala-forward-spaces) - (when (scala-looking-at-special-identifier ":") - (forward-char) - (scala-forward-spaces) - t)) . nil) - ((lambda () - (scala-forward-type) - (scala-when-looking-at "\\s *\\*") - t) . t))))) - (scala-when-looking-at "\\s *,") - (set-match-data matches))) - t))) - -(defun scala-match-and-skip-ident (limit) - (scala-forward-spaces) - (when (and (not (looking-at scala-keywords-re)) - (looking-at scala-qual-ident-re)) - (goto-char (match-end 0)) - t)) - -(defun scala-match-and-skip-type-param (limit) - (scala-when-looking-at "\\s *[[,]\\s *" - (let ((matches (scala-make-match '((scala-forward-type-param . t))))) - (scala-when-looking-at "\\s *\\]") - (set-match-data matches) - t))) - -(defun scala-match-and-skip-result-type (limit) - (scala-when-looking-at "\\s *:\\s *" - (set-match-data (list (point-marker) - (progn (scala-forward-type) (point-marker)))) - t)) - -(defconst scala-pattern-end-re - (regexp-opt '("if" "case" "class") 'words)) - -(defconst scala-pattern-end-special-re - (regexp-opt '( "=>" "=" "<-") t)) - -(defun scala-match-and-skip-pattern (limit) - (while (progn - (skip-chars-forward "()[], ") - (and (not (or (looking-at scala-pattern-end-re) - (scala-looking-at-special-identifier - scala-pattern-end-special-re))) - (looking-at scala-literal-re))) - (goto-char (match-end 0))) - (and (not (or (looking-at scala-pattern-end-re) - (scala-looking-at-special-identifier scala-pattern-end-special-re))) - (let ((case-fold-search nil)) - (cond ((looking-at scala-capitalized-ident-re) - (goto-char (match-end 0))) - ((scala-match-and-skip-binding limit) t))))) - -(defvar scala-font-lock-keywords - `(;; keywords - (,scala-keywords-re - 0 font-lock-keyword-face nil) - - ;; constants - (,scala-constants-re - 0 ,(if (boundp 'font-lock-constant-face) - 'font-lock-constant-face - 'font-lock-keyword-face) - nil) - - ;; modules - (,(concat "\\<\\(module\\|object\\)\\>\\s *\\(" scala-ident-re "\\)") - (2 font-lock-variable-name-face nil)) - - ;; type definitions - (,(concat "\\<type\\>\\s *\\(" scala-ident-re "\\)") - (1 font-lock-type-face nil)) - - ;; variables - ("\\<var\\>" - (scala-match-and-skip-binding (goto-char (match-end 0)) - nil - (1 font-lock-variable-name-face nil) - (2 font-lock-type-face nil t))) - - ;; functions - (,(concat "\\(^\\|[^(,]\\)\\s *\\<def\\>" "\\s *" "\\(" scala-ident-re "\\)\\s *") - (2 font-lock-function-name-face nil) - (scala-match-and-skip-type-param (goto-char (match-end 0)) nil - (1 font-lock-type-face nil t)) - (scala-match-and-skip-binding nil nil - (1 font-lock-variable-name-face nil) - (2 font-lock-type-face nil t)) - (scala-match-and-skip-result-type nil nil - (0 font-lock-type-face nil))) - - ;; class definitions - ("\\<\\(class\\|trait\\)\\>" - (scala-match-and-skip-ident (goto-char (match-end 0)) nil - (1 font-lock-type-face nil)) - (scala-match-and-skip-type-param nil nil - (1 font-lock-type-face nil t)) - (scala-match-and-skip-binding nil nil - (1 font-lock-variable-name-face nil) - (2 font-lock-type-face nil t))) - - ;; "extends" and "with" clauses - ("\\<\\(extends\\|with\\)\\>\\s *[^{]" - (scala-match-and-skip-ident (goto-char (1- (match-end 0))) nil - (0 font-lock-type-face nil)) - (scala-match-and-skip-type-param nil nil - (1 font-lock-type-face nil t))) - - ;; patterns - ("\\<\\(case\\|val\\)\\>\\s *" - (scala-match-and-skip-pattern (goto-char (match-end 0)) nil - (1 font-lock-variable-name-face nil) - (2 font-lock-type-face nil t))))) - - -(defvar scala-font-lock-syntactic-keywords - `((,scala-char-re (0 "\"" t nil)) - (scala-search-special-identifier-forward (0 "w" nil nil)))) - -; define scala-mode-hook -(defvar scala-mode-hook nil - "Hook to run after installing scala mode") - -;; Bug reporting - -(defun scala-report-bug () - "Report a bug to the author of the Scala mode via e-mail. -The package used to edit and send the e-mail is the one selected -through `mail-user-agent'." - (interactive) - (require 'reporter) - (let ((reporter-prompt-for-summary-p t)) - (reporter-submit-bug-report - scala-bug-e-mail - (concat "Scala mode v" scala-mode-version) - '(scala-indent-step)))) - -;; Customization - -(defun scala-customize () - "Customize Scala mode using the Customize package." - (interactive) - (customize-group 'scala)) - -(defun scala-interpreter-running-p () - "True iff a Scala interpreter is currently running in a buffer." - ;; The following makes sure that we do not autoload - ;; inferior-scala-mode just to check if the interpreter is running. - (and (fboundp 'inferior-scala-mode) - (let ((ism-def (symbol-function 'inferior-scala-mode))) - (not (and (consp ism-def) (eq (car ism-def) 'autoload)))) - (scala-interpreter-running-p-1))) - -(defun scala-browse-web-site () - "Browse the Scala home-page" - (interactive) - (require 'browse-url) - (browse-url scala-web-url)) - -;;; Mode -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -;;;###autoload -(define-derived-mode scala-mode fundamental-mode "Scala" - "Major mode for editing Scala code. - -When started, run `scala-mode-hook'. - -\\{scala-mode-map}" - ;; Font lock - (make-local-variable 'font-lock-defaults) - (setq font-lock-defaults - `(scala-font-lock-keywords - nil - nil - ((?\_ . "w")) - nil - (font-lock-syntactic-keywords . ,scala-font-lock-syntactic-keywords) - (parse-sexp-lookup-properties . t))) - - ;; Paragraph separation - (make-local-variable 'paragraph-start) - (setq paragraph-start (concat "^\\s *$\\|" page-delimiter)) - (make-local-variable 'paragraph-separate) - (setq paragraph-separate paragraph-start) - (make-local-variable 'paragraph-ignore-fill-prefix) - (setq paragraph-ignore-fill-prefix t) - - ;; Comment handling - (make-local-variable 'comment-start) - (setq comment-start "// ") - (make-local-variable 'comment-end) - (setq comment-end "") - (make-local-variable 'comment-multi-line) - (setq comment-multi-line nil) - (make-local-variable 'comment-start-skip) - (setq comment-start-skip "/\\*+ *\\|//+ *") - (make-local-variable 'comment-end-skip) - (setq comment-end-skip " *\\*+/\\| *") - - ;; Misc - (make-local-variable 'indent-line-function) - (setq indent-line-function #'scala-indent-line) - (make-local-variable 'require-final-newline) - (setq require-final-newline t)) - - -;; Keymap -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(define-key scala-mode-map [tab] 'scala-indent-line) -(define-key scala-mode-map [(control tab)] 'scala-undent-line) -(define-key scala-mode-map [backspace] 'backward-delete-char-untabify) - -(define-key scala-mode-map [(control c)(control l)] 'scala-load-file) -(define-key scala-mode-map [(control c)(control r)] 'scala-eval-region) -(define-key scala-mode-map [(control c)(control b)] 'scala-eval-buffer) - -(define-key scala-mode-map [(control c)(control c)] 'comment-region) - -(define-key scala-mode-map "}" 'scala-electric-brace) - -(easy-menu-define scala-menu-bar scala-mode-map "Scala menu" - '("Scala" - ["Run interpreter..." - run-scala (not (scala-interpreter-running-p))] - ["Quit interpreter" - scala-quit-interpreter (scala-interpreter-running-p)] - ["Load file in interpreter..." - scala-load-file (scala-interpreter-running-p)] - ["Switch to interpreter" - scala-switch-to-interpreter (scala-interpreter-running-p)] - ["Evaluate region" - scala-eval-region (and (scala-interpreter-running-p) - mark-active)] - ["Evaluate buffer" - scala-eval-buffer (scala-interpreter-running-p)] - "---" - ["Browse Scala Web site..." - scala-browse-web-site t] - ["Customize..." - scala-customize t] - ["Report bug..." - scala-report-bug t])) - -;; Syntax tables -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -;; strings and character literals -(modify-syntax-entry ?\" "\"" scala-mode-syntax-table) -(modify-syntax-entry ?\\ "\\" scala-mode-syntax-table) - -;; different kinds of "parenthesis" -(modify-syntax-entry ?\( "()" scala-mode-syntax-table) -(modify-syntax-entry ?\[ "(]" scala-mode-syntax-table) -(modify-syntax-entry ?\{ "(}" scala-mode-syntax-table) -(modify-syntax-entry ?\) ")(" scala-mode-syntax-table) -(modify-syntax-entry ?\] ")[" scala-mode-syntax-table) -(modify-syntax-entry ?\} "){" scala-mode-syntax-table) - -;; special characters -(modify-syntax-entry ?\_ "_" scala-mode-syntax-table) - -(dolist (char scala-all-special-chars) - (modify-syntax-entry char "." scala-mode-syntax-table)) -(modify-syntax-entry ?\. "." scala-mode-syntax-table) - -;; comments -(modify-syntax-entry ?\/ ". 124b" scala-mode-syntax-table) -(modify-syntax-entry ?\* ". 23" scala-mode-syntax-table) -(modify-syntax-entry ?\n "> b" scala-mode-syntax-table) -(modify-syntax-entry ?\r "> b" scala-mode-syntax-table) - -; run hooks -(run-hooks 'scala-mode-hook) - -(provide 'scala-mode) |