Rebol.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: "Rebol"
file_extensions:
  - r2
  - r3
  - reb
  - r
  - nest

variables:
  comment_line_start: ;
  delimiters: \[\]{}"\(\)/\\@#\$%\^,;
  non_ident_chars: '{{delimiters}}\s'
  non_ident_start_chars: \d'{{non_ident_chars}}
  ident: '[^{{non_ident_start_chars}}][^{{non_ident_chars}}]*'
  inf_or_nan: '(([+-])?1\.#(?i)(inf|nan))'
  float_or_int: '([+-])?\d+(?:(\.)\d+)?(?:([Ee][+-]?)\d+)?'
  non_url_chars: '\s\[\]\(\){}";'
  non_email_chars: '{{non_url_chars}}:'
  months: (?i)(Jan(u(a(ry?)?)?)?|Feb(u(a(ry?)?)?)?|Mar(ch?)?|Apr(il?)?|May|June?|July?|Aug(u(st?)?)?|Sep(t(e(m(b(er?)?)?)?)?)?|Oct(o(b(er?)?)?)?|Nov(e(m(b(er?)?)?)?)?|Dec(e(m(b(er?)?)?)?)?)
  lex_delimit: \x00\x0A\x0D\x20\x22\(\)/;\[\]{}
  any_word_chars: '[^{{lex_delimit}}]*'
  lit_word_start_chars: ^[\d\'\:@]   #awoid: '2nd ''word ':word '@ref
  lit_word_chars: '[{{lit_word_start_chars}}]{{any_word_chars}}'
  arrow_word_chars: '[-<>]+'
  refinement_chars: '{{any_word_chars}}'
  word_boundary: (?![^{{non_ident_chars}}])
  words_control_conditional: (if|either|unless|case|switch)
  words_control_loop: (foreach|forall|forskip|for|until|while)
  words_control_flow: (break|return|exit|quit|halt|continue)
  words_other_output: (prin(tf?)?|probe|\?\?|\?)
  words_decl_function: (function|funct|func|does|module|closure|native|action|has)
  words_decl_object: (object|context|construct|map)

first_line_match: '^\s*(?i)(Rebol|Red)\s\['
scope: source.rebol
contexts:
  prototype:
    - include: match-comment-lines

  main:
    - include: match-literals
    - include: match-constants
    - include: match-comment
    - include: match-idents
    - include: match-punctuation

  match-literals:
    - include: match-time
    - include: match-date
    - include: match-money
    - include: match-tuple
    - include: match-pair
    - include: match-arrow-word
    - include: match-tag
    - include: match-lit-word
    - include: match-refinement
    - include: match-char
    - include: match-hashtag       # in Rebol #foo@some is email!, in Red issue! and ref! (so far)
    - include: match-any-string
    - include: match-number

  match-any-string:
    - include: match-file
    - include: match-binary
    - include: match-string
    - include: match-url
    - include: match-email        # must be after lit-word! and refinement!
    #- include: match-ref        # ref! looks like @name, currently substituted with email!

  match-number:
    - include: match-hex-integers
    - match: '{{inf_or_nan}}'
      scope: constant.numeric.rebol
      captures:
        2: punctuation.definition.numeric.sign.rebol
    - match: '([+-])?\d+\.(#)'
      scope: invalid.rebol
      captures:
        1: punctuation.definition.numeric.sign.rebol
        2: invalid.illegal.rebol
    - match: ([+-]?)\d+(')*(?:(\.)\d+)?(?:(([Ee])(([+-])?\d+)))?
      scope: constant.numeric.rebol
      captures:
        1: punctuation.definition.numeric.sign.rebol
        2: punctuation.separator.quote.rebol
        3: punctuation.separator.decimal.rebol
        4: constant.numeric.exponent.rebol
        5: punctuation.separator.exponent.rebol
        7: punctuation.definition.numeric.sign.rebol

  match-hex-integers:
    #Note: hex integers are so far Red only (and probably will be replaced)
    #Note: \h would allow also 0h, but that is not valid in Red
    - match: \b([0-9A-F]{2}{0,4})(h)\b
      scope: constant.numeric.hex.rebol
      captures:
        2: storage.type.numeric.hex.rebol

  match-time:
    #Note: Red and Rebol3 does not support am/pm part as Rebol2 did!
    - match: ([+-])?(?:\d+(:))?\d+(:)\d+(?:([.,])\d+)?(?:(?i)(am|pm))?
      scope: constant.numeric.time.rebol
      captures:
        1: punctuation.definition.numeric.sign.rebol
        2: punctuation.separator.time.rebol
        3: punctuation.separator.time.rebol
        4: punctuation.separator.time.rebol
        5: storage.type.ampm.rebol

  match-date:
    - match: |-
        (?x:
          (?:
            (?:\d+(-)({{months}})(-)\w+)|
            (?:\d+(/)({{months}})(/)\w+)
          )
          (?:
            (/)(?:\d+(:))?\d+(:)\d+(?:([.,])\d+)?(?:(?i)(am|pm))? # Time
            (?:([+-])\d+(:)\d+)?                                  # Timezone
          )?
        )
      scope: constant.numeric.date.rebol
      captures:
        #1:  punctuation.separator.time.rebol
        2:  constant.numeric.date.month.rebol
        #3:  punctuation.separator.time.rebol
        4:  punctuation.separator.time.rebol
        5:  constant.numeric.date.month.rebol
        6:  punctuation.separator.time.rebol
        7:  punctuation.separator.time.rebol
        8:  punctuation.separator.time.rebol
        9:  storage.type.ampm.rebol
        10: punctuation.separator.time.rebol
        11: punctuation.separator.time.rebol

  match-money:
    - match: ([a-zA-Z]{0,3})?(\$)(?:\d+|{{float_or_int}})
      scope: constant.numeric.money.rebol
      captures:
        1: storage.type.money.currency.name.rebol
        2: storage.type.money.currency.symbol.rebol

  # TODO: `punctuation.separator` for punctuation. Requires push/pop.
  match-tuple:
    - match: \d+\.\d+(?:\.|(?:\.\d+)+)
      scope: constant.numeric.tuple.rebol

  match-tag:
    - match: '<(?:\/|%\=?\ )?(?:([-_a-zA-Z0-9]+):)?([-_a-zA-Z0-9:]+)'
      captures:
        0: entity.other.namespace.xml
        1: entity.name.tag.xml
      push:
        - meta_scope: entity.tag.rebol
        - match: (?:\s/|\ %)?>
          pop: true
        - match: ' (?:([-_a-zA-Z0-9]+):)?([_a-zA-Z-]+)'
          captures:
            0: entity.other.namespace.xml
            1: entity.other.attribute-name.xml
        - match: "'"
          push:
            - meta_scope: string.quoted.single.xml
            - match: "'"
              pop: true
        - match: '"'
          push:
            - meta_scope: string.quoted.double.xml
            - match: '"'
              pop: true
    - match: '<[^>]+>'
      scope: entity.tag.rebol

  # Note: the email literal in Red is EXTREMELY permissive.
  # Note: this is actually ref! datatype: @name
  # TODO: `punctuation.separator` for punctuation. Requires push/pop.
  match-email:
    - match: '[^{{non_email_chars}}]*(@)[^{{non_email_chars}}]*'
      scope: string.email.rebol
      captures:
        1: storage.type.email.rebol

  # Note: the URL literal in Red is EXTREMELY permissive.
  # Note: these are also url! types: scheme:something & mailto:email@foo.com
  # TODO: `punctuation.separator` for punctuation. Requires push/pop.
  # TODO: support for percent encoding: %aa%20bb is same like %"aa bb"
  match-url:
    #- match: ([[:alpha:]][^{{non_url_chars}}:/]*)(:) ((/{0,2})(([^{{non_url_chars}}@]+)(@))?[^{{non_url_chars}}]* | [^{{non_url_chars}}]+)
    #- match: ([[:alpha:]][^{{non_url_chars}}:/]*)(:)((/{0,2})[^{{non_url_chars}}]* | [^{{non_url_chars}}]+)
    - match: ([[:alpha:]][^{{non_url_chars}}:/]*)(:)(((/{1,2})(([^{{non_url_chars}}@]+)(@))?[^{{non_url_chars}}]*)|(([^{{non_url_chars}}@]+)(@))?[^{{non_url_chars}}]+)
      scope: string.url.rebol
      captures:
        1: string.url.scheme.rebol
        2: storage.type.url.rebol
        5: storage.type.url.rebol
        7: string.url.user.rebol
        8: storage.type.url.rebol
        10: string.url.user.rebol
        11: storage.type.url.rebol

  # TODO: support for percent encoding: %aa%20bb is same like %"aa bb"
  match-file:
    - match: (\%)(")
      scope: string.filename.rebol
      captures:
        1: storage.type.filename.rebol
        2: punctuation.definition.string.begin.rebol
      push:
        - meta_scope: string.filename.rebol
        - include: pop-string-double
    - match: (\%)[^\s\[\](){};@%]*
      scope: string.filename.rebol
      captures:
        1: storage.type.filename.rebol

  match-char:
    - match: '(#)(")'
      captures:
        1: storage.modifier.rebol
        2: punctuation.definition.character.begin.rebol
      push:
        - meta_include_prototype: false
        - meta_scope: constant.character.literal.rebol
        - include: pop-char

  pop-char:
    - meta_include_prototype: false
    - match: '"'
      scope: punctuation.definition.character.end.rebol
      pop: true
    - match: \^\((\h{0,4}|null|line|tab|page|esc|back|del)\)([^"]*)(")
      scope: constant.character.escape.rebol
      captures:
        2: invalid.illegal.rebol
        3: punctuation.definition.character.end.rebol
      pop: true
    - match: \^.([^"]*)(")
      scope: constant.character.escape.rebol
      captures:
        1: invalid.illegal.rebol
        2: punctuation.definition.character.end.rebol
      pop: true
    - match: .([^"]+)(")
      scope: constant.character.escape.rebol
      captures:
        1: invalid.illegal.rebol
        2: punctuation.definition.character.end.rebol
      pop: true

  match-html-characters:
    - match: "(&)([a-zA-Z0-9]+|#[0-9]+|#x[0-9a-fA-F]+)(;)"
      scope: constant.character.entity.html
      captures:
        0: punctuation.definition.entity.html
        2: punctuation.definition.entity.html

  match-hashtag:
    - match: (?:(#)({))
      captures:
        0: string.binary.prefix
        1: storage.modifier.rebol
      push: pop-binary-base16
    - match: (?:(#)\[)
      captures:
        0: punctuation.section.mapping.begin.rebol
        1: storage.modifier.rebol
      push: pop-mapping
    - match: (?:(#)\((?![\)]))
      captures:
        0: punctuation.section.construct.begin.rebol
        1: storage.modifier.rebol
      push: pop-construct
    - match: (\#)(?![^{{non_ident_chars}}@])
      scope: invalid.rebol
      captures:
        1: invalid.illegal.rebol
    - match: (\#)[\w#-]+
      scope: word.issue.rebol
      captures:
        1: storage.type.issue.rebol

  pop-construct:
    - meta_scope: meta.construct.rebol
    - match: '\)'
      scope: punctuation.section.construct.end.rebol
      pop: true
    - include: main

  pop-mapping:
    - meta_scope: meta.mapping.rebol
    - match: ']'
      scope: punctuation.section.mapping.end.rebol
      pop: true
    - include: main

  match-string:
    - include: match-string-double
    - include: match-string-braces

  match-string-double:
    - match: '"'
      scope: punctuation.definition.string.begin.rebol
      push: pop-string-double

  match-string-escaped-char:
    - match: '\^\((\h{0,4}|null|line|tab|page|esc|back|del)\)'
      scope: constant.character.escape.rebol
    - include: match-ansi-sequence
    - match: \^(?![\(])[[:ascii:]]
      scope: constant.character.escape.rebol
    - match: \^(.)
      captures:
        0: invalid.rebol
        1: invalid.illegal.rebol

  # TODO: improve this (only colors are handled now!)
  match-ansi-sequence:
    - match: '(\^\[\[)((\d)+(;(\d)+)*)?(m)'
      scope: meta.sequence.ansi
      captures:
        0: constant.character.escape.rebol

  pop-string-double:
    - meta_include_prototype: false
    - meta_scope: string.quoted.double.rebol
    - match: '"'
      scope: punctuation.definition.string.end.rebol
      pop: true
    - include: match-string-escaped-char

  match-string-braces:
    - match: '{'
      scope: punctuation.definition.string.begin.rebol
      push: pop-string-braces

  pop-string-braces:
    - meta_include_prototype: false
    - meta_scope: string.quoted.double.rebol
    - match: '}'
      scope: punctuation.definition.string.end.rebol
      pop: true
    #- include: rsp-tag
    - include: match-string-escaped-char
    - include: match-html-characters
    - include: match-string-braces

  match-pair:
    - match: '({{inf_or_nan}}|{{float_or_int}}|\d+)(x)({{inf_or_nan}}|{{float_or_int}}|\d+)'
      scope: constant.numeric.pair.rebol
      captures:
         5: punctuation.definition.numeric.sign.rebol
         4: constant.numeric.pair.special.rebol
         8: storage.type.numeric.pair.rebol
         13: punctuation.definition.numeric.sign.rebol

  match-binary:
    - include: match-binary-base2
    - include: match-binary-base16
    - include: match-binary-base64

  match-binary-base16:
    - match: '(16)?#\{'
      captures:
        0: string.binary.prefix
      push: pop-binary-base16

  match-binary-base64:
    - match: '64#\{'
      captures:
        0: string.binary.prefix
      push:
        - meta_scope: binary.base64.rebol
        - match: ';.*$'
          scope: comment.line.rebol
        - match: '\}'
          captures:
            0: string.binary.prefix
          pop: true
        - match: '[0-9a-zA-Z+/=\s]*'
          scope: string.binary.base64.rebol
        - match: .
          scope: invalid.illegal.rebol

  match-binary-base2:
    - match: '2#\{'
      captures:
        0: string.binary.prefix
      push:
        - meta_scope: binary.base2.rebol
        - match: '\}'
          captures:
            0: string.binary.prefix
          pop: true
        - match: ';.*$'
          scope: comment.line.rebol
        - match: '[01\s]s*'
          scope: string.binary.base2.rebol
        - match: .
          scope: invalid.illegal.rebol

  pop-binary-base16:
    - meta_scope: binary.base16.rebol
    - match: '\}'
      captures:
        0: string.binary.prefix
      pop: true
    - match: ';.*$'
      scope: comment.line.rebol
    - match: '[0-9a-fA-F\s]*'
      scope: string.binary.base16.rebol
    - match: .
      scope: invalid.illegal.rebol

  match-comment-lines:
    - include: match-comment-docline
    - include: match-comment-todo
    - include: match-comment-line
    - include: match-comment-shebang

  match-comment-docline:
    - match: '({{comment_line_start}}[-]+).*$'
      scope: comment.docline.rebol
      captures:
        1: punctuation.definition.comment.begin.rebol

  match-comment-todo:
    - match: '({{comment_line_start}}@@).*$'
      scope: comment.todo.rebol
      captures:
        1: punctuation.definition.comment.todo.rebol

  match-comment-line:
    - match: '({{comment_line_start}}).*$'
      scope: comment.line.rebol
      captures:
        1: punctuation.definition.comment.begin.rebol

  match-comment-shebang:
    - match: ^(#!).*$\n?
      scope: comment.line.shebang.rebol
      captures:
        1: punctuation.definition.comment.rebol

  match-comment:
    - match: '(comment){{word_boundary}}(?![\)\]\}])(\s+(quote))?\s*'
      scope: comment.block.rebol
      push:
        - pop-comment-value
        #- pop-before-nonblank

  pop-comment-value:
    - match: (#)?\[
      scope: comment.value.block.rebol
      set: pop-comment-value-block-tail
    - match: (#|2#|16#|64#)?\{
      scope: comment.value.string.rebol
      set: pop-comment-value-string-multiline-tail
    - match: \"
      scope: comment.value.string.rebol
      set: pop-comment-value-string-line-tail
    - match: (#)?\(
      scope: comment.value.paren.rebol
      set: pop-comment-value-paren-tail
    - match: ''
      pop: true

  pop-comment-value-block-tail:
    - meta_scope: comment.value.block.rebol
    - match: \]
      pop: true
    - match: \[
      push: pop-comment-value-block-tail

  pop-comment-value-string-multiline-tail:
    - meta_scope: comment.value.string.rebol
    - match: \}
      pop: true
    - match: \^\}
    - match: \{
      push: pop-comment-value-string-multiline-tail

  pop-comment-value-string-line-tail:
    - meta_scope: comment.value.string.rebol
    - match: \"
      pop: true
    - match: \^\"
    - match: \"
      push: pop-comment-value-string-line-tail

  pop-comment-value-paren-tail:
    - meta_scope: comment.value.paren.rebol
    - match: \)
      pop: true
    - match: \(
      push: pop-comment-value-paren-tail

  match-constants:
    - match: \b(?:true|false|none)(?![^{{non_ident_chars}}])
      scope: constant.language.rebol

  match-idents:
    - include: match-set-word   # functions are handled from inside set-words
    - include: match-get-word
    - include: match-keywords
    - include: match-ident-type
    - include: match-ident-query
    - include: match-ident-other

  match-set-word:
    - match: '(:)(:)+{{word_boundary}}'
      captures:
        2: invalid.illegal.rebol
    - include: match-decl-function
    - include: match-decl-object
    - match: '({{ident}})(:){{word_boundary}}'
      captures:
        1: entity.name.word.set.rebol
        2: keyword.operator.assignment.rebol

  match-get-word:
    - match: '(:)({{ident}}){{word_boundary}}'
      captures:
        1: keyword.operator.assignment.rebol
        2: entity.name.word.get.rebol

  match-lit-word:
    - match: (\')({{lit_word_chars}}){{word_boundary}}
      captures:
        1: keyword.operator.quote.rebol
        2: entity.name.word.lit.rebol
    - match: (\')(.)
      captures:
        1: keyword.operator.quote.rebol
        2: invalid.illegal.rebol

  match-arrow-word:
    - match: (<)({{arrow_word_chars}}){{word_boundary}}
      scope: variable.other.rebol

  match-refinement:
    - match: (/)({{refinement_chars}}){{word_boundary}}
      captures:
        1: keyword.operator.refinement.rebol
        2: entity.name.word.refinement.rebol

  match-keywords:
    - match: '(?i){{words_control_conditional}}{{word_boundary}}'
      scope: keyword.control.conditional.rebol
    - match: '(?i){{words_control_loop}}{{word_boundary}}'
      scope: keyword.control.loop.rebol
    - match: '(?i){{words_control_flow}}{{word_boundary}}'
      scope: keyword.control.flow.rebol
    - match: '(?i){{words_other_output}}{{word_boundary}}'
      scope: keyword.other.output.rebol
    - match: '(?i)(==|=\?|!==|!=|<=|>=|<>|<|>|=){{word_boundary}}'
      scope: keyword.operator.comparison.rebol
    - match: '(?i)(all|any|not|or|xor){{word_boundary}}'
      scope: keyword.operator.logical.rebol
    - match: '(\+\+|--){{word_boundary}}'
      scope: keyword.operator.assignment.augmented.rebol
    - match: '(\+|\-|\*|\*\*|/|//|<<|>>|&|\|){{word_boundary}}'
      scope: keyword.operator.arithmetic.rebol
    - include: match-keyword-bincode
    - include: match-keyword-tests

  # Binary dialect (bincode) keywords:
  match-keyword-bincode:
    - match: '(?i)((u|s)i8(le|be|(le|be)?bytes)?|(u|s)i16(le|be|(le|be)?bytes)?|(u|s)i24(le|be|(le|be)?bytes)?|(u|s)i32(le|be|(le|be)?bytes)?|(u|s)i64(le|be|(le|be)?bytes|EncodedU32)?){{word_boundary}}'
      scope: storage.type.datatype.bincode.integers.rebol
    - match: '(?i)(float(16)?|double|fixed(8|16)){{word_boundary}}'
      scope: storage.type.datatype.bincode.decimals.rebol
    # words bellow are case sensitive by design (not to colorize any such a word if it's not fully uppercase)
    - match: '(BITSET(8|16|32)|BIT|(S|U|F)B){{word_boundary}}'
      scope: storage.type.datatype.bincode.bits.rebol
    - match: '(INDEX(?i)(z)?||LENGTH\?){{word_boundary}}'
      scope: storage.type.datatype.bincode.index-length.rebol
    - match: '(UNIXTIME-NOW(-LE|-BE)?|MSDOS-(TIME|DATETIME|DATE)){{word_boundary}}'
      scope: storage.type.datatype.bincode.rebol
    - match: '((STRING-|OCTAL-)?BYTES){{word_boundary}}'
      scope: storage.type.datatype.bincode.bytes.rebol
    - match: 'TUPLE(3|4){{word_boundary}}'
      scope: storage.type.datatype.bincode.typle.rebol
    - match: '(SKIP(BITS)?|ALIGN|AT(?i)(z)?){{word_boundary}}'
      scope: storage.type.datatype.bincode.rebol

  # these are special function names used in unit tests
  match-keyword-tests:
    - match: (~~~(start|end)-file~~~){{word_boundary}}
      scope: variable.other.test.file.rebol
    - match: (===(start|end)-group===){{word_boundary}}
      scope: variable.other.test.group.rebol
    - match: '(--test--){{word_boundary}}'
      scope: variable.other.test.rebol
    - match: '(--assert(f~=|-er)?){{word_boundary}}'
      scope: variable.other.test.assert.rebol

  match-ident-type:
    - match: (to|as|make)\s+{{ident}}(!){{word_boundary}}
      scope: storage.type.datatype.rebol
      captures:
        2: storage.type.punctuation.rebol
    - match: '{{ident}}(!){{word_boundary}}'
      scope: storage.type.datatype.rebol
      captures:
        1: storage.type.punctuation.rebol
    - match: (to-{{ident}}){{word_boundary}}
      scope: storage.type.datatype.rebol

  match-ident-query:
    - match: '{{ident}}(\?){{word_boundary}}'
      scope: word.query.rebol
      captures:
        1: storage.type.punctuation.rebol

  match-ident-other:
    - match: '{{ident}}'
      scope: variable.other.rebol

  match-decl-function:
    - match: ({{ident}})(:)\s*{{words_decl_function}}((?=(\s*\[))|(?=(\/)))
      captures:
        1: entity.name.function.rebol
        2: keyword.operator.assignment.rebol
        3: storage.type.function.rebol
      #push:
      #  - pop-block
      #  - pop-locals
      #  - pop-params

  match-decl-object:
    - match: ({{ident}})(:)\s*{{words_decl_object}}(?![^{{non_ident_chars}}])
      captures:
        1: entity.name.class.rebol
        2: keyword.operator.assignment.rebol
        3: storage.type.class.rebol


  match-punctuation:
    - include: match-slash
    - include: match-blocks
    - include: match-parens

  match-slash:
    - match: /
      scope: punctuation.accessor.slash.rebol

  match-blocks:
    - match: \[
      scope: punctuation.section.block.begin.rebol
      push: pop-block-tail
    - match: \]
      scope: punctuation.section.block.end.rebol invalid.illegal.rebol

  pop-block-tail:
    - meta_scope: meta.block.rebol
    - match: \]
      scope: punctuation.section.block.end.rebol
      pop: true
    - include: main

  match-parens:
    - match: \(
      scope: punctuation.section.parens.begin.rebol
      push: pop-parens-tail
    - match: \)
      scope: punctuation.section.parens.end.rebol invalid.illegal.rebol

  pop-parens-tail:
    - meta_scope: meta.paren.rebol
    - match: \)
      scope: punctuation.section.parens.end.rebol
      pop: true
    - include: main

# unused:

#  pop-block:
#    - match: \s*\[
#      scope: punctuation.section.block.begin.rebol
#      set: pop-block-tail
#    - include: pop-before-nonblank
#
#  pop-before-nonblank:
#    - match: (?=\S)
#      pop: true

#  rsp-tag:
#    - match: <%=
#      push:
#        - meta_scope: source.rebol
#        - match: "%>"
#          pop: true
#        - include: scope:source.rebol