atg-c#.sublime-syntax

%YAML 1.2
---
name: ATG C#
file_extensions:
  - atg
scope: source.atg
variables:
  ident: '\b[[:alpha:]][\w]+\b'
  terminator: '(?<!\.)\.(?!\.)'
  section_name: '\b(COMPILER|IGNORECASE|CHARACTERS|TOKENS|COMMENTS|IGNORE|PRAGMAS|PRODUCTIONS|END)\b'
contexts:
  main:
    - include: imports
    - include: title_and_globals
    - include: scanner
    - include: parser
    - include: end_tag

  # Included in contexts by default:
  prototype:
  - include: comments

################ General ##################

  comments:
    - match: '\/\*'
      scope: puctuation.definition.comment.atg
      push:
        - meta_scope: comment.block.atg
        - match: '\*\/'
          scope: punctuation.definition.comment.atg
          pop: true
    - match: '\/\/'
      scope: puctuation.definition.comment.atg
      push:
        - meta_scope: comment.line.atg
        - match: $\n?
          pop: true

  strings:
    # strings are not affected by comments
    - match: '"'
      scope: punctuation.definition.string.begin.atg
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.atg
        - match: '"'
          scope: punctuation.definition.string.end.atg
          pop: true
        - match: \\.
          scope: constant.character.escape.atg
    - match: "'"
      scope: punctuation.definition.string.begin.atg
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.single.atg
        - match: "'"
          scope: punctuation.definition.string.end.atg
          pop: true
        - match: \\.
          scope: constant.character.escape.atg

  end_tag:
    - match: '\bEND\b'
      scope : storage.modifier.atg
      push:
        - match: '{{terminator}}'
          scope: punctuation.terminator.atg
          pop: true

################ Scanner Specification ##################

  scanner:
    - include: section_ignorecase
    - include: section_characters
    - include: section_tokens
    - include: section_comments
    - include: section_ignore

  section_ignorecase:
    - match: '\bIGNORECASE\b'
      scope: storage.modifier.atg

  section_characters:
    - match: '\bCHARACTERS\b'
      scope: storage.modifier.atg
      push:
      - meta_content_scope: "meta.section.characters.body.atg"
      - match: '(?={{section_name}})'
        pop: true
      - include: set_decl

  section_tokens:
    - match: '\bTOKENS\b'
      scope: storage.modifier.atg
      push:
      - meta_content_scope: "meta.section.tokens.body.atg"
      - match: '(?={{section_name}})'
        pop: true
      - include: token_decl

  section_comments:
    - match: '\bCOMMENTS\b'
      scope: storage.modifier.atg
      push:
      - meta_content_scope: "meta.section.comments.body.atg"
      - match: '(?={{section_name}})'
        pop: true
      - include: strings
      - match: '\b(FROM|TO|NESTED)\b'
        scope: keyword.control.atg

  section_ignore:
    - match: '\bIGNORE\b'
      scope: storage.modifier.atg
      push:
      - meta_content_scope: "meta.section.ignore.body.atg"
      - match: '(?={{section_name}})'
        pop: true
      - include: set_expr
      - match: '\bCASE\b'
        scope: keyword.control.atg

  set_decl:
    - match: '{{ident}}'
      scope: entity.name.rule.atg
      push:
      - match: '{{terminator}}'
        scope: punctuation.section.rule.terminator.atg      
        pop: true
      - match: '='
        scope: punctuation.section.rule.definition.atg
        push:
        - meta_content_scope: meta.rule.body.atg
        - match: '(?={{terminator}})'
          pop: true
        - include: set_expr

  set_expr:
    - include: strings
    - include: keyword_any
    - match: '\+'
      scope: keyword.operator.union.atg
    - match: '-'
      scope: keyword.operator.difference.atg
    - match: '\.\.'
      scope: keyword.operator.range.atg

  token_decl:
    - match: ({{ident}}|".*?"|'.*?') # ident and strings are valid token names
      scope: entity.name.rule.atg
      push:
      - match: '{{terminator}}'
        scope: punctuation.section.rule.terminator.atg
        pop: true
      - match: '='
        scope: punctuation.section.rule.definition.atg
        push:
        - meta_content_scope: meta.rule.body.atg
        - match: '(?={{terminator}})'
          pop: true
        - include: token_expr

  token_expr:
    - include: strings
    - include: keyword_context
  # Bracket Balancing:
    # grouping
    - match: '\('
      scope: keyword.control.grouping.atg
      push:
        - match: '\)'
          scope: keyword.control.grouping.atg
          pop: true
        - include: token_expr
    - match: '\)'
      scope: invalid.illegal.stray-bracket-end
    # optional
    - match: '\['
      scope: keyword.control.optional.atg
      push:
        - match: '\]'
          scope: keyword.control.optional.atg
          pop: true
        - include: token_expr
    - match: '\]'
      scope: invalid.illegal.stray-bracket-end
    # repetition
    - match: '\{'
      scope: keyword.control.repetition.atg
      push:
        - match: '\}'
          scope: keyword.control.repetition.atg
          pop: true
        - include: token_expr
    - match: '\}'
      scope: invalid.illegal.stray-bracket-end
    # alternation
    - match: '\|'
      scope: keyword.control.alternation.atg

