# Leo colorizer control file for scala mode.
# This file is in the public domain.

# Properties for scala mode.
properties = {
    "commentEnd": "*/",
    "commentStart": "/*",
    "doubleBracketIndent": "false",
    "indentCloseBrackets": "}",
    "indentOpenBrackets": "{",
    "indentPrevLine": "\\s*(((if|while)\\s*\\(|else\\s*(\\{|$)|else\\s+if\\s*\\(|case\\s+.+:|default:)[^;]*|for\\s*\\(.*)",
    "indentSize": "2",
    "lineComment": "//",
    "lineUpClosingBracket": "true",
    "noTabs": "true",
    "tabSize": "2",
    "wordBreakChars": ",+-=<>/?^&*",
}

# Attributes dict for scala_main ruleset.
scala_main_attributes_dict = {
    "default": "null",
    "digit_re": "(0[lL]?|[1-9]\\d{0,9}(\\d{0,9}[lL])?|0[xX]\\p{XDigit}{1,8}(\\p{XDigit}{0,8}[lL])?|0[0-7]{1,11}([0-7]{0,11}[lL])?|([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?|[0-9]+([eE][+-]?[0-9]+[fFdD]?|([eE][+-]?[0-9]+)?[fFdD]))",
    "escape": "\\",
    "highlight_digits": "true",
    "ignore_case": "false",
    "no_word_sep": "",
}

# Attributes dict for scala_primary ruleset.
scala_primary_attributes_dict = {
    "default": "null",
    "digit_re": "(0[lL]?|[1-9]\\d{0,9}(\\d{0,9}[lL])?|0[xX]\\p{XDigit}{1,8}(\\p{XDigit}{0,8}[lL])?|0[0-7]{1,11}([0-7]{0,11}[lL])?|([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?|[0-9]+([eE][+-]?[0-9]+[fFdD]?|([eE][+-]?[0-9]+)?[fFdD]))",
    "escape": "\\",
    "highlight_digits": "true",
    "ignore_case": "false",
    "no_word_sep": "",
}

# Attributes dict for scala_pattern ruleset.
scala_pattern_attributes_dict = {
    "default": "NULL",
    "digit_re": "(0[lL]?|[1-9]\\d{0,9}(\\d{0,9}[lL])?|0[xX]\\p{XDigit}{1,8}(\\p{XDigit}{0,8}[lL])?|0[0-7]{1,11}([0-7]{0,11}[lL])?|([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?|[0-9]+([eE][+-]?[0-9]+[fFdD]?|([eE][+-]?[0-9]+)?[fFdD]))",
    "escape": "\\",
    "highlight_digits": "true",
    "ignore_case": "false",
    "no_word_sep": "",
}

# Attributes dict for scala_scaladoc ruleset.
scala_scaladoc_attributes_dict = {
    "default": "COMMENT3",
    "digit_re": "(0[lL]?|[1-9]\\d{0,9}(\\d{0,9}[lL])?|0[xX]\\p{XDigit}{1,8}(\\p{XDigit}{0,8}[lL])?|0[0-7]{1,11}([0-7]{0,11}[lL])?|([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?|[0-9]+([eE][+-]?[0-9]+[fFdD]?|([eE][+-]?[0-9]+)?[fFdD]))",
    "escape": "\\",
    "highlight_digits": "true",
    "ignore_case": "true",
    "no_word_sep": "",
}

# Attributes dict for scala_scaladoc_pre ruleset.
scala_scaladoc_pre_attributes_dict = {
    "default": "COMMENT3",
    "digit_re": "(0[lL]?|[1-9]\\d{0,9}(\\d{0,9}[lL])?|0[xX]\\p{XDigit}{1,8}(\\p{XDigit}{0,8}[lL])?|0[0-7]{1,11}([0-7]{0,11}[lL])?|([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?|[0-9]+([eE][+-]?[0-9]+[fFdD]?|([eE][+-]?[0-9]+)?[fFdD]))",
    "escape": "\\",
    "highlight_digits": "true",
    "ignore_case": "true",
    "no_word_sep": "",
}

