MivaScript.sublime-syntax

%YAML 1.2
---
name: Miva Script (MV)
file_extensions:
  - mv
scope: text.mv
variables:
  identifier: '[a-zA-Z_][a-zA-Z0-9_]*'

contexts:
  main:
    - match: ""
      push: "Packages/HTML/HTML.sublime-syntax"
      with_prototype:

        # Comments
        - match: (?i)<MvCOMMENT>
          push: comments

        # Expressions
        - include: expression

        # Tags
        - include: text-tags




  # =-======================== Comments ========================-= #
  comments:
    - meta_scope: comment.block.mv
    - match: (?i)<\/MvCOMMENT>
      pop: true


  # =-======================== Text ========================-= #
  text-tags:
    - include: tag-function
    - include: tag-do
    - include: tag-conditional-block
    - include: tag-conditional-inline
    - include: tag-loop
    - include: tag-flow
    - include: tag-include
    - include: tag-preprocessor
    - include: tag-miva
    - include: tag-assign
    - include: tag-other


  # =-======== Expressions - Text ========-= #
  expression:
    - match: '{'
      scope: puncuation.definition.expression.mv
      push:
        #- clear_scopes: true
        - meta_scope: text.mv source.mv.expr
        - match: '}'
          scope: puncuation.terminator.expression.mv
          pop: true
        - include: source-mv
    - match: '}'
      scope: invalid.illegal.stray-expression-end


  # =-======== Tags - Text ========-= #
  tag-function:
    - match: (?i)(<\/?)(MvFUNCTION)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: meta.function.declaration.mv storage.type.function.mv
      push:
        - meta_scope: meta.tag.block.function.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: text-function-parameters
        - include: text-function-name
        - include: tag-stuff

  tag-do:
    - match: (?i)(<\/?)(MvDO)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: meta.tag.do.mv entity.name.tag.do.mv
      push:
        - meta_scope: meta.tag.inline.do.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: text-attribute-value
        - include: text-attribute-file
        - include: tag-stuff

  tag-conditional-block:
    - match: (?i)(<)(MvIF)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: meta.conditional.mv keyword.control.conditional.mv
      push:
        - meta_scope: meta.tag.block.conditional.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: tag-stuff

  tag-conditional-inline:
    - match: (?i)(<)(MvELSEIF|MvELSE|MvIFDEF|MvIFNDEF)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: meta.conditional.mv keyword.control.conditional.mv
      push:
        - meta_scope: meta.tag.inline.conditional.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: tag-stuff

  tag-flow:
    - match: (?i)(<\/?)(MvFUNCTIONRETURN|MvCALLSTOP|MvCALLCONTINUE|MvCOMMERCESTOP|MvCOMMERCECONTINUE|MvFORSTOP|MvFORCONTINUE|MvFOREACHSTOP|MvFOREACHCONTINUE|MvIMPORTSTOP|MvIMPORTCONTINUE|MvPOPSTOP|MvPOPCONTINUE|MvWHILESTOP|MvWHILECONTINUE)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: keyword.control.flow.mv
      push:
        - meta_scope: meta.tag.inline.flow.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: tag-stuff

  tag-include:
    - match: (?i)(<\/?)(MvINCLUDE|MvIMPORT)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: meta.include.mv keyword.control.import.include.mv
      push:
        - meta_scope: meta.tag.inline.include.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: tag-stuff

  tag-loop:
    - match: (?i)(<)(MvFOR|MvFOREACH|MvWHILE)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: meta.loop.mv keyword.control.loop.mv
      push:
        - meta_scope: meta.tag.block.loop.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: tag-stuff

  tag-preprocessor:
    - match: (?i)(<\/?)(MvASYNCHRONOUS|MvASSEMBLY|MvCOMMERCE|MvCAPTURE)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: meta.tag.preprocessor.mv entity.name.tag.preprocessor.mv meta.preprocessor.mv
      push:
        - meta_scope: meta.tag.block.preprocessor.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: tag-stuff

  tag-miva:
    - match: (?i)(<\/?)(MIVA)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: meta.tag.miva.mv entity.name.tag.miva.mv meta.preprocessor.mv
      push:
        - meta_scope: meta.tag.inline.miva.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: tag-stuff

  tag-assign:
    - match: (?i)(<\/?)(MvASSIGN)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: meta.tag.assign.mv entity.name.tag.assign.mv
      push:
        - meta_scope: meta.tag.inline.assign.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: tag-stuff

  tag-other:
    - match: (?i)(<\/?)(Mv[^\>\s]*)\b
      captures:
        1: punctuation.definition.tag.begin.mv
        2: meta.tag.other.mv entity.name.tag.other.mv
      push:
        - meta_scope: meta.tag.block.other.mv
        - match: (>)
          captures:
            1: punctuation.definition.tag.end.mv
          pop: true
        - include: tag-stuff

  # =-======== Tag Stuff ========-= #
  tag-stuff:
    - include: text-attributes-generic
    - include: text-string-double-quoted
    - include: text-unquoted-numbers

  # =-======== Attributes - Text ========-= #
  text-attributes-generic:
    - match: '(?<=[^=])\b([a-zA-Z0-9\:\-\_]+)\s*(=?)'
      captures:
        1: entity.other.attribute-name.generic.mv
        2: punctuation.separator.key-value.mv

  text-unquoted-numbers:
    - match: '\s*(=?)([0-9]+(\.[0-9]+)?)(\/>)'
      scope: invalid.illegal.unquoted-numeric-constant
      pop: true
    - match: '\s*(=?)([0-9]+(\.[0-9]+)?)\s*(\/?>)'
      captures:
        1: punctuation.separator.key-value.mv
        2: constant.numeric.mv
        3: constant.numeric.mv
        4: punctuation.definition.tag.end.mv
      pop: true

  text-attribute-value:
    - match: '(?i)(?<=[^=])\b(value)\s*(=?)\s*(\")'
      captures:
        1: entity.other.attribute-name.value.mv
        2: punctuation.separator.key-value.mv
        3: string.quoted.double.mv punctuation.definition.string.begin.mv
      push:
        - meta_scope: attribute-content.value.mv string.quoted.double.mv
        - match: '"'
          captures:
            0: punctuation.definition.string.end.mv
          pop: true
        - include: source-variables
        - include: expression

  text-function-name:
    - match: '(?i)(?<=[^=])\b(NAME)\s*(=?)\s*(\")([^\"]*)(\")'
      captures:
        1: entity.other.attribute-name.mv
        2: punctuation.separator.key-value.mv
        3: string.quoted.double.mv punctuation.definition.string.begin.mv
        4: string.quoted.double.mv meta.function.mv entity.name.function.mv
        5: string.quoted.double.mv punctuation.definition.string.end.mv

  text-function-parameters:
    - match: '(?i)(?<=[^=])\b(PARAMETERS)\s*(=?)\s*(\")'
      captures:
        1: entity.other.attribute-name.mv
        2: punctuation.separator.key-value.mv
        3: string.quoted.double.mv punctuation.definition.string.begin.mv
      push:
        - meta_content_scope: source.mv
        - match: '{{identifier}}'
          scope: variable.parameter.function.mv string.quoted.double.mv
        - match: ','
          scope: punctuation.separator.parameter.function.mv
        - match: '\"'
          scope: string.quoted.double.mv punctuation.definition.string.end.mv
          pop: true

  text-attribute-file:
    - match: '(?i)(?<=[^=])\b(file)\s*(=?)\s*(\")'
      captures:
        1: entity.other.attribute-name.file.mv
        2: punctuation.separator.key-value.mv
        3: string.quoted.double.mv punctuation.definition.string.begin.mv
      push:
        - meta_scope: attribute-content.file.mv string.quoted.double.mv
        - match: '"'
          captures:
            0: punctuation.definition.string.end.mv
          pop: true
        - include: source-variables
        - include: expression

  text-attribute-name:
    - match: '(?i)(?<=[^=])\b(name)\s*(=?)\s*(\")'
      captures:
        1: entity.other.attribute-name.name.mv
        2: punctuation.separator.key-value.mv
        3: string.quoted.double.mv punctuation.definition.string.begin.mv
      push:
        - meta_scope: attribute-content.name.mv string.quoted.double.mv
        - match: '"'
          captures:
            0: punctuation.definition.string.end.mv
          pop: true
        - include: source-variables
        - include: expression

  # text-function-parameters:
  #   - match: '(?i)(?<=[^=])\b((?i)parameters)\s*(=?)\s*(\")'
  #     captures:
  #       1: entity.other.attribute-name.parameters.mv
  #       2: punctuation.separator.key-value.mv
  #       3: string.quoted.double.mv punctuation.definition.string.begin.mv
  #     push:
  #       - meta_content_scope: source.mv
  #       - match: '{{identifier}}'
  #         scope: variable.parameter.function.mv string.quoted.double.mv
  #       - match: ','
  #         scope: punctuation.separator.parameter.function.mv
  #       - match: '\"'
  #         scope: string.quoted.double.mv punctuation.definition.string.end.mv
  #         pop: true


  # =-======== String Quoted Double - Text ========-= #
  text-string-double-quoted:
    - match: '"'
      captures:
        0: punctuation.definition.string.begin.mv
      push:
        - meta_scope: string.quoted.double.mv
        - match: '"'
          captures:
            0: punctuation.definition.string.end.mv
          pop: true
        - include: source-variables
        - include: expression


  # =-======================== Source ========================-= #
  source-mv:
    - include: source-variables
    - include: source-function-file
    - include: source-brackets
    - include: source-group
    - include: source-string-single
    - include: source-numbers
    - include: source-operators
    - include: source-constants
    - include: source-functions
    - include: source-function-call


  # =-======== Functions - Source ========-= #
  source-functions:
    # Builtins
    - match: \b({{identifier}})(?=\s*\()
      scope: support.function.builtin.mv

    # Merchant Functions
    - match: \b({{identifier}})(?=\s*\()
      scope: support.function.merchant.mv

  # =-======== Operators - Source ========-= #
  source-operators:
    # Arithmetic Operators
    - match: (\b(?i:POW|MOD|ROUND)\b)
      scope: keyword.operator.arithmetic.mv

    # Arithmetic Operators (Symbols)
    - match: ((?<!\S)(\+|\-|\*|\/)\B)
      scope: keyword.operator.arithmetic.mv

    # Arithmetic Operators (Increment and Decrement)
    - match: (\b(\+\+|\-\-)\B)
      scope: keyword.operator.arithmetic.mv

    # Comparison Operators
    - match: (\b(?i:EQ|GT|GE|LT|NE|LE)\b)
      scope: keyword.operator.comparison.mv

    # Logical Operators
    - match: (\b(?i:NOT|AND|OR|ISNULL)\b)
      scope: keyword.operator.logical.mv

    # Bitwise Operators
    - match: (\b(?i:BITAND|BITOR|BITXOR|BITOC|BITSL|BITSR)\b)
      scope: keyword.operator.bitwise.mv

    # Text Operators
    - match: (\b(?i:IN|CIN|EIN|ECIN|CRYPT)\b)
      scope: keyword.operator.string.mv

    # Text Operators (Symbols)
    - match: ((?<!\S)(\$)\B)
      scope: keyword.operator.string.mv


  # =-======== Constants - Source ========-= #
  source-constants:
    # NULL
    - match: \b(?i:NULL)\b
      scope: constant.language.null.mv
    # POSX
    - match: \b(POS)[0-9]+\b
      scope: constant.language.posx.mv


  # =-======== Numbers - Source ========-= #
  source-numbers:
    - match: \b(([0-9]+(\.[0-9]+)?))\b
      scope: constant.numeric.mv


  # =-======== Variables - Source ========-= #
  source-variables:
    # Variables Base
    - match: '\b(g|global)(\.)'
      captures:
        1: variable.language.global.namespace.mv
        2: variable.language.global.separator.mv
      push:
        - match: '({{identifier}})'
          scope: variable.language.global.name.mv
        - match: '(:?)({{identifier}})'
          captures:
            1: variable.language.global.separator.mv
            2: variable.language.global.member.mv
        - match: \b
          pop: true

    - match: '\b(s|system)(\.)'
      captures:
        1: variable.language.system.namespace.mv
        2: variable.language.system.separator.mv
      push:
        - match: '({{identifier}})'
          scope: variable.language.system.name.mv
        - match: '(:?)({{identifier}})'
          captures:
            1: variable.language.system.separator.mv
            2: variable.language.system.member.mv
        - match: \b
          pop: true

    - match: '\b(l|local)(\.)'
      captures:
        1: variable.language.local.namespace.mv
        2: variable.language.local.separator.mv
      push:
        - match: '({{identifier}})'
          scope: variable.language.local.name.mv
        - match: '(:?)({{identifier}})'
          captures:
            1: variable.language.local.separator.mv
            2: variable.language.local.member.mv
        - match: \b
          pop: true

    # Variables Cont. (continue after square brackets)
    - match: '(?<=\])(:)({{identifier}})'
      captures:
        1: variable.language.separator.mv
        2: variable.language.member.mv
      push:
        - match: '(:?)({{identifier}})'
          captures:
            1: variable.language.separator.mv
            2: variable.language.member.mv
        - match: \b
          pop: true

    # Variables Data
    - match: '\b({{identifier}})(\.)(d|database)(\.)({{identifier}})\b'
      captures:
        1: variable.language.alias.mv
        2: variable.language.separator.mv
        3: variable.language.namespace.mv
        4: variable.language.separator.mv
        5: variable.language.field.mv

  # =-======== Strings - Source ========-= #
  source-string-single:
    - match: "'"
      scope: punctuation.definition.string.begin.mv
      push:
        - meta_scope: string.quoted.single.mv
        - match: "'"
          pop: true
        - include: source-string-escapes

  source-string-escapes:
    - match: \\\s*\n
      scope: constant.character.escape.newline.js
    - match: '\\(x[\da-fA-F][\da-fA-F]|u[\da-fA-F][\da-fA-F][\da-fA-F][\da-fA-F]|.)'
      scope: constant.character.escape.js


  # =-======== Function Calls - Source ========-= #
  source-function-call:
    - match: '({{identifier}})(?=\s*\()'
      scope: variable.function.mv
      push:
        - meta_scope: meta.function-call.mv
        # - include: function-call-params
        - match: '(?=[^ ])'
          pop: true


  # =-======== Brackets / Group (Parenthesis) - Source ========-= #
  source-brackets:
    - match: \[
      scope: puncuation.definition.brackets.mv
      push:
        - meta_scope: meta.brackets.mv
        - match: '\]'
          scope: puncuation.terminator.bracket.mv
          pop: true
        - include: source-mv
    - match: '\]'
      scope: invalid.illegal.stray-bracket-end

  source-group:
    - match: \(
      scope: puncuation.definition.group.mv
      push:
        - meta_scope: meta.group.mv
        - match: \)
          scope: puncuation.terminator.group.mv
          pop: true
        - include: source-mv
    - match: \)
      scope: invalid.illegal.stray-group-end

  # =-======== Special Bracket Dot Function File - Source ========-= #
  # source-function-file:
  #   - match: \[
  #     scope: puncuation.definition.function-file.mv
  #     push:
  #       - meta_scope: function-file.mv
  #       - match: \]\.
  #         scope: puncuation.terminator.function-file-ending.mv
  #         pop: true
  #       - include: source-mv
  #   - match: \]\.
  #     scope: invalid.illegal.stray-bracket-end
  source-function-file:
    - match: '(?<=\])([^\.]*?)\.'
      scope: puncuation.terminator.function-file-ending.mv