branch: elpa/scala-mode
commit a8b0936d466b499f0e20897e93c2a9236c3608d0
Author: Heikki Vesalainen <heikkivesalai...@yahoo.com>
Commit: Heikki Vesalainen <heikkivesalai...@yahoo.com>
Working on syntax
---
Example.scala | 58 +++++++-
Test.scala | 31 ++++
scala-mode-constants.el | 8 ++
scala-mode-fontlock.el | 28 ++++
scala-mode-indent.el | 13 ++
scala-mode-map.el | 26 ++++
scala-mode-syntax.el | 376 ++++++++++++++++++++++++++++++++++++++++++++++++
scala-mode.el | 97 +++++++++++++
8 files changed, 631 insertions(+), 6 deletions(-)
diff --git a/Example.scala b/Example.scala
index 7eb013c..3b312b6 100644
--- a/Example.scala
+++ b/Example.scala
@@ -12,14 +12,14 @@ Indenting happens relative to an indent anchor. Usually the
indent anchor is the
the declaration or expression is inside a parameter list, then the anchor is
inside the list.
*/
-def f(s: String <%,
- i: Int) =
+def f(s: String,
+ i: Int) =
s.take(i) // indented relative to 'def'
/* */ val x = foo(
zot, // indented relative to '/* */'
someThing
- map (x=a===> x.length) // indented relative to 'someThing'
+ map (x => x.length) // indented relative to 'someThing'
)
val x =
@@ -41,7 +41,7 @@ Any line not beginning with a declaration or expression start
reserved word (i.e
This rule does not apply in the following cases:
- if the previous lines was empty
- previous line was an annotation
-- previous statement ended with ';'
+- previous statement ended with ';,'
- the current line starts a body (of declaration or anonymous function)
- block or simple expression starts with an anonymous function (lambda)
declaration
*/
@@ -89,6 +89,11 @@ List("foo", "bar")
s.length
)
+List("foo") map (
+ s => // start lambda
+ s.length // run-on rule does not apply
+)
+
/*
1.3 Parameter lists
@@ -102,6 +107,7 @@ of a line, it will be indented to the same column as the
first paremeter groups
parentheses.
- A closing parantheses that is on its own line, will be indented to the same
column
with the indent anchor.
+- Rule does not apply, if the first parameter was a lambda expression
*/
class Foo(
@@ -181,12 +187,17 @@ val z = for { i <- 1 to 10,
}
/*
-1.7 If statements
+1.7 If and try statements
If statements will be indented acording to the following rules:
-- The the body of the 'if' or 'else if' statement is a simple expression (i.e.
not a block), then the next 'else if' or 'else' is aligned with the previous
'if' or 'else if',
+- If the the body of the 'if' or 'else if' statement is a simple expression
(i.e. not a block), then the next 'else if' or 'else' is aligned with the
previous 'if' or 'else if',
- otherwise 'else if' and 'else' is aligned with previous block close.
+
+Try statements will be indented acording to the following rules:
+- If the body of the 'try' is a simple expression (i.e. not a block), then the
next 'catch' is aligned with the previous try
+- otherwise 'catch' is aligned with previous block close.
+- Finally is aligned similarly
*/
val x = if (kissa)
@@ -204,6 +215,25 @@ val y = if (kissa) {
zot
}
+val a = try
+ foo()
+ catch {
+ case e => bar()
+ }
+
+val b = try {
+ foo()
+} catch {
+ case e => bar()
+} finally {
+ zot()
+}
+
+val c = try
+ zot()
+ finally
+ log("zotted")
+
/*
1.8 Block opening curly brackets on new line
@@ -232,3 +262,19 @@ class Foo
"hello"
}
}
+
+/*
+2. font-lock support
+*/
+
+/*
+2.1 Types
+*/
+
+val strings = Seq("""multi
+line"quote
+strings""", "normal strings", 'c')
+
+val `quoted id` = 1
+
+val symbol = 'Symbol
diff --git a/Test.scala b/Test.scala
new file mode 100644
index 0000000..5fb26be
--- /dev/null
+++ b/Test.scala
@@ -0,0 +1,31 @@
+/* fooo bar */
+
+"""foo""".r """bar""".r
+
+"""
+qasduote_asdasd a+_
+'f'
+""", val zot "fo\ro"
+
+__
+
+asdasd_dfasdf_>> _<<
+
+val x:[Type <% Foo] => '\u123c'
+val y = "foo a\"sdasd"
+" ", " ", "as\"dasd"
+`asdasd`> asdasdasd
+"asdasd
+
+"""asdasdasd
+asdasda
+asdasdasd
+asdasdasd"asda"
+asdasdasdasdasd asd""
+asdasd
+asdasdasdasdasd"""asdasdasd
+
+"""asdasd"""asasdasd
+
+"""asdasdasdasdasdlkjhasd
+asdasdkj"""
diff --git a/scala-mode-constants.el b/scala-mode-constants.el
new file mode 100644
index 0000000..2c7507d
--- /dev/null
+++ b/scala-mode-constants.el
@@ -0,0 +1,8 @@
+;;; scala-mode-constants.el - Major mode for editing scala, constants
+;;; Copyright (c) 2012 Heikki Vesalainen
+;;; For information on the License, see the LICENSE file
+
+;;; Based on Scala Language Specification (SLS) Version 2.9
+
+(provide 'scala-mode-constants)
+
diff --git a/scala-mode-fontlock.el b/scala-mode-fontlock.el
new file mode 100644
index 0000000..31f64ee
--- /dev/null
+++ b/scala-mode-fontlock.el
@@ -0,0 +1,28 @@
+;;; scala-mode-fontlock.el - Major mode for editing scala, font-lock
+;;; Copyright (c) 2012 Heikki Vesalainen
+;;; For information on the License, see the LICENSE file
+
+(provide 'scala-mode-fontlock)
+
+(require 'scala-mode-syntax)
+(require 'scala-mode-constants)
+
+(defun scala-font-lock:mark-symbol (limit)
+ (if (re-search-forward scala-syntax:reserved-symbols-re limit t)
+ (goto-char (match-end 2)) ;; step back to the match (re matches futher)
+ nil))
+
+(defun scala-font-lock:mark-underscore (limit)
+ (if (re-search-forward scala-syntax:reserved-symbol-underscore-re limit t)
+ (goto-char (match-end 2)) ;; step back to the match (re matches futher)
+ nil))
+
+(defvar scala-font-lock:keywords
+ `(;; keywords
+ (,scala-syntax:keywords-re 0 font-lock-keyword-face)
+
+ ;; symbols
+ (scala-font-lock:mark-symbol 2 font-lock-keyword-face)
+ (scala-font-lock:mark-underscore 2 font-lock-keyword-face)
+
+))
diff --git a/scala-mode-indent.el b/scala-mode-indent.el
new file mode 100644
index 0000000..b10356e
--- /dev/null
+++ b/scala-mode-indent.el
@@ -0,0 +1,13 @@
+;;; scala-mode.el - Major mode for editing scala, indenting
+;;; Copyright (c) 2012 Heikki Vesalainen
+;;; For information on the License, see the LICENSE file
+
+(provide 'scala-mode-indent)
+
+(defun scala-goto-indent-anhor ()
+ "moves back to the point whose column will be used as
+the anchor relative to which indenting is calculated."
+ (interactive)
+
+)
+
diff --git a/scala-mode-map.el b/scala-mode-map.el
new file mode 100644
index 0000000..9ad1758
--- /dev/null
+++ b/scala-mode-map.el
@@ -0,0 +1,26 @@
+;;; scala-mode-map.el - Major mode for editing scala, keyboard map
+;;; Copyright (c) 2012 Heikki Vesalainen
+;;; For information on the License, see the LICENSE file
+
+(provide 'scala-mode-map)
+
+(defmacro scala-mode-map:define-keys (key-map key-funcs)
+ (cons 'progn (mapcar
+ #'(lambda (key-func)
+ `(define-key ,key-map ,(car key-func) ,(cadr key-func)))
+ key-funcs)))
+
+(defvar scala-mode-map nil
+ "Local key map used for scala mode")
+
+(when (not scala-mode-map)
+ (let ((keymap (make-sparse-keymap)))
+ (scala-mode-map:define-keys
+ keymap
+ (([backspace] 'backward-delete-char-untabify)
+ ;; ("\r" 'scala-newline)
+ ([(control c)(control c)] 'comment-region)
+ ;; ("}" 'scala-electric-brace)
+ ))
+ (setq scala-mode-map keymap)))
+
diff --git a/scala-mode-syntax.el b/scala-mode-syntax.el
new file mode 100644
index 0000000..84c3e10
--- /dev/null
+++ b/scala-mode-syntax.el
@@ -0,0 +1,376 @@
+;;;; scala-mode-syntax.el - Major mode for editing scala, syntax
+;;; Copyright (c) 2012 Heikki Vesalainen
+;;; For information on the License, see the LICENSE file
+
+;;; Based on Scala Language Specification (SLS) Version 2.9
+
+(provide 'scala-mode-syntax)
+
+(require 'scala-mode-constants)
+
+;;;; Scala syntax regular expressions
+;;; Based on the Scala language specification 2.9. Note: order is not
+;;; the same as in the document, as here things are declared before
+;;; used.
+
+;;; A note on naming. Things that end with '-re' are regular
+;;; expressions. Things that end with '-group' are regular expression
+;;; character groups without the enclosing [], i.e. they are not
+;;; regular expressions, but can be used in declaring one.
+
+;; single letter matching groups (Chapter 1)
+(defconst scala-syntax:hexDigit-group "0-9A-Fa-f")
+(defconst scala-syntax:UnicodeEscape-re (concat "\\\\u["
scala-syntax:hexDigit-group "]\\{4\\}"))
+
+(defconst scala-syntax:upper-group "_[:upper:]\\$") ;; missing _ to make ids
work
+(defconst scala-syntax:upperAndUnderscore-group (concat "_"
scala-syntax:upper-group ))
+(defconst scala-syntax:lower-group "[:lower:]")
+(defconst scala-syntax:letter-group (concat scala-syntax:lower-group
scala-syntax:upper-group)) ;; TODO: add Lt, Lo, Nl
+(defconst scala-syntax:digit-group "0-9")
+(defconst scala-syntax:opchar-group "!#%&*+/:<=>?@\\\\\\^|~\\-") ;; TODO: Sm,
So
+
+;; Integer Literal (Chapter 1.3.1)
+(defconst scala-syntax:nonZeroDigit-group "1-9")
+(defconst scala-syntax:octalDigit-group "0-7")
+(defconst scala-syntax:decimalNumeral-re
+ (concat "0"
+ "\\|[" scala-syntax:nonZeroDigit-group "][" scala-syntax:digit-group
"]*"))
+(defconst scala-syntax:hexNumeral-re (concat "0x[" scala-syntax:hexDigit-group
"]+"))
+(defconst scala-syntax:octalNumeral-re (concat "0["
scala-syntax:octalDigit-group "]+"))
+(defconst scala-syntax:integerLiteral-re (concat "-?" ;; added from definition
of literal
+ "\\(" scala-syntax:decimalNumeral-re
+ "\\|" scala-syntax:hexNumeral-re
+ "\\|" scala-syntax:octalNumeral-re
+ "\\)[Ll]?"))
+
+;; Floating Point Literal (Chapter 1.3.2)
+(defconst scala-syntax:exponentPart-re (concat "\\([eE][+-]?["
scala-syntax:digit-group "]+\\)"))
+(defconst scala-syntax:floatType-re "[fFdD]")
+(defconst scala-syntax:floatingPointLiteral-re
+ (concat "-?" ;; added from definition of literal
+ "\\([" scala-syntax:digit-group "]+\\.[" scala-syntax:digit-group
"]*"
+ scala-syntax:exponentPart-re "?" scala-syntax:floatType-re "?"
+ "\\|" "\\.[" scala-syntax:digit-group "]+"
+ scala-syntax:exponentPart-re "?" scala-syntax:floatType-re "?"
+ "\\|" "[" scala-syntax:digit-group "]+" scala-syntax:exponentPart-re
+ "\\|" "[" scala-syntax:digit-group "]+" scala-syntax:floatType-re
"\\)"))
+
+;; Boolean Literals (Chapter 1.3.3)
+(defconst scala-syntax:booleanLiteral-re "true|false")
+
+;; Escape Sequences (Chapter 1.3.6)
+(defconst scala-syntax:escapeSequence-re "\\\\['btnfr\"\\\\]")
+
+;; Character Literals (Chapter 1.3.4)
+(defconst scala-syntax:characterLiteral-re
+ (concat "\\('\\)\\(" "[^\\\\]" ;; should be just printable char, but this is
faster
+ "\\|" scala-syntax:escapeSequence-re
+ "\\|" scala-syntax:UnicodeEscape-re "\\)\\('\\)"))
+
+;; String Literals (Chapter 1.3.5)
+(defconst scala-syntax:stringElement-re
+ (concat "\\(" "[^\n\"\\\\\]"
+ "\\|" scala-syntax:escapeSequence-re
+ "\\|" scala-syntax:UnicodeEscape-re "\\)"))
+(defconst scala-syntax:oneLineStringLiteral-re (concat "\\(\"\\)"
scala-syntax:stringElement-re "*\\(\"\\)"))
+(defconst scala-syntax:multiLineStringLiteral-re
+ "\\(\"\\)\\(\"\"\\(\"?\"?[^\"]\\)*\"\"+\\)\\(\"\\)")
+(defconst scala-syntax:stringLiteral-re
+ (concat "\\(" scala-syntax:multiLineStringLiteral-re
+ "\\|" scala-syntax:oneLineStringLiteral-re "\\)" ))
+
+;; Identifiers (Chapter 1.1)
+(defconst scala-syntax:op-re (concat "[" scala-syntax:opchar-group "]+"))
+(defconst scala-syntax:idrest-re
+ ;; Eagerness of regexp causes problems with _. The following is a workaround,
+ ;; but the resulting regexp matches only what SLS demands.
+ (concat "\\(" "[_]??" "[" scala-syntax:letter-group scala-syntax:digit-group
"]+" "\\)*"
+ "\\(" "_+" scala-syntax:op-re "\\|" "_" "\\)?"))
+(defconst scala-syntax:varid-re (concat "[" scala-syntax:lower-group "]"
scala-syntax:idrest-re))
+(defconst scala-syntax:capitalid-re (concat "["
scala-syntax:upperAndUnderscore-group "]" scala-syntax:idrest-re))
+(defconst scala-syntax:plainid-re (concat "\\(" scala-syntax:capitalid-re
+ "\\|" scala-syntax:varid-re
+ "\\|" scala-syntax:op-re "\\)"))
+;; stringlit is referred to, but not defined Scala Language Specification 2.9
+(defconst scala-syntax:stringlit-re (concat scala-syntax:stringElement-re
"*?"))
+(defconst scala-syntax:quotedid-re (concat "`" scala-syntax:stringlit-re "`"))
+(defconst scala-syntax:id-re (concat "\\(" scala-syntax:plainid-re
+ "\\|" scala-syntax:quotedid-re "\\)"))
+
+;; Symbol literals (Chapter 1.3.7)
+(defconst scala-syntax:symbolLiteral-re
+ ;; must end with non-' to not conflict with scala-syntax:characterLiteral-re
+ (concat "'" scala-syntax:plainid-re "\\([^']\\|$\\)"))
+
+;; Literals (Chapter 1.3)
+(defconst scala-syntax:literal-re
+ (concat "\\(" scala-syntax:integerLiteral-re
+ "\\|" scala-syntax:floatingPointLiteral-re
+ "\\|" scala-syntax:booleanLiteral-re
+ "\\|" scala-syntax:characterLiteral-re
+ "\\|" scala-syntax:stringLiteral-re
+ "\\|" scala-syntax:symbolLiteral-re
+ "\\|" "null" "\\)"))
+
+;; Paths (Chapter 3.1)
+(defconst scala-syntax:classQualifier-re (concat "\\[" scala-syntax:id-re
"\\]"))
+(defconst scala-syntax:stableId-re
+ (concat "\\(\\(" scala-syntax:id-re
+ "\\|" "this"
+ "\\|" "super" scala-syntax:classQualifier-re "\\)\\.\\)*"
+ scala-syntax:id-re))
+(defconst scala-syntax:path-re
+ (concat "\\(" scala-syntax:stableId-re
+ "\\|" "\\(" scala-syntax:id-re "\\." "\\)?" "this" "\\)"))
+
+
+;;;
+;;; Other regular expressions
+;;;
+
+(defconst scala-syntax:empty-line-re
+ "^\\s *$")
+
+(defconst scala-syntax:keywords-re
+ (regexp-opt '("abstract" "case" "catch" "class" "def"
+ "do" "else" "extends" "false" "final"
+ "finally" "for" "forSome" "if" "implicit"
+ "import" "lazy" "match" "new" "null"
+ "object" "override" "package" "private" "protected"
+ "return" "sealed" "super" "this" "throw"
+ "trait" "try" "true" "type" "val"
+ "var" "while" "with" "yield") 'words))
+
+
+;; false, true, null, super, this are neither
+
+(defconst scala-syntax:after-reserved-symbol-underscore-re
+ ;; what can be after reserved symbol _ (if there is something else, it
+ ;; will be upper case letter per SLS)
+ (concat "$\\|[^" scala-syntax:upper-group scala-syntax:lower-group
scala-syntax:digit-group "]"))
+
+(defconst scala-syntax:reserved-symbol-underscore-re
+ ;; reserved symbol _
+ (concat "\\(^\\|[^" scala-syntax:upper-group scala-syntax:lower-group
scala-syntax:digit-group "]\\)"
+ "\\(_\\)"
+ "\\($\\|[^" scala-syntax:upper-group scala-syntax:lower-group
scala-syntax:digit-group "]\\)"))
+
+(defconst scala-syntax:reserved-symbols-re
+ ;; reserved symbols and XML starts ('<!' and '<?')
+ (concat "\\(^\\|[^" scala-syntax:opchar-group "]\\)"
+ "\\([:=#@\u21D2\u2190]\\|=>\\|<[:%!?\\-]\\|>:\\)"
+ "\\($\\|[^" scala-syntax:opchar-group "]\\)"))
+
+(defconst scala-syntax:reserved-re
+ (concat scala-syntax:keywords-re "\\|" scala-syntax:reserved-symbols-re
"\\|" scala-syntax:reserved-symbol-underscore-re))
+
+(defconst scala-syntax:mustNotTerminate-keywords-re
+ "Keywords which cannot end a expression and are infact a sign of run-on."
+ (regexp-opt '("catch", "else", "extends", "finally",
+ "forSome", "match", "with", "yield") 'words))
+
+(defconst scala-syntax:mustNotTerminate-re
+ "All keywords and symbols that cannot terminate a expression
+and are infact a sign of run-on, except for @, which may start
+an expression with annotation."
+ (concat "\\(" scala-syntax:mustNotTerminate-keywords-re
+ "\\|" scala-syntax:reserved-symbols-re "\\)"))
+
+(defconst scala-syntax:mustTerminate-re
+ "Symbols that must terminate an expression, i.e the following expression
+cannot be a run-on. This includes only , and ; and the empty line"
+ (concat "\\([,;]|" scala-syntax:empty-line-re "\\)"))
+
+(defconst scala-syntax:mustNotContinue-re
+ "Keywords that begin an expression, i.e they cannot be run-on to the
+previous the line even if there is no semi in between."
+ ;; 'case' and 'while' are unclear. 'case' might belong to 'case class'
+ ;; while 'while' might belong to a 'do..while'
+ (regexp-opt '("abstract", "class", "def", "do", "final",
+ "for", "if", "implicit", "import", "lazy",
+ "new", "object", "override", "package", "private",
+ "protected", "return", "sealed", "throw",
+ "trait", "try", "type", "val", "var") 'words))
+
+(defconst scala-syntax:double-arrow-re
+ "=>\\|\u21D2")
+
+(defconst scala-syntax:multiLineStringLiteral-start-re
+ "\\(\"\\)\"\"")
+
+(defconst scala-syntax:multiLineStringLiteral-end-re
+ "\"\"+\\(\"\\)")
+
+(defun scala-syntax:find-reserved-symbols ()
+ (interactive)
+ (re-search-forward scala-syntax:reserved-symbols-re nil t))
+
+
+;;;; Character syntax table and related syntax-propertize functions
+;;; The syntax table relies havily on the syntax-propertize-functions being
+;;; run. Hence this syntax requires at least emacs 24, which introduced
+;;; this new facility.
+
+(defvar scala-syntax:syntax-table nil
+ "Syntax table used in `scala-mode' buffers.")
+(when (not scala-syntax:syntax-table)
+ (let ((syntab (make-syntax-table)))
+ ;; 1. start by reseting the syntax table: only (){}[] are
+ ;; parentheses, so all others marked as parentheses in the parent
+ ;; table must be marked as symbols, nothing is a punctuation
+ ;; unless otherwise stated
+ (map-char-table
+ #'(lambda (key value)
+ (when (or (= (syntax-class value) 4) ; open
+ (= (syntax-class value) 5) ; close
+ (= (syntax-class value) 1)) ; punctuation
+ (modify-syntax-entry key "_" syntab)))
+ (char-table-parent syntab))
+
+ ;; Below 'space', everything is either illegal or whitespace.
+ ;; Consider as whitespace, unless otherwise stated below.
+ (modify-syntax-entry '(0 . 32) " " syntab)
+
+ ;; The scala parentheses
+ (modify-syntax-entry ?\( "()" syntab)
+ (modify-syntax-entry ?\[ "(]" syntab)
+ (modify-syntax-entry ?\{ "(}" syntab)
+ (modify-syntax-entry ?\) ")(" syntab)
+ (modify-syntax-entry ?\] ")[" syntab)
+ (modify-syntax-entry ?\} "){" syntab)
+
+ ;; _ is upper-case letter, but will be modified to be punctuation
+ ;; when in reserved symbol position by syntax-propertize-function
+ (modify-syntax-entry ?\_ "w" syntab)
+
+ ;; by default all opchars are punctuation, but they will be
+ ;; modified by syntax-propertize-function to be symbol
+ ;; constituents when a part of varid or capitalid
+ (dolist (char (mapcar 'identity "#%:<=>@!&*+-/?\\^|~\u21D2\u2190")) ;;
TODO: Sm, So
+ (modify-syntax-entry char "." syntab))
+
+ ;; what can I say? It's the escape char.
+ (modify-syntax-entry ?\\ "." syntab)
+
+ ;; scala strings cannot span lines, so we mark
+ ;; " as punctuation, but do the real stuff
+ ;; in syntax-propertize-function for properly
+ ;; formatted strings.
+ (modify-syntax-entry ?\" "." syntab)
+
+ ;; backquote is given paired delimiter syntax so that
+ ;; quoted ids are parsed as one sexp. Fontification
+ ;; is done separately.
+ (modify-syntax-entry ?\` "$" syntab)
+
+ ;; ' is considered an expression prefix, since it can
+ ;; both start a Symbol and is a char quote. It
+ ;; will be given string syntax by syntax-propertize-function
+ ;; for properly formatted char literals.
+ (modify-syntax-entry ?\' "'" syntab)
+
+ ;; punctuation as specified by SLS
+ (modify-syntax-entry ?\. "." syntab)
+ (modify-syntax-entry ?\; "." syntab)
+ (modify-syntax-entry ?\, "." syntab)
+
+ ;; comments
+ ;; the `n' means that comments can be nested
+ (modify-syntax-entry ?\/ ". 124b" syntab)
+ (modify-syntax-entry ?\* ". 23n" syntab)
+ (modify-syntax-entry ?\n "> b" syntab)
+ (modify-syntax-entry ?\r "> b" syntab)
+
+ (setq scala-syntax:syntax-table syntab)))
+
+(defun scala-syntax:propertize-extend-region (start end)
+ "See syntax-propertize-extend-region-functions"
+ ;; nothing yet
+ nil)
+
+(defmacro scala-syntax:put-syntax-table-property (match-group value)
+ "Add 'syntax-table entry 'value' to the region marked by the
+match-group 'match-group'"
+ `(put-text-property (match-beginning ,match-group)
+ (match-end ,match-group)
+ 'syntax-table
+ ,value))
+
+(defun scala-syntax:propertize-characterLiterals (start end)
+ "Mark start and end of character literals as syntax class
+7 (string quotes). Only valid character literals will be marked."
+ (save-excursion
+ (goto-char start)
+ (while (re-search-forward scala-syntax:characterLiteral-re end t)
+ (scala-syntax:put-syntax-table-property 1 '(7 . nil))
+ (scala-syntax:put-syntax-table-property 3 '(7 . nil)))))
+
+(defun scala-syntax:propertize-stringLiterals (start end)
+ "Mark start and end of both one-line and multi-line string
+literals. One-line strings use syntax class 7 (string quotes),
+while multi-line strings are marked with 15 (generic string
+delimiter). Multi-line string literals are marked even if they
+are unbalanced. One-line string literals have to be balanced to
+get marked. This means invalid one-line strings will not be fontified."
+ (let* ((string-state (nth 3 (syntax-ppss start)))
+ (unbalanced-p (eq string-state t)))
+
+ (if (and string-state (not unbalanced-p))
+ ;; a normal string is open, let's de-propertize
+ (remove-text-properties start end '(syntax-table nil))
+ (save-excursion
+ (goto-char start)
+ ;; close the closing for the unbalanced multi-line literal
+ (when (and unbalanced-p
+ (re-search-forward
scala-syntax:multiLineStringLiteral-end-re end t))
+ (scala-syntax:put-syntax-table-property 1 '(15 . nil)))
+ ;; match any balanced one-line or multi-line literals
+ (catch 'break
+ (while (re-search-forward scala-syntax:stringLiteral-re end t)
+ (cond
+ ((match-beginning 2)
+ (scala-syntax:put-syntax-table-property 2 '(15 . nil))
+ (scala-syntax:put-syntax-table-property 5 '(15 . nil)))
+ ((or (match-end 7) ; group 7 is non-nil, ie. online string is not
empty
+ (= (match-end 8) (line-end-position)) ; empty string at line
end
+ (not (= (char-after (match-end 8)) ?\"))) ; no " after empty
string
+ (scala-syntax:put-syntax-table-property 6 '(7 . nil))
+ (scala-syntax:put-syntax-table-property 8 '(7 . nil)))
+ (t ;; backtrack and continue to next while loop
+ (goto-char (match-beginning 0))
+ (throw 'break nil)))))
+ ;; match any start of multi-line literals that are not yet balanced
+ (when (re-search-forward scala-syntax:multiLineStringLiteral-start-re
end t)
+ (scala-syntax:put-syntax-table-property 1 '(15 . nil)))))))
+
+(defun scala-syntax:propertize-underscore-and-idrest (start end)
+ "Mark all underscores (_) as punctuation (syntax 1) or upper
+case letter (syntax 2). Also mark opchars in idrest as symbol
+constituents (syntax 3)"
+ (save-excursion
+ (goto-char start)
+ (while (re-search-forward "_" end t)
+ (let ((match-beg (match-beginning 0))
+ (match-end (match-end 0)))
+ (put-text-property
+ match-beg match-end 'syntax-table
+ (if (= match-beg (line-beginning-position))
+ (if (looking-at scala-syntax:after-reserved-symbol-underscore-re)
+ '(1 . nil) ; punctuation
+ '(2 . nil)) ; word syntax
+ (save-excursion
+ (goto-char (1- match-beg))
+ (if (looking-at scala-syntax:reserved-symbol-underscore-re)
+ '(1 . nil) ; punctuation
+ ;; check for opchars that should be marked as symbol
constituents (3)
+ (goto-char match-end)
+ (when (looking-at scala-syntax:op-re)
+ (scala-syntax:put-syntax-table-property 0 '(3 . nil)))
+ '(2 . nil))))))))) ;; word syntax (2) for the '_'
+
+(defun scala-syntax:propertize (start end)
+ "See syntax-propertize-function"
+ (scala-syntax:propertize-characterLiterals start end)
+ (scala-syntax:propertize-stringLiterals start end)
+ (scala-syntax:propertize-underscore-and-idrest start end))
+
diff --git a/scala-mode.el b/scala-mode.el
new file mode 100644
index 0000000..5038b7b
--- /dev/null
+++ b/scala-mode.el
@@ -0,0 +1,97 @@
+;;; scala-mode.el - Major mode for editing scala
+;;; Copyright (c) 2012 Heikki Vesalainen
+;;; For information on the License, see the LICENSE file
+
+;;; Based on Scala Language Specification (SLS) Version 2.9
+
+(provide 'scala-mode)
+
+(require 'scala-mode-constants)
+(require 'scala-mode-syntax)
+(require 'scala-mode-fontlock)
+(require 'scala-mode-indent)
+(require 'scala-mode-map)
+
+;; Tested only for emacs 23
+(unless (<= 23 emacs-major-version)
+ (error
+ (format "The Scala mode has been tested only on Emacs version 23.x (and not
your Emacs version %s.%s)"
+ emacs-major-version emacs-minor-version)))
+
+;; Attach .scala files to the scala-mode
+(add-to-list 'auto-mode-alist '("\\.scala\\'" . scala-mode))
+(modify-coding-system-alist 'file "\\.scala\\'" 'utf-8)
+
+
+(defmacro scala-mode:make-local-variables (&rest quoted-names)
+ (cons 'progn (mapcar #'(lambda (quoted-name) `(make-local-variable
,quoted-name)) quoted-names)))
+
+;; (defun scala-mode ()
+;; "Major mode for editing scala code.
+
+;; When started, runs `scala-mode-hook'.
+
+;; \\{scala-mode-map}"
+;; (interactive)
+;; (kill-all-local-variables)
+;; (set-syntax-table scala-mode-syntax-table)
+
+;; (scala-mode:make-local-variables
+;; 'require-final-newline
+;; 'comment-start
+;; 'comment-end
+;; 'comment-start-line
+;; 'comment-column
+;; 'comment-multi-line)
+
+;;;###autoload
+(define-derived-mode scala-mode prog-mode "Scala"
+ "Major mode for editing scala code.
+
+When started, runs `scala-mode-hook'.
+
+\\{scala-mode-map}"
+ :syntax-table scala-syntax:syntax-table
+; :group
+; :abbrev
+
+ (scala-mode:make-local-variables
+ 'syntax-propertize-function
+ 'font-lock-defaults
+ 'comment-start
+ 'comment-end
+ 'comment-start-skip
+ 'comment-column
+ 'comment-multi-line)
+
+ (add-hook 'syntax-propertize-extend-region-functions
+ 'scala-syntax:propertize-extend-region)
+ (setq
+ syntax-propertize-function 'scala-syntax:propertize
+ parse-sexp-lookup-properties t
+
+ ;; TODO: font-lock
+ font-lock-defaults '(scala-font-lock:keywords
+ nil)
+
+ ;; TODO: paragraph-start, paragraphs-separate,
paragraph-ignore-fill-prefix
+ ;; TODO: beginning-of-defun-function, end-of-defun-function
+
+ ;; comments
+ comment-start "// "
+ comment-end ""
+ comment-start-skip "\\(//+\\|/\\*+\\)\\s *"
+ comment-column 0
+ comment-multi-line t
+ ;; TODO: comment-indent-function
+ )
+ (use-local-map scala-mode-map)
+ (turn-on-font-lock)
+)
+
+
+
+
+
+
+
