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

# Properties for scheme mode.
properties = {
    "commentEnd": "|#",
    "commentStart": "#|",
    "indentCloseBrackets": ")",
    "indentOpenBrackets": "(",
    "lineComment": ";",
    "lineUpClosingBracket": "false",
    "noWordSep": "_-+?:*/!",
}

# Attributes dict for scheme_main ruleset.
scheme_main_attributes_dict = {
    "default": "null",
    "digit_re": "",
    "escape": "",
    "highlight_digits": "true",
    "ignore_case": "false",
    "no_word_sep": "_-+?:*/!",
}

# Dictionary of attributes dictionaries for scheme mode.
attributesDictDict = {
    "scheme_main": scheme_main_attributes_dict,
}

# Keywords dict for scheme_main ruleset.
scheme_main_keywords_dict = {
    "#f": "literal2",
    "#t": "literal2",
    "<": "keyword3",
    "=?": "keyword3",
    ">": "keyword3",
    "?": "keyword3",
    "abs": "keyword2",
    "acos": "keyword2",
    "and": "keyword1",
    "angle": "keyword2",
    "append": "keyword2",
    "apply": "keyword2",
    "asin": "keyword2",
    "assoc": "keyword2",
    "assq": "keyword2",
    "assv": "keyword2",
    "atan": "keyword2",
    "begin": "keyword1",
    "boolean?": "keyword3",
    "caaar": "keyword2",
    "caadr": "keyword2",
    "caar": "keyword2",
    "cadar": "keyword2",
    "caddr": "keyword2",
    "cadr": "keyword2",
    "call-with-current-continuation": "keyword2",
    "call-with-input-file": "keyword2",
    "call-with-output-file": "keyword2",
    "call-with-values": "keyword2",
    "call/cc": "keyword2",
    "car": "keyword2",
    "case": "keyword1",
    "catch": "keyword2",
    "cdaar": "keyword2",
    "cdadr": "keyword2",
    "cdar": "keyword2",
    "cddar": "keyword2",
    "cdddr": "keyword2",
    "cddr": "keyword2",
    "cdr": "keyword2",
    "ceiling": "keyword2",
    "char": "keyword3",
    "char-": "keyword2",
    "char-alphabetic?": "keyword3",
    "char-ci": "keyword3",
    "char-ci=?": "keyword3",
    "char-downcase": "keyword2",
    "char-lower-case?": "keyword3",
    "char-numeric?": "keyword3",
    "char-ready?": "keyword3",
    "char-upcase": "keyword2",
    "char-upper-case?": "keyword3",
    "char-whitespace?": "keyword3",
    "char=?": "keyword3",
    "char?": "keyword3",
    "close-input-port": "keyword2",
    "close-output-port": "keyword2",
    "complex?": "keyword3",
    "cond": "keyword1",
    "cond-expand": "keyword1",
    "cons": "keyword2",
    "cos": "keyword2",
    "current-input-port": "keyword2",
    "current-output-port": "keyword2",
    "define": "keyword1",
    "define-macro": "keyword1",
    "delay": "keyword1",
    "delete-file": "keyword2",
    "display": "keyword2",
    "do": "keyword1",
    "dynamic-wind": "keyword2",
    "else": "keyword1",
    "eof-object?": "keyword3",
    "eq?": "keyword3",
    "equal?": "keyword3",
    "eqv?": "keyword3",
    "eval": "keyword2",
    "even?": "keyword3",
    "exact-": "keyword2",
    "exact?": "keyword3",
    "exit": "keyword2",
    "exp": "keyword2",
    "expt": "keyword2",
    "file-exists?": "keyword3",
    "file-or-directory-modify-seconds": "keyword2",
    "floor": "keyword2",
    "fluid-let": "keyword1",
    "for-each": "keyword2",
    "force": "keyword2",
    "gcd": "keyword2",
    "gensym": "keyword2",
    "get-output-string": "keyword2",
    "getenv": "keyword2",
    "if": "keyword1",
    "imag-part": "keyword2",
    "inexact": "keyword2",
    "inexact?": "keyword3",
    "input-port?": "keyword3",
    "integer": "keyword2",
    "integer-": "keyword2",
    "integer?": "keyword3",
    "lambda": "keyword1",
    "lcm": "keyword2",
    "length": "keyword2",
    "let": "keyword1",
    "let*": "keyword1",
    "letrec": "keyword1",
    "list": "keyword2",
    "list-": "keyword2",
    "list-ref": "keyword2",
    "list-tail": "keyword2",
    "list?": "keyword3",
    "load": "keyword2",
    "log": "keyword2",
    "magnitude": "keyword2",
    "make-polar": "keyword2",
    "make-rectangular": "keyword2",
    "make-string": "keyword2",
    "make-vector": "keyword2",
    "map": "keyword2",
    "max": "keyword2",
    "member": "keyword2",
    "memq": "keyword2",
    "memv": "keyword2",
    "min": "keyword2",
    "modulo": "keyword2",
    "negative?": "keyword3",
    "newline": "keyword2",
    "nil": "keyword2",
    "not": "keyword2",
    "null?": "keyword3",
    "number": "keyword2",
    "number-": "keyword2",
    "number?": "keyword3",
    "odd?": "keyword3",
    "open-input-file": "keyword2",
    "open-input-string": "keyword2",
    "open-output-file": "keyword2",
    "open-output-string": "keyword2",
    "or": "keyword1",
    "output-port?": "keyword3",
    "pair?": "keyword3",
    "peek-char": "keyword2",
    "port?": "keyword3",
    "positive?": "keyword3",
    "procedure?": "keyword3",
    "quasiquote": "keyword1",
    "quote": "keyword1",
    "quotient": "keyword2",
    "rational?": "keyword3",
    "read": "keyword2",
    "read-char": "keyword2",
    "read-line": "keyword2",
    "real-part": "keyword2",
    "real?": "keyword3",
    "remainder": "keyword2",
    "reverse": "keyword2",
    "reverse!": "keyword2",
    "round": "keyword2",
    "set!": "keyword1",
    "set-car!": "keyword2",
    "set-cdr!": "keyword2",
    "sin": "keyword2",
    "sqrt": "keyword2",
    "string": "keyword3",
    "string-": "keyword2",
    "string-append": "keyword2",
    "string-ci": "keyword3",
    "string-ci=?": "keyword3",
    "string-copy": "keyword2",
    "string-fill!": "keyword2",
    "string-length": "keyword2",
    "string-ref": "keyword2",
    "string-set!": "keyword2",
    "string=?": "keyword3",
    "string?": "keyword3",
    "substring": "keyword2",
    "symbol": "keyword2",
    "symbol-": "keyword2",
    "symbol?": "keyword3",
    "system": "keyword2",
    "tan": "keyword2",
    "truncate": "keyword2",
    "values": "keyword2",
    "vector": "keyword2",
    "vector-": "keyword2",
    "vector-fill!": "keyword2",
    "vector-length": "keyword2",
    "vector-ref": "keyword2",
    "vector-set!": "keyword2",
    "vector?": "keyword3",
    "with-input-from-file": "keyword2",
    "with-output-to-file": "keyword2",
    "write": "keyword2",
    "write-char": "keyword2",
    "zero?": "keyword3",
}

