Umka.sublime-syntax

%YAML 1.2
---
# See http://www.sublimetext.com/docs/3/syntax.html
file_extensions:
  - um
scope: source.umka
variables:
  builtin: (append|atan|atan2|cap|ceil|copy|cos|delete|exit|exp|fabs|floor|fprintf|fscanf|insert|keys|len|log|make|memusage|new|printf|resume|round|scanf|selfhasptr|selftypeeq|sin|sizeof|sizeofself|slice|sort|sprintf|sqrt|sscanf|trunc|typeptr|valid|validkey)
  ident: '[A-Za-z_][A-Za-z_0-9]*'
  typeident: '_*[A-Z][A-Za-z_0-9]*'
  space: '\s*'
contexts:
  import_named_string:
    - match: "\""
      scope: punctuation.definition.string.begin.umka
      push: double_quoted_string
      pop: true

  expr_traps:
    # Type scoped
    - match: '\{'
      scope: punctuation.definition.parameters.begin.umka
      push: type_scoped

  import:
    # Exit
    - match: '\)'
      scope: keyword.control.umka         
      pop: true

    # Import default
    - match: "\""
      scope: punctuation.definition.string.begin.umka
      push: module_string

    # Import named
    - match: '\b({{ident}}){{space}}(\=)'
      captures:
        1: entity.name.module.umka
        2: keyword.operator.umka
      push: import_named_string

    - include: main

  ternary_scoped:
    - match: '(?<!\:)\:(?!\:)'
      scope: keyword.operator.umka
      pop: true

    - include: expr_traps
    - include: main
  
  expr_scoped:
    - match: '$'
      pop: true

    - match: ';'
      scope: punctuation.separator.umka
      pop: true

    - match: '(?=\})'
      pop: true

    - match: '(?=\))'
      pop: true

    - match: '(?=\])'
      pop: true

    - include: expr_traps
    - include: main

  block_scoped:
    - match: '\}'
      scope: punctuation.definition.codeblock.end.umka
      pop: true

    - include: main

  parenthesis_scoped:
    - match: '\)'
      scope: punctuation.definition.parameters.end.umka
      pop: true

    - include: expr_traps
    - include: main

  bracket_scoped:
    - match: '\]'
      scope: punctuation.definition.parameters.end.umka
      pop: true

    - include: expr_traps
    - include: main
  
  function_param_trap:
    - match: '\bfn\b'
      scope: keyword.control.umka

    - match: '\)'
      scope: punctuation.definition.parameters.end.umka
      pop: true

    - include: main

  method_trap:
    # Method creation builtin override
    - match: '\b({{builtin}}){{space}}(\*?){{space}}(?=\()'
      captures:
        2: entity.name.function.umka
        3: keyword.operator.umka

    # Definition
    - match: '\b({{ident}}){{space}}(\*?){{space}}(?=\()'
      captures:
        1: entity.name.function.umka
        2: keyword.operator.umka

    - match: '\('
      scope: punctuation.definition.parameters.begin.umka
      push: function_param_trap
    
    - match: '$'
      pop: true

    # Closure parameters
    - match: '(\|[^\|]*\|){{space}}(\{)'
      captures:
        1: variable.parameter.umka
        2: punctuation.definition.codeblock.begin.umka
      push: block_scoped
      pop: true

    - match: '\{'
      push: block_scoped
      scope: punctuation.definition.codeblock.begin.umka
      pop: true

    - include: main

  switch_trap:
    - match: ':='
      scope: keyword.operator.umka

    - match: 'type'
      scope: keyword.control.umka
 
    - match: '$'
      pop: true

    - match: '\{'
      scope: punctuation.definition.codeblock.begin.umka
      push: block_scoped
      pop: true

    - include: main

  function_trap:
    - match: '\('
      scope: punctuation.definition.parameters.begin.umka
      push: function_param_trap
    
    # Definition
    - match: '\b({{ident}}){{space}}(\*?){{space}}(?=\()'
      captures:
        1: entity.name.function.umka
        2: keyword.operator.umka

    - match: '$'
      pop: true

    - match: '\{'
      push: block_scoped
      scope: punctuation.definition.codeblock.begin.umka
      pop: true

    - include: main

  enum_scoped:
    - match: '\b({{ident}})\b'
      scope: constant.enum.umka

    - match: '\}'
      scope: punctuation.definition.parameters.end.umka
      pop: true

    - include: main

  interface_scoped:
    - match: '\b({{builtin}}){{space}}(?=\()'
      scope: entity.name.function.umka

    - match: '\b({{builtin}})\b'
      scope: 

    - match: '\}'
      scope: punctuation.definition.parameters.end.umka
      pop: true

    - include: main

  struct_scoped:
    - match: '\}'
      scope: punctuation.definition.parameters.end.umka
      pop: true

    - include: main

    # Struct member
    - match: '\b({{ident}}\,{{space}})*({{ident}})(?={{space}}:)\b'
      scope: variable.parameter.umka

  type_scoped:
    # Module override
    - match: '\b({{ident}}){{space}}(?=::)'
      scope: entity.name.module.umka
    
    - match: '(?=\b(var|const|if|for|switch|type|return|break|continue)\b)'
      set: block_scoped

    - match: '\+\+|--'
      scope: keyword.operator.umka
      set: block_scoped

    - match: '\{'
      scope: punctuation.definition.parameters.begin.umka
      push: type_scoped

    - match: '\}'
      scope: punctuation.definition.parameters.end.umka
      pop: true
 
    # Trap decl
    - match: '\b*({{ident}}){{space}}(?=:=)\b'
      scope: variable.other.umka
      set: block_scoped

    # Struct fields
    - match: '\b*({{ident}}){{space}}(?=:)\b'
      scope: variable.parameter.umka

    - include: main
  
  main:
    # Equality trap
    - match: '=='
      scope: keyword.operator.umka

    # Assign/decl expr scope trap
    - match: '(:=|\+=|\-=|\*=|/=|%=|&=|\|=|~=|<<=|>>=|\^=|=)'
      scope: keyword.operator.umka
      push: expr_scoped

    - match: '\('
      scope: punctuation.definition.parameters.begin.umka
      push: parenthesis_scoped

    - match: '\['
      scope: punctuation.definition.parameters.begin.umka
      push: bracket_scoped

    - match: '\{'
      scope: punctuation.definition.codeblock.begin.umka
      push: block_scoped

    # Predeclared constants
    - match: '\b(true|false|null)\b'
      scope: storage.constant.umka       

    # Predeclared types
    - match: '\b(str|void|int8|int16|int32|int|uint8|uint16|uint32|uint|bool|char|real32|real|fiber|any)\b'
      scope: storage.type.umka

    # Method call builtin override
    - match: '(?<=\.){{space}}({{builtin}}){{space}}(?=\()'
      captures:
        1: variable.function.umka

    # Builtin functions
    - match: '\b{{builtin}}\b'
      scope: support.function.umka

    # Imports
    - match: '\bimport{{space}}\('
      scope: keyword.control.umka         
      push: import

    - match: '\bimport{{space}}(?=\")'
      scope: keyword.control.umka     
      push:
        - match: '"'
          scope: punctuation.definition.string.begin.umka
          push: module_string
          pop: true

    - match: '\b(import){{space}}({{ident}}){{space}}(\=){{space}}(?=\")'
      captures:
        1: keyword.control.umka
        2: entity.name.module.umka
        3: keyword.operator.umka
      push:
        - match: '"'
          scope: punctuation.definition.string.begin.umka
          push: double_quoted_string
          pop: true

    # Method brace trap
    - match: '\bfn{{space}}(?=\()'
      scope: keyword.control.umka
      push: method_trap

    # Switch brace trap
    - match: '\bswitch\b'
      scope: keyword.control.umka
      push: switch_trap

    # Function brace trap
    - match: '\bfn\b'
      scope: keyword.control.umka
      push: function_trap

    # Return expr scope trap
    - match: '\breturn\b'
      scope: keyword.control.umka
      push: expr_scoped

    # Struct definitions
    - match: '\b(struct){{space}}(\{)'
      captures:
        1: keyword.control.umka
        2: punctuation.definition.parameters.begin.umka
      push: struct_scoped

    # Enum definitions
    - match: '\b(enum){{space}}(\{)'
      captures:
        1: keyword.control.umka
        2: punctuation.definition.parameters.begin.umka
      push: enum_scoped

    # Interface definitions
    - match: '\b(interface){{space}}(\{)'
      captures:
        1: keyword.control.umka
        2: punctuation.definition.parameters.begin.umka
      push: interface_scoped

    # Enum member before case
    - match: '\b(case){{space}}(\.){{space}}({{ident}})'
      captures: 
        1: keyword.control.umka
        2: punctuation.separator.umka
        3: constant.enum.umka

    # Keywords
    - match: '\b(break|case|const|continue|default|else|enum|for|fn|import|interface|if|in|map|return|str|struct|switch|type|var|weak)\b'
      scope: keyword.control.umka         
    
    # Ternary scoped 
    - match: '\?'
      scope: keyword.operator.umka
      push: ternary_scoped

    # Closure parameters
    - match: '(\|[^\|]*\|){{space}}(\{)'
      captures:
        1: variable.parameter.umka
        2: punctuation.definition.codeblock.begin.umka
      push: block_scoped

    # Enum direct access
    - match: '\b({{typeident}}){{space}}(\.){{space}}({{ident}})'
      captures:
        1: storage.type.umka
        2: punctuation.separator.umka
        3: constant.enum.umka

    # Variadic type
    - match: '(\.\.){{space}}({{ident}})'
      captures:
        1: punctuation.separator.um
        2: storage.type.umka

    # Type
    - match: '\b{{typeident}}\b'
      scope: storage.type.umka

    # Function call
    - match: '\b({{ident}}){{space}}(?=\()'
      captures:
        1: variable.function.umka

    # Method call
    - match: '(\.){{space}}({{ident}}){{space}}(?=\()'
      captures:
        1: punctuation.separator.umka
        2: variable.function.umka

    # Member
    - match: '(?<=[A-Za-z_0-9\]\)\}\^]){{space}}(\.){{space}}({{ident}})'
      captures: 
        1: punctuation.separator.umka
        2: variable.parameter.umka

    # Enum member
    - match: '(\.){{space}}({{ident}})'
      captures: 
        1: punctuation.separator.umka
        2: constant.enum.umka

    # Module
    - match: '\b({{ident}}){{space}}(?=::)'
      scope: entity.name.module.umka

    # Module member
    - match: '(?<=::){{space}}({{ident}})'
      scope: variable.parameter.umka

    # Line comments
    - match: '//'
      scope: punctuation.definition.comment.umka
      push: line_comment

    # Block comments
    - match: '/\*'
      scope: punctuation.definition.comment.begin.umka
      push: block_comment  

    # Operators
    - match: '|\+\+|\-\-|&&|\|\||\*|\+|\-|/|%|&|\||~|<<|>>|!|==|!=|<=|>=|<|>|:=|^='
      scope: keyword.operator.umka

    # Punctuation
    - match: '\^|;|:|::|\.|,'
      scope: punctuation.separator.umka
 
    # Hex literals
    - match: '\b(0[Xx])[0-9A-Fa-f]+\b'
      scope: constant.numeric.umka      

    # Decimal literals
    - match: '\b[0-9.]+([Ee][+-]?[0-9]*)?\b'
      scope: constant.numeric.umka       

    # String literals
    - match: '"'
      scope: punctuation.definition.string.begin.umka
      push: double_quoted_string

    # Character literals
    - match: ''''
      scope: punctuation.definition.string.begin.umka
      push: single_quoted_string              

  module_string:
    - meta_scope: string.quoted.double.umka
    - match: '\\.'
      scope: constant.character.escape.umka
    - match: "{{ident}}(?=\\.um)"
      scope: entity.name.module.umka
    - match: '"'
      scope: punctuation.definition.string.end.umka
      pop: true

  double_quoted_string:
    - meta_scope: string.quoted.double.umka
    - match: '\%\%'
      scope: constant.character.escape.umka
    - match: '\%[\-\+\s\#0]?([0-9]+|\*)?(\.[0-9]*)?(hh|h|l|ll)?[diuxXfFeEgGscv]'
      scope: constant.character.escape.umka
    - match: '(\\x[A-Fa-f0-9][A-Fa-f0-9]|\\.)'
      scope: constant.character.escape.umka
    - match: '"'
      scope: punctuation.definition.string.end.umka
      pop: true

  single_quoted_string:
    - meta_scope: string.quoted.single.umka
    - match: '(\\x[A-Fa-f0-9][A-Fa-f0-9]|\\.)'
      scope: constant.character.escape.umka
    - match: ''''
      scope: punctuation.definition.string.end.umka
      pop: true

  line_comment:
    - meta_scope: comment.line.umka
    - match: $
      pop: true
    - include: todos

  block_comment:
    - meta_scope: comment.block.umka
    - match: '\*/'
      scope: punctuation.definition.comment.end.umka
      pop: true
    - include: todos

  todos:
    - match: '\b(TODO|FIXME|BUG|HACK|IMPORTANT|NOTE|WIP|XXX)\b(\(.*\))?:?'
      scope: markup.bold.umka

    - match: '\>\>\>.*'
      scope: markup.bold.heading

    - match: '\@([A-Z][A-Z0-9]*)\b(\(.*\))?:?'
      scope: markup.bold.umka