rebol.sublime-syntax

%YAML 1.2
---
file_extensions: [rebol, reds, red, r]
scope: source.rebol

# Based mostly on this Quick Tour: http://www.rebol.com/docs/core23/rebolcore-3.html
# TODO: use the actual language/lexer specs for Rebol and Red.

variables:
  comment_line_start: ;
  non_ident_chars: \[\]{}"\(\)/\\@#\$%\^,:;<>\s
  non_ident_start_chars: \d'{{non_ident_chars}}
  ident: '[^{{non_ident_start_chars}}][^{{non_ident_chars}}]*'
  fractional: \d+([.,])\d+(?:([Ee][+-]?)\d+)?
  non_url_chars: '\s\[\]\(\){}"%'
  non_email_chars: '{{non_url_chars}}:'

contexts:
  prototype:
    - include: match-comments

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

  match-literals:
    - include: match-times
    - include: match-dates
    - include: match-money
    - include: match-tuples
    - include: match-tags
    - include: match-emails
    - include: match-urls
    - include: match-filenames
    - include: match-pairs
    - include: match-binaries
    - include: match-issues
    - include: match-strings
    - include: match-numbers

  match-numbers:
    - include: match-floats
    - include: match-integers

  match-floats:
    - match: '{{fractional}}'
      scope: constant.numeric.float.rebol
      captures:
        1: punctuation.separator.decimal.rebol
        2: punctuation.separator.exponent.rebol

  # TODO: hex integers.
  match-integers:
    - include: match-integers-dec

  match-integers-dec:
    - match: \d+
      scope: constant.numeric.integer.rebol

  match-times:
    - match: (?:\d+(:))?\d+(:)\d+(?:([.,])\d+)?(?:(?i)(am|pm))?
      scope: constant.numeric.time.rebol
      captures:
        1: punctuation.separator.time.rebol
        2: punctuation.separator.time.rebol
        3: punctuation.separator.time.rebol
        4: storage.type.ampm.rebol

  match-dates:
    - match: |-
        (?x:
          (?:
            (?:\d+(-)[[:alnum:]]+(-)\w+)|
            (?:\d+(/)[[:alnum:]]+(/)\w+)
          )
          (?:
            (/)(?:\d+(:))?\d+(:)\d+(?:([.,])\d+)?(?:(?i)(am|pm))? # Time
            (?:([+-])\d+(:)\d+)?                                  # Timezone
          )?
        )
      scope: constant.numeric.date.rebol
      captures:
        1: punctuation.separator.time.rebol
        2: punctuation.separator.time.rebol
        3: punctuation.separator.time.rebol
        4: punctuation.separator.time.rebol
        5: punctuation.separator.time.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: ([[:alpha:]]+)?([\$\£\€\¥])(?:\d+|{{fractional}})
      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-tuples:
    - match: \d+\.\d+(?:\.|(?:\.\d+)+)
      scope: constant.numeric.tuple.rebol

  # Extremely limited support for tags. No special syntax for attributes.
  # This should be improved in the future.
  #
  # Note: the language supports some other characters in tag names, but for now
  # we're more interested in avoiding collisions with identifiers such as
  # `<=`.
  match-tags:
    - match: (</?)([[:alnum:]_:-]+)
      captures:
        1: punctuation.definition.tag.begin.rebol
        2: entity.name.tag.rebol
      push: pop-tag

  pop-tag:
    - meta_scope: meta.tag.rebol
    - match: /?\>
      scope: punctuation.definition.tag.end.rebol
      pop: true
    - include: main

  # Note: the email literal in Red is EXTREMELY permissive.
  # TODO: `punctuation.separator` for punctuation. Requires push/pop.
  match-emails:
    - 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.
  # TODO: `punctuation.separator` for punctuation. Requires push/pop.
  match-urls:
    - match: '[[:alpha:]][^{{non_url_chars}}:/]*(://?)[^{{non_url_chars}}]*'
      scope: string.url.rebol
      captures:
        1: storage.type.url.rebol

  match-filenames:
    # TODO support escapes.
    - match: (\%)"^["]*"
      scope: string.filename.rebol
      captures:
        1: storage.type.filename.rebol
    - match: (\%)[^\s\[\](){};@%]*
      scope: string.filename.rebol
      captures:
        1: storage.type.filename.rebol

  match-pairs:
    - match: \d+(x)\d+
      scope: constant.numeric.pair.rebol
      captures:
        1: punctuation.separator.pair.rebol

  match-binaries:
    - match: ((?:\d+)?\#)({)
      captures:
        1: storage.type.binary.rebol
        2: punctuation.definition.string.begin.rebol
      push: pop-binary-multi

  # TODO: scope invalid characters.
  pop-binary-multi:
    - meta_scope: string.binary.rebol
    - match: \}
      scope: punctuation.definition.string.end.rebol
      pop: true

  match-issues:
    - match: (\#)[\w-]*
      scope: string.issue.rebol
      captures:
        1: storage.type.issue.rebol

  match-strings:
    - include: match-strings-double
    - include: match-strings-braces

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

  pop-strings-double:
    - meta_include_prototype: false
    - meta_scope: string.quoted.double.rebol
    - match: '"'
      scope: punctuation.definition.string.end.rebol
      pop: true
    - match: \^\([^)]*\)
      scope: constant.character.escape.rebol
    - match: \^.
      scope: constant.character.escape.rebol

  # TODO support escapes.
  match-strings-braces:
    - match: '{'
      scope: punctuation.definition.string.begin.rebol
      push: pop-strings-braces

  pop-strings-braces:
    - meta_include_prototype: false
    - meta_scope: string.quoted.double.rebol
    - match: '}'
      scope: punctuation.definition.string.end.rebol
      pop: true
    - include: match-strings-braces

  match-comments:
    - include: match-comments-line
    - include: match-comments-block

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

  match-comments-block:
    - match: (?<=^|{{non_ident_chars}})(comment)(?![^{{non_ident_chars}}])
      scope: comment.block.rebol
      push: pop-comment-block

  # TODO: pop one "form", making it part of the comment (literal, ident, block,
  # group, etc.).
  pop-comment-block:
    - match: ''
      pop: true

  match-constants:
    - match: \b(?:true|false)\b
      scope: constant.language.rebol

  match-idents:
    - include: match-decl-func
    - include: match-decl-function
    - include: match-decl-other
    - include: match-ident-type
    - include: match-ident-other

  match-ident-type:
    - match: '{{ident}}!'
      scope: storage.type.rebol

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

  match-decl-func:
    - match: ({{ident}})(:)\s*(func)(?![^{{non_ident_chars}}])
      captures:
        1: entity.name.function.rebol
        2: keyword.operator.assignment.rebol
        3: storage.type.function.rebol
      push:
        - pop-block
        - pop-params

  match-decl-function:
    - match: ({{ident}})(:)\s*(function)(?![^{{non_ident_chars}}])
      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-other:
    - match: '({{ident}})(:)'
      captures:
        1: entity.name.rebol
        2: keyword.operator.assignment.rebol

  pop-params:
    - match: \[
      scope: punctuation.section.block.begin.rebol
      set: pop-params-tail
    - include: pop-before-nonblank

  pop-params-tail:
    - meta_scope: meta.block.rebol
    - match: \]
      scope: punctuation.section.block.end.rebol
      pop: true
    - include: match-ident-type
    - match: '{{ident}}'
      scope: variable.parameter.rebol
    - include: main

  pop-locals:
    - match: \[
      scope: punctuation.section.block.begin.rebol
      set: pop-locals-tail
    - include: pop-before-nonblank

  pop-locals-tail:
    - meta_scope: meta.block.rebol
    - match: \]
      scope: punctuation.section.block.end.rebol
      pop: true
    - include: match-ident-type
    - match: '{{ident}}'
      scope: variable.declaration.rebol
    - include: main

  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:
    - match: \[
      scope: punctuation.section.block.begin.rebol
      set: pop-block-tail
    - include: pop-before-nonblank

  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

  pop-before-nonblank:
    - match: (?=\S)
      pop: true