################ Parser Specification ##################

  parser:
    - match: '\bPRODUCTIONS\b'
      scope: storage.modifier.atg
      push:
      - meta_content_scope: "meta.section.productions.body.atg"
      - match: '(?={{section_name}})'
        pop: true
      - include: production_decl

  production_decl:
    - match: '{{ident}}'
      scope: entity.name.rule.atg
      push:
      - match: '{{terminator}}'
        scope: punctuation.section.rule.terminator.atg      
        pop: true
      - match: '='
        scope: punctuation.section.rule.definition.atg
        push:
        - meta_content_scope: meta.rule.body.atg
        - match: '(?={{terminator}})'
          pop: true
        - include: expression
      - include: parameters
      - include: sem_action

  expression:
    - include: strings
    - include: keyword_if_resolver
    - include: arguments
    - include: sem_action
    - include: keyword_any
    - match: '\b(WEAK|SYNC)\b'
      scope: keyword.control.atg
  # Bracket Balancing:
    # grouping
    - match: '\('
      scope: keyword.control.grouping.atg
      push:
        - match: '\)'
          scope: keyword.control.grouping.atg
          pop: true
        - include: expression
    - match: '\)'
      scope: invalid.illegal.stray-bracket-end
    # optional
    - match: '\['
      scope: keyword.control.optional.atg
      push:
        - match: '\]'
          scope: keyword.control.optional.atg
          pop: true
        - include: expression
    - match: '\]'
      scope: invalid.illegal.stray-bracket-end
    # repetition
    - match: '\{'
      scope: keyword.control.repetition.atg
      push:
        - match: '\}'
          scope: keyword.control.repetition.atg
          pop: true
        - include: expression
    - match: '\}'
      scope: invalid.illegal.stray-bracket-end
    # alternation
    - match: '\|'
      scope: keyword.control.alternation.atg

################ C# language dependent ##################

  imports:
    # from top of C#.sublime-syntax#main:
    - match: '^\s*(using)\s+([^ ;]*);'
      scope: meta.keyword.using.source.cs
      captures:
        1: keyword.other.using.source.cs

  title_and_globals:
    - match: '(\bCOMPILER\b)\s*(\b[[:alpha:]][\w]+\b)'
      captures:
        1: storage.modifier.atg
        2: entity.name.rule.atg
      push:
      - meta_content_scope: meta.globals.atg
      - include: "Packages/C#/C#.sublime-syntax#method"
      - include: "Packages/C#/C#.sublime-syntax#code"
      with_prototype:
        # note: section_name variable does not work here
        - match: '(?=\b(COMPILER|IGNORECASE|CHARACTERS|TOKENS|COMMENTS|IGNORE|PRAGMAS|PRODUCTIONS|END)\b)'
          pop: true
        
  sem_action:
    - match: '\(\.'
      scope: punctuation.section.semantic.begin.atg
      push: 
      - include: "Packages/C#/C#.sublime-syntax#code"
      with_prototype:
        - match: '\.\)'
          scope: punctuation.section.semantic.end.atg
          pop: true

  parameters:
    - match: '<'
      push:
      - match: '>'
        pop: true
      - include: "Packages/C#/C#.sublime-syntax#constants"
      - include: "Packages/C#/C#.sublime-syntax#block"
      # from C#.sublime-syntax#parameters:
      - match: '\b(ref|params|out)?\s*\b([\w.\[\]]+)\s+(\w+)\s*(=)?'
        captures:
          1: storage.type.modifier.source.cs
          2: storage.type.generic.source.cs
          3: variable.parameter.function.source.cs
          4: keyword.operator.assignment.source.cs

  arguments:
    - match: '<'
      scope: punctuation.section.arguments.begin.atg
      push: 
      - include: "Packages/C#/C#.sublime-syntax#code"
      with_prototype:
        - match: '>'
          scope: punctuation.section.arguments.end.atg
          pop: true

  keyword_if_resolver:
    - match: '\b(IF)\b\s*\('
      captures:
        1: keyword.control.atg
      push: 
      - include: "Packages/C#/C#.sublime-syntax#code"
      with_prototype:
        - match: '\)'
          pop: true

 ################ Keywords ##################

  keyword_context:
    - match: '\b(CONTEXT)\b\s*\('
      captures:
        1: keyword.control.atg
      push:
        - match: '\)'
          pop: true
        - include: token_expr

  keyword_any:
    - match: '\bANY\b'
      scope: constant.language.atg