# Dictionary of keywords dictionaries for scheme mode.
keywordsDictDict = {
    "scheme_main": scheme_main_keywords_dict,
}

# Rules for scheme_main ruleset.

def scheme_rule0(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 scheme_rule1(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 scheme_rule2(colorer, s, i):
    return colorer.match_mark_following(s, i, kind="literal1", pattern="'",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, exclude_match=False)

def scheme_rule3(colorer, s, i):
    return colorer.match_mark_following(s, i, kind="literal1", pattern="#\\",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, exclude_match=False)

def scheme_rule4(colorer, s, i):
    return colorer.match_mark_following(s, i, kind="literal1", pattern="#b",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, exclude_match=False)

def scheme_rule5(colorer, s, i):
    return colorer.match_mark_following(s, i, kind="literal1", pattern="#d",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, exclude_match=False)

def scheme_rule6(colorer, s, i):
    return colorer.match_mark_following(s, i, kind="literal1", pattern="#o",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, exclude_match=False)

def scheme_rule7(colorer, s, i):
    return colorer.match_mark_following(s, i, kind="literal1", pattern="#x",
        at_line_start=False, at_whitespace_end=False, at_word_start=False, exclude_match=False)

def scheme_rule8(colorer, s, i):
    return colorer.match_eol_span(s, i, kind="comment1", seq=";",
        at_line_start=False, at_whitespace_end=False, at_word_start=False,
        delegate="", exclude_match=False)

def scheme_rule9(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 scheme_rule10(colorer, s, i):
    return colorer.match_keywords(s, i)

# Rules dict for scheme_main ruleset.
rulesDict1 = {
    "!": [scheme_rule10,],
    "\"": [scheme_rule9,],
    "#": [scheme_rule0,scheme_rule3,scheme_rule4,scheme_rule5,scheme_rule6,scheme_rule7,scheme_rule10,],
    "'": [scheme_rule1,scheme_rule2,],
    "*": [scheme_rule10,],
    "-": [scheme_rule10,],
    "/": [scheme_rule10,],
    "0": [scheme_rule10,],
    "1": [scheme_rule10,],
    "2": [scheme_rule10,],
    "3": [scheme_rule10,],
    "4": [scheme_rule10,],
    "5": [scheme_rule10,],
    "6": [scheme_rule10,],
    "7": [scheme_rule10,],
    "8": [scheme_rule10,],
    "9": [scheme_rule10,],
    ";": [scheme_rule8,],
    "<": [scheme_rule10,],
    "=": [scheme_rule10,],
    ">": [scheme_rule10,],
    "?": [scheme_rule10,],
    "@": [scheme_rule10,],
    "A": [scheme_rule10,],
    "B": [scheme_rule10,],
    "C": [scheme_rule10,],
    "D": [scheme_rule10,],
    "E": [scheme_rule10,],
    "F": [scheme_rule10,],
    "G": [scheme_rule10,],
    "H": [scheme_rule10,],
    "I": [scheme_rule10,],
    "J": [scheme_rule10,],
    "K": [scheme_rule10,],
    "L": [scheme_rule10,],
    "M": [scheme_rule10,],
    "N": [scheme_rule10,],
    "O": [scheme_rule10,],
    "P": [scheme_rule10,],
    "Q": [scheme_rule10,],
    "R": [scheme_rule10,],
    "S": [scheme_rule10,],
    "T": [scheme_rule10,],
    "U": [scheme_rule10,],
    "V": [scheme_rule10,],
    "W": [scheme_rule10,],
    "X": [scheme_rule10,],
    "Y": [scheme_rule10,],
    "Z": [scheme_rule10,],
    "a": [scheme_rule10,],
    "b": [scheme_rule10,],
    "c": [scheme_rule10,],
    "d": [scheme_rule10,],
    "e": [scheme_rule10,],
    "f": [scheme_rule10,],
    "g": [scheme_rule10,],
    "h": [scheme_rule10,],
    "i": [scheme_rule10,],
    "j": [scheme_rule10,],
    "k": [scheme_rule10,],
    "l": [scheme_rule10,],
    "m": [scheme_rule10,],
    "n": [scheme_rule10,],
    "o": [scheme_rule10,],
    "p": [scheme_rule10,],
    "q": [scheme_rule10,],
    "r": [scheme_rule10,],
    "s": [scheme_rule10,],
    "t": [scheme_rule10,],
    "u": [scheme_rule10,],
    "v": [scheme_rule10,],
    "w": [scheme_rule10,],
    "x": [scheme_rule10,],
    "y": [scheme_rule10,],
    "z": [scheme_rule10,],
}

# x.rulesDictDict for scheme mode.
rulesDictDict = {
    "scheme_main": rulesDict1,
}

# Import dict for scheme mode.
importDict = {}