# Attributes dict for scala_xml_tag ruleset.
scala_xml_tag_attributes_dict = {
    "default": "LABEL",
    "digit_re": "(0[lL]?|[1-9]\\d{0,9}(\\d{0,9}[lL])?|0[xX]\\p{XDigit}{1,8}(\\p{XDigit}{0,8}[lL])?|0[0-7]{1,11}([0-7]{0,11}[lL])?|([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?|[0-9]+([eE][+-]?[0-9]+[fFdD]?|([eE][+-]?[0-9]+)?[fFdD]))",
    "escape": "\\",
    "highlight_digits": "true",
    "ignore_case": "true",
    "no_word_sep": "",
}

# Attributes dict for scala_xml_text ruleset.
scala_xml_text_attributes_dict = {
    "default": "COMMENT4",
    "digit_re": "(0[lL]?|[1-9]\\d{0,9}(\\d{0,9}[lL])?|0[xX]\\p{XDigit}{1,8}(\\p{XDigit}{0,8}[lL])?|0[0-7]{1,11}([0-7]{0,11}[lL])?|([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?|[0-9]+([eE][+-]?[0-9]+[fFdD]?|([eE][+-]?[0-9]+)?[fFdD]))",
    "escape": "\\",
    "highlight_digits": "true",
    "ignore_case": "true",
    "no_word_sep": "",
}

# Attributes dict for scala_xml_comment ruleset.
scala_xml_comment_attributes_dict = {
    "default": "COMMENT2",
    "digit_re": "(0[lL]?|[1-9]\\d{0,9}(\\d{0,9}[lL])?|0[xX]\\p{XDigit}{1,8}(\\p{XDigit}{0,8}[lL])?|0[0-7]{1,11}([0-7]{0,11}[lL])?|([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?|[0-9]+([eE][+-]?[0-9]+[fFdD]?|([eE][+-]?[0-9]+)?[fFdD]))",
    "escape": "\\",
    "highlight_digits": "true",
    "ignore_case": "true",
    "no_word_sep": "",
}

# Dictionary of attributes dictionaries for scala mode.
attributesDictDict = {
    "scala_main": scala_main_attributes_dict,
    "scala_pattern": scala_pattern_attributes_dict,
    "scala_primary": scala_primary_attributes_dict,
    "scala_scaladoc": scala_scaladoc_attributes_dict,
    "scala_scaladoc_pre": scala_scaladoc_pre_attributes_dict,
    "scala_xml_comment": scala_xml_comment_attributes_dict,
    "scala_xml_tag": scala_xml_tag_attributes_dict,
    "scala_xml_text": scala_xml_text_attributes_dict,
}

# Keywords dict for scala_main ruleset.
scala_main_keywords_dict = {}

# Keywords dict for scala_primary ruleset.
scala_primary_keywords_dict = {

### EKR
#    "\t  ": "",
#    "\n": "",
#    "    ": "",
#    "      ": "",
    "=": "",
    ">": "",
    "Actor": "",
    "ActorProxy": "",
    "ActorTask": "",
    "ActorThread": "",
    "AllRef": "",
    "Any": "",
    "AnyRef": "",
    "Application": "",
    "AppliedType": "",
    "Array": "",
    "ArrayBuffer": "",
    "Attribute": "",
    "Boolean": "",
    "BoxedArray": "",
    "BoxedBooleanArray": "",
    "BoxedByteArray": "",
    "BoxedCharArray": "",
    "Buffer": "",
    "BufferedIterator": "",
    "Byte": "",
    "Char": "",
    "Character": "",
    "Console": "",
    "Double": "",
    "Enumeration": "",
    "Float": "",
    "Fluid": "",
    "Function": "",
    "IScheduler": "",
    "ImmutableMapAdaptor": "",
    "ImmutableSetAdaptor": "",
    "Int": "",
    "Integer": "",
    "Iterable": "",
    "List": "",
    "Long": "",
    "Nil": "",
    "None": "",
    "Option": "",
    "Pair": "",
    "PartialFunction": "",
    "Pid": "",
    "Predef": "",
    "PriorityQueue": "",
    "PriorityQueueProxy": "",
    "Reaction": "",
    "Ref": "",
    "RemoteActor": "",
    "Responder": "",
    "RichInt": "",
    "RichString": "",
    "Rule": "",
    "RuleTransformer": "",
    "SUnit": "",
    "ScalaRunTime": "",
    "Scheduler": "",
    "Script": "",
    "Short": "",
    "Some": "",
    "Stream": "",
    "String": "",
    "Symbol": "",
    "TIMEOUT": "",
    "TcpService": "",
    "TcpServiceWorker": "",
    "TimerThread": "",
    "Unit": "",
    "WorkerThread": "",
    "abstract": "",
    "boolean": "",
    "byte": "",
    "case": "",
    "catch": "",
    "char": "",
    "class": "",
    "def": "",
    "do": "",
    "double": "",
    "else": "",
    "extends": "",
    "false": "",
    "final": "",
    "finally": "",
    "float": "",
    "for": "",
    "forSome": "",
    "if": "",
    "implicit": "",
    "import": "",
    "int": "",
    "lazy": "",
    "long": "",
    "match": "",
    "new": "",
    "null": "",
    "object": "",
    "override": "",
    "package": "",
    "private": "",
    "protected": "",
    "requires": "",
    "return": "",
    "sealed": "",
    "short": "",
    "super": "",
    "this": "",
    "throw": "",
    "trait": "",
    "true": "",
    "try": "",
    "type": "",
    "unit": "",
    "val": "",
    "var": "",
    "while": "",
    "with": "",
    "yield": "",
}

# Keywords dict for scala_pattern ruleset.
scala_pattern_keywords_dict = {}

# Keywords dict for scala_scaladoc ruleset.
scala_scaladoc_keywords_dict = {
#    "\n": "",
#    "    ": "",
#    "      ": "",
    "@access": "",
    "@author": "",
    "@beaninfo": "",
    "@bon": "",
    "@bug": "",
    "@complexity": "",
    "@deprecated": "",
    "@design": "",
    "@docroot": "",
    "@ensures": "",
    "@equivalent": "",
    "@example": "",
    "@exception": "",
    "@generates": "",
    "@guard": "",
    "@hides": "",
    "@history": "",
    "@idea": "",
    "@invariant": "",
    "@link": "",
    "@modifies": "",
    "@overrides": "",
    "@param": "",
    "@post": "",
    "@pre": "",
    "@references": "",
    "@requires": "",
    "@return": "",
    "@review": "",
    "@see": "",
    "@serial": "",
    "@serialData": "",
    "@serialField": "",
    "@serialdata": "",
    "@serialfield": "",
    "@since": "",
    "@spec": "",
    "@throws": "",
    "@todo": "",
    "@uses": "",
    "@values": "",
    "@version": "",
}

# Keywords dict for scala_scaladoc_pre ruleset.
scala_scaladoc_pre_keywords_dict = {}

# Keywords dict for scala_xml_tag ruleset.
scala_xml_tag_keywords_dict = {}

# Keywords dict for scala_xml_text ruleset.
scala_xml_text_keywords_dict = {}

# Keywords dict for scala_xml_comment ruleset.
scala_xml_comment_keywords_dict = {}

# Dictionary of keywords dictionaries for scala mode.
keywordsDictDict = {
    "scala_main": scala_main_keywords_dict,
    "scala_pattern": scala_pattern_keywords_dict,
    "scala_primary": scala_primary_keywords_dict,
    "scala_scaladoc": scala_scaladoc_keywords_dict,
    "scala_scaladoc_pre": scala_scaladoc_pre_keywords_dict,
    "scala_xml_comment": scala_xml_comment_keywords_dict,
    "scala_xml_tag": scala_xml_tag_keywords_dict,
    "scala_xml_text": scala_xml_text_keywords_dict,
}

# Rules for scala_main ruleset.

def scala_rule0(colorer, s, i):
    return colorer.match_mark_following(s, i, kind="label", pattern="@",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, exclude_match=False)


# Rules dict for scala_main ruleset.
rulesDict1 = {
    "@": [scala_rule0,],
}

# Rules for scala_primary ruleset.

def scala_rule1(colorer, s, i):
    return colorer.match_seq(s, i, kind="comment1", seq="/**/",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule2(colorer, s, i):
    return colorer.match_eol_span(s, i, kind="comment2", seq="//",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="", exclude_match=False)

def scala_rule3(colorer, s, i):
    return colorer.match_span(s, i, kind="comment3", begin="/**", end="*/",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="scala::scaladoc",exclude_match=False,
        no_escape=False, no_line_break=False, no_word_break=False)

def scala_rule4(colorer, s, i):
    return colorer.match_span(s, i, kind="comment1", begin="/*", end="*/",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="",exclude_match=False,
        no_escape=False, no_line_break=False, no_word_break=False)

def scala_rule5(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="comment2", regexp="<!--",
        at_line_start=False, at_whitespace_end=True, at_word_start=False, delegate="scala::xml_comment")

def scala_rule6(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="literal3", regexp="<\\/?\\w*",
        at_line_start=False, at_whitespace_end=True, at_word_start=False, delegate="scala::xml_tag")

def scala_rule7(colorer, s, i):
    return colorer.match_span(s, i, kind="literal1", begin="\"\"\"", end="\"\"\"",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="",exclude_match=False,
        no_escape=False, no_line_break=False, no_word_break=False)

def scala_rule8(colorer, s, i):
    return colorer.match_span(s, i, kind="literal1", begin="\"", end="\"",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="",exclude_match=False,
        no_escape=False, no_line_break=True, no_word_break=False)

def scala_rule9(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="literal1", regexp="'([^']|\\\\.)'",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule10(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="label", regexp="'[0-9a-zA-Z><=+]([0-9a-zA-Z><=+]|_[0-9a-zA-Z><=+])*",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule11(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="literal3", regexp="\\[[^\\[\\]]*(\\[[^\\[\\]]*(\\[[^\\[\\]]*\\][^\\[\\]]*)*\\][^\\[\\]]*)*\\]",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule12(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="literal2", regexp="<:\\s*\\w+(\\.\\w+)*(#\\w+)?",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule13(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="literal2", regexp=">:\\s*\\w+(\\.\\w+)*(#\\w+)?",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule14(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq=")",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule15(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="=",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule16(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="!",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule17(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq=">=",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule18(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq=">:",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule19(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="<=",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule20(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="<:",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule21(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="+",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule22(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="-",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule23(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="/",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule24(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="*",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule25(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq=">",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule26(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="<",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule27(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="%",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule28(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="&",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule29(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="|",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule30(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="^",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule31(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="`",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule32(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="~",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule33(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="}",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule34(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="{",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule35(colorer, s, i):
    return colorer.match_seq(s, i, kind="null", seq=".",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule36(colorer, s, i):
    return colorer.match_seq(s, i, kind="null", seq=",",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule37(colorer, s, i):
    return colorer.match_seq(s, i, kind="null", seq=";",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule38(colorer, s, i):
    return colorer.match_seq(s, i, kind="null", seq="]",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule39(colorer, s, i):
    return colorer.match_seq(s, i, kind="null", seq="[",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule40(colorer, s, i):
    return colorer.match_seq(s, i, kind="null", seq="?",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule41(colorer, s, i):
    return colorer.match_seq(s, i, kind="null", seq=":",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule42(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="literal2", regexp=":\\s*\\w+(\\.\\w+)*(#\\w+)?",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule43(colorer, s, i):
    return colorer.match_mark_previous(s, i, kind="function", pattern="(",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, exclude_match=False)

def scala_rule44(colorer, s, i):
    return colorer.match_span(s, i, kind="", begin="case", end="=>",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="scala::pattern",exclude_match=False,
        no_escape=False, no_line_break=True, no_word_break=False)

def scala_rule45(colorer, s, i):
    return colorer.match_keywords(s, i)

# Rules dict for scala_primary ruleset.
rulesDict2 = {
    "!": [scala_rule16,],
    "\"": [scala_rule7,scala_rule8,],
    "%": [scala_rule27,],
    "&": [scala_rule28,],
    "'": [scala_rule9,scala_rule10,],
    "(": [scala_rule43,],
    ")": [scala_rule14,],
    "*": [scala_rule24,],
    "+": [scala_rule21,],
    ",": [scala_rule36,],
    "-": [scala_rule22,],
    ".": [scala_rule35,],
    "/": [scala_rule1,scala_rule2,scala_rule3,scala_rule4,scala_rule23,],
    "0": [scala_rule45,],
    "1": [scala_rule45,],
    "2": [scala_rule45,],
    "3": [scala_rule45,],
    "4": [scala_rule45,],
    "5": [scala_rule45,],
    "6": [scala_rule45,],
    "7": [scala_rule45,],
    "8": [scala_rule45,],
    "9": [scala_rule45,],
    ":": [scala_rule41,scala_rule42,],
    ";": [scala_rule37,],
    "<": [scala_rule5,scala_rule6,scala_rule12,scala_rule19,scala_rule20,scala_rule26,],
    "=": [scala_rule15,scala_rule45,],
    ">": [scala_rule13,scala_rule17,scala_rule18,scala_rule25,scala_rule45,],
    "?": [scala_rule40,],
    "@": [scala_rule45,],
    "A": [scala_rule45,],
    "B": [scala_rule45,],
    "C": [scala_rule45,],
    "D": [scala_rule45,],
    "E": [scala_rule45,],
    "F": [scala_rule45,],
    "G": [scala_rule45,],
    "H": [scala_rule45,],
    "I": [scala_rule45,],
    "J": [scala_rule45,],
    "K": [scala_rule45,],
    "L": [scala_rule45,],
    "M": [scala_rule45,],
    "N": [scala_rule45,],
    "O": [scala_rule45,],
    "P": [scala_rule45,],
    "Q": [scala_rule45,],
    "R": [scala_rule45,],
    "S": [scala_rule45,],
    "T": [scala_rule45,],
    "U": [scala_rule45,],
    "V": [scala_rule45,],
    "W": [scala_rule45,],
    "X": [scala_rule45,],
    "Y": [scala_rule45,],
    "Z": [scala_rule45,],
    "[": [scala_rule11,scala_rule39,],
    "]": [scala_rule38,],
    "^": [scala_rule30,],
    "`": [scala_rule31,],
    "a": [scala_rule45,],
    "b": [scala_rule45,],
    "c": [scala_rule44,scala_rule45,],
    "d": [scala_rule45,],
    "e": [scala_rule45,],
    "f": [scala_rule45,],
    "g": [scala_rule45,],
    "h": [scala_rule45,],
    "i": [scala_rule45,],
    "j": [scala_rule45,],
    "k": [scala_rule45,],
    "l": [scala_rule45,],
    "m": [scala_rule45,],
    "n": [scala_rule45,],
    "o": [scala_rule45,],
    "p": [scala_rule45,],
    "q": [scala_rule45,],
    "r": [scala_rule45,],
    "s": [scala_rule45,],
    "t": [scala_rule45,],
    "u": [scala_rule45,],
    "v": [scala_rule45,],
    "w": [scala_rule45,],
    "x": [scala_rule45,],
    "y": [scala_rule45,],
    "z": [scala_rule45,],
    "{": [scala_rule34,],
    "|": [scala_rule29,],
    "}": [scala_rule33,],
    "~": [scala_rule32,],
}

# Rules for scala_pattern ruleset.


def scala_rule46(colorer, s, i):
    return colorer.match_seq(s, i, kind="operator", seq="@",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

# Rules dict for scala_pattern ruleset.
rulesDict3 = {
    "@": [scala_rule46,],
}

# Rules for scala_scaladoc ruleset.

def scala_rule47(colorer, s, i):
    return colorer.match_seq(s, i, kind="comment3", seq="{",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule48(colorer, s, i):
    return colorer.match_seq(s, i, kind="comment3", seq="*",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule49(colorer, s, i):
    return colorer.match_span(s, i, kind="markup", begin="<pre>", end="</pre>",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="scala::scaladoc_pre",exclude_match=False,
        no_escape=False, no_line_break=False, no_word_break=False)

def scala_rule50(colorer, s, i):
    return colorer.match_span(s, i, kind="comment1", begin="<!--", end="-->",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="",exclude_match=False,
        no_escape=False, no_line_break=False, no_word_break=False)

def scala_rule51(colorer, s, i):
    return colorer.match_seq(s, i, kind="comment3", seq="<<",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule52(colorer, s, i):
    return colorer.match_seq(s, i, kind="comment3", seq="<=",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule53(colorer, s, i):
    return colorer.match_seq(s, i, kind="comment3", seq="< ",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="")

def scala_rule54(colorer, s, i):
    return colorer.match_span(s, i, kind="markup", begin="<", end=">",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="xml::tags",exclude_match=False,
        no_escape=False, no_line_break=False, no_word_break=False)

def scala_rule55(colorer, s, i):
    return colorer.match_keywords(s, i)

# Rules dict for scala_scaladoc ruleset.
rulesDict4 = {
    "*": [scala_rule48,],
    "0": [scala_rule55,],
    "1": [scala_rule55,],
    "2": [scala_rule55,],
    "3": [scala_rule55,],
    "4": [scala_rule55,],
    "5": [scala_rule55,],
    "6": [scala_rule55,],
    "7": [scala_rule55,],
    "8": [scala_rule55,],
    "9": [scala_rule55,],
    "<": [scala_rule49,scala_rule50,scala_rule51,scala_rule52,scala_rule53,scala_rule54,],
    "=": [scala_rule55,],
    ">": [scala_rule55,],
    "@": [scala_rule55,],
    "A": [scala_rule55,],
    "B": [scala_rule55,],
    "C": [scala_rule55,],
    "D": [scala_rule55,],
    "E": [scala_rule55,],
    "F": [scala_rule55,],
    "G": [scala_rule55,],
    "H": [scala_rule55,],
    "I": [scala_rule55,],
    "J": [scala_rule55,],
    "K": [scala_rule55,],
    "L": [scala_rule55,],
    "M": [scala_rule55,],
    "N": [scala_rule55,],
    "O": [scala_rule55,],
    "P": [scala_rule55,],
    "Q": [scala_rule55,],
    "R": [scala_rule55,],
    "S": [scala_rule55,],
    "T": [scala_rule55,],
    "U": [scala_rule55,],
    "V": [scala_rule55,],
    "W": [scala_rule55,],
    "X": [scala_rule55,],
    "Y": [scala_rule55,],
    "Z": [scala_rule55,],
    "a": [scala_rule55,],
    "b": [scala_rule55,],
    "c": [scala_rule55,],
    "d": [scala_rule55,],
    "e": [scala_rule55,],
    "f": [scala_rule55,],
    "g": [scala_rule55,],
    "h": [scala_rule55,],
    "i": [scala_rule55,],
    "j": [scala_rule55,],
    "k": [scala_rule55,],
    "l": [scala_rule55,],
    "m": [scala_rule55,],
    "n": [scala_rule55,],
    "o": [scala_rule55,],
    "p": [scala_rule55,],
    "q": [scala_rule55,],
    "r": [scala_rule55,],
    "s": [scala_rule55,],
    "t": [scala_rule55,],
    "u": [scala_rule55,],
    "v": [scala_rule55,],
    "w": [scala_rule55,],
    "x": [scala_rule55,],
    "y": [scala_rule55,],
    "z": [scala_rule55,],
    "{": [scala_rule47,],
}

# Rules for scala_scaladoc_pre ruleset.

# Rules dict for scala_scaladoc_pre ruleset.
rulesDict5 = {}

# Rules for scala_xml_tag ruleset.

def scala_rule56(colorer, s, i):
    return colorer.match_span(s, i, kind="literal1", begin="\"", end="\"",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="",exclude_match=False,
        no_escape=False, no_line_break=True, no_word_break=False)

def scala_rule57(colorer, s, i):
    return colorer.match_span(s, i, kind="literal1", begin="'", end="'",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="",exclude_match=False,
        no_escape=False, no_line_break=True, no_word_break=False)

def scala_rule58(colorer, s, i):
    return colorer.match_span(s, i, kind="", begin="{", end="}",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="scala::main",exclude_match=False,
        no_escape=False, no_line_break=False, no_word_break=False)

def scala_rule59(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="literal3", regexp=">$",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="scala::main")

def scala_rule60(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="literal3", regexp=">\\s*;",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="scala::main")

def scala_rule61(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="literal3", regexp=">\\s*\\)",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="scala::main")

def scala_rule62(colorer, s, i):
    return colorer.match_seq(s, i, kind="literal3", seq=">",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="scala::xml_text")

# Rules dict for scala_xml_tag ruleset.
rulesDict6 = {
    "\"": [scala_rule56,],
    "'": [scala_rule57,],
    ">": [scala_rule59,scala_rule60,scala_rule61,scala_rule62,],
    "{": [scala_rule58,],
}

# Rules for scala_xml_text ruleset.

def scala_rule63(colorer, s, i):
    return colorer.match_span(s, i, kind="", begin="{", end="}",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="scala::main",exclude_match=False,
        no_escape=False, no_line_break=False, no_word_break=False)

def scala_rule64(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="comment2", regexp="<!--",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="scala::xml_comment")

def scala_rule65(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="literal3", regexp="<\\/?\\w*",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="scala::xml_tag")

# Rules dict for scala_xml_text ruleset.
rulesDict7 = {
    "<": [scala_rule64,scala_rule65,],
    "{": [scala_rule63,],
}

# Rules for scala_xml_comment ruleset.

def scala_rule66(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="comment2", regexp="-->$",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="scala::main")

def scala_rule67(colorer, s, i):
    return colorer.match_seq_regexp(s, i, kind="comment2", regexp="-->\\s*;",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="scala::main")

def scala_rule68(colorer, s, i):
    return colorer.match_seq(s, i, kind="comment2", seq="-->",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, delegate="scala::xml_text")

# Rules dict for scala_xml_comment ruleset.
rulesDict8 = {
    "-": [scala_rule66,scala_rule67,scala_rule68,],
}

# x.rulesDictDict for scala mode.
rulesDictDict = {
    "scala_main": rulesDict1,
    "scala_pattern": rulesDict3,
    "scala_primary": rulesDict2,
    "scala_scaladoc": rulesDict4,
    "scala_scaladoc_pre": rulesDict5,
    "scala_xml_comment": rulesDict8,
    "scala_xml_tag": rulesDict6,
    "scala_xml_text": rulesDict7,
}

# Import dict for scala mode.
importDict = {
    "scala_main": ["scala_main::primary",],
    "scala_pattern": ["scala_pattern::primary",],
}

