PureBasic.sublime-syntax

%YAML 1.2
---
file_extensions:
  - pb
  - pbi
  - pbf
scope: source.purebasic
version: 2
variables:
  following_pointer: '(\s*(\*))?'
  opening_parens: '(\()(\*)?'
  return_type: '(\s*(\.)\s*(\w+))?'
  variables: '(\@)?(\w+)(\$)?'
contexts:
  calls:
    - match: '\b(\w+)(\()'
      captures:
        1: variable.function.purebasic
        2: punctuation.section.parens.begin.purebasic
      push:
        - meta_scope: meta.function-call.purebasic
        - match: '\)'
          scope: punctuation.section.parens.end.purebasic
          pop: true
        - include: literals
        - include: keywords
        - include: types
        - include: punctuation
        - include: calls
        - include: variables
        - include: constants

  comments:
    - match: ';'
      scope: punctuation.definition.comment.purebasic
      push:
        - meta_scope: comment.line.purebasic
        - match: '$'
          pop: true

  constants:
    - match: '(#)([\w_]+)\b'
      captures:
        0: variable.other.constant.purebasic
        1: punctuation.definition.variable.purebasic

  declarations:
    - match: '\b(?i:(Enumeration|EnumerationBinary))(\s+(\D\w+))?\b'
      captures:
        1: storage.type.enum.purebasic keyword.declaration.enum.purebasic
        3: entity.name.enum.purebasic
      push:
        - include: comments
        - include: terminators
        - include: literals
        - include: keywords
        - include: types
        - include: punctuation
        - include: variables
        - include: constants

    - match: '\b(?i:(Declare|DeclareCDLL|DeclareDLL|Prototype))(\s*(\.)\s*(\w+))?\s+(\w+)'
      captures:
        1: storage.type.function.purebasic keyword.declaration.function.purebasic
        3: punctuation.separator.purebasic
        4: meta.function.return-type.purebasic storage.type.purebasic
        5: entity.name.function.forward-decl.purebasic
      push: parameters

    - match: '\b(?i:(Define)){{following_pointer}}\b'
      captures:
        1: keyword.declaration.purebasic
        3: variable.other.purebasic punctuation.definition.variable.purebasic
      push:
        - include: terminators
        - include: literals
        - include: keywords
        - include: types
        - include: punctuation
        - include: variables
        - include: constants

    - match: '\b(?i:(Dim|NewList|NewMap|ReDim))\s+(\w+)\b'
      captures:
        1: keyword.declaration.purebasic
        2: entity.name.function.purebasic
      push:
        - include: terminators
        - include: literals
        - include: keywords
        - include: types
        - include: punctuation
        - include: variables
        - include: constants

    - match: '\b(?i:Global|Protected|Runtime|Shared|Static|Threaded)\b'
      scope: storage.modifier.purebasic

    - match: '\b(?i:(DeclareModule|Module)\s+(\w+))\b'
      captures:
        1: keyword.declaration.purebasic
        2: entity.name.namespace.purebasic
      push:
        - meta_scope: meta.namespace.purebasic
        - match: '\b(?i:EndDeclareModule|EndModule)\b'
          scope: keyword.other.purebasic
          pop: true
        - include: comments
        - include: literals
        - include: declarations
        - include: keywords
        - include: types
        - include: punctuation
        - include: variables
        - include: constants

    - match: '\b(?i:(Procedure|ProcedureC|ProcedureCDLL|ProcedureDLL){{return_type}}\s+(\w+))\b'
      captures:
        1: storage.type.function.purebasic keyword.declaration.function.purebasic
        3: punctuation.separator.purebasic
        4: meta.function.return-type.purebasic storage.type.purebasic
        5: entity.name.function.purebasic
      push: procedures

    - match: '\b(?i:(Import))\b'
      captures:
        1: keyword.control.import.purebasic
      push:
        - include: comments
        - include: literals
        - match: '\bEndImport\b'
          scope: keyword.control.import.purebasic
          pop: true
        - include: parameter_keywords
        - include: members
        - include: keywords
        - include: types
        - include: punctuation

    - match: '\b(?i:(Interface)\s+(\w+)(\s+(Extends)\s+(\w+))?)\b'
      captures:
        1: storage.type.interface.purebasic keyword.declaration.interface.purebasic
        2: entity.name.interface.purebasic
        4: keyword.other.purebasic
        5: entity.name.interface.purebasic
      push:
        - include: comments
        - include: literals
        - match: '\bEndInterface\b'
          scope: keyword.other.purebasic
          pop: true
        - include: parameter_keywords
        - include: members
        - include: keywords
        - include: types
        - include: punctuation

    - match: '\b(?i:(Structure)\s+(\w+)(\s+(Extends)\s+(\w+))?)\b'
      captures:
        1: storage.type.struct.purebasic keyword.declaration.struct.purebasic
        2: entity.name.struct.purebasic
        4: keyword.other.purebasic
        5: entity.name.struct.purebasic
      push:
        - include: comments
        - include: literals
        - match: '\bEndStructure\b'
          scope: keyword.other.purebasic
          pop: true
        #
        # "StructureUnion" blocks can only appear inside "Structure" definitions.
        #
        - match: '\b(?i:StructureUnion|EndStructureUnion)\b'
          scope: keyword.other.purebasic
        - include: parameter_keywords
        - include: members
        - include: keywords
        - include: types
        - include: punctuation

  leading_pointers:
    - match: '^\s*(\*)'
      captures:
        1: punctuation.definition.variable.purebasic variable.other.purebasic

  main:
    - include: comments
    - include: literals
    - include: declarations
    - include: leading_pointers
    - include: keywords
    - include: types
    - include: punctuation
    - include: calls
    - include: labels
    - include: variables
    - include: constants

  #
  # Variable and procedure definitions inside structure definitions and interface blocks.
  #
  members:
    - match: '\b(\w+){{return_type}}(\()'
      captures:
        1: entity.name.function.forward-decl.purebasic
        3: punctuation.separator.purebasic
        4: meta.function.return-type.purebasic storage.type.purebasic
        5: punctuation.section.parens.begin.purebasic
      push: parameters
    #
    # Variables are scoped slightly different than all other variables.
    #
    - match: '(\*)?(\w+)(\$)?'
      captures:
        0: variable.other.member.purebasic
        1: punctuation.definition.variable.purebasic
        3: punctuation.definition.variable.purebasic

  labels:
    - match: '\b((\w+)(:))\s*$'
      captures:
        2: entity.name.label.purebasic
        3: punctuation.separator.purebasic

  #
  # Strings and numbers.
  #
  literals:
    # Strings with escape sequences require a tilde before the beginning double quote.
    - match: '~"'
      scope: punctuation.definition.string.begin.purebasic
      push:
        - meta_scope: string.quoted.double.purebasic
        - match: '\\[\w\d"]'
          scope: constant.character.escape.purebasic
        - match: '"'
          scope: punctuation.definition.string.end.purebasic
          pop: true

    # Literal strings without escape sequences.
    - match: '"'
      scope: punctuation.definition.string.begin.purebasic
      push:
        - meta_scope: string.quoted.double.purebasic
        - match: '"'
          scope: punctuation.definition.string.end.purebasic
          pop: true

    - match: '\-?\d+(\.\d+)?(e\-\d+)?'
      scope: constant.numeric.purebasic

  keywords:
    - include: operators_all

    - match: '\b(?i:Break|Case|Continue|CompilerCase|CompilerDefault|CompilerElse|CompilerElseIf|CompilerEndIf|CompilerEndSelect|CompilerIf|CompilerSelect|Default|Else|End|EndIf|EndSelect|ElseIf|Else|FakeReturn|For|ForEach|Forever|Gosub|Goto|If|Next|Repeat|Select|To|Until|Wend|While)\b'
      scope: keyword.control.purebasic

    - match: '\b(?i:DataSection|EndDataSection|IncludeFile|IncludePath|XIncludeFile)\b'
      scope: keyword.control.import.purebasic

    - match: '\b(?i:Interface)\b'
      scope: keyword.declaration.purebasic

    - match: '\b(?i:(CallDebugger|CompilerError|CompilerWarning|Data|Debug|DebugLevel|DisableASM|DisableDebugger|DisableExplicit|EnableASM|EnableDebugger|EnableExplicit|EndEnumeration|EndInterface|EndMacro|EndWith|Extends|Macro|MacroExpandedCount|Module|ProcedureReturn|Read|Restore|Step|Swap|UndefineMacro|UnuseModule|UseModule|With))\b{{following_pointer}}'
      captures:
        1: keyword.other.purebasic
        3: variable.other.purebasic punctuation.definition.variable.purebasic

  operators_all:
    - include: operators_arithmetic
    - include: operators_assignment
    - include: operators_comparison
    - include: operators_logical
    - include: operators_bitwise

  operators_arithmetic:
    - match: '(\+|-|\*|/|%|<<|>>){{following_pointer}}'
      captures:
        1: keyword.operator.arithmetic.purebasic
        3: variable.other.purebasic punctuation.definition.variable.purebasic

  operators_assignment:
    - match: '(=(?![<>])){{following_pointer}}'
      captures:
        1: keyword.operator.assignment.purebasic
        3: variable.other.purebasic punctuation.definition.variable.purebasic

  operators_bitwise:
    - match: '(&|\||!|~){{following_pointer}}'
      captures:
        1: keyword.operator.bitwise.purebasic
        3: variable.other.purebasic punctuation.definition.variable.purebasic

  operators_comparison:
    - match: '(<=?|>=?|=<?|=>?|<>){{following_pointer}}'
      captures:
        1: keyword.operator.comparison.purebasic
        3: variable.other.purebasic punctuation.definition.variable.purebasic

  operators_logical:
    - match: '(?i)\b(And|Or|XOr|Not)\b{{following_pointer}}'
      captures:
        1: keyword.operator.word.purebasic
        3: variable.other.purebasic punctuation.definition.variable.purebasic

  #
  # Whatever can occur inside the parenthesis of a procedure declaration.
  #
  parameter_list_contents:
    - include: literals
    - include: keywords
    - include: types
    - include: punctuation
    - include: calls
    #
    # Function parameters should have a dedicated scope according to the Sublime Text documentation.
    #
    - match: '{{variables}}'
      captures:
        0: variable.parameter.purebasic
        1: punctuation.definition.variable.purebasic
        3: punctuation.definition.variable.purebasic
    - include: constants

  #
  # The "Array" and "List" keywords may appear in structure and interface definitions.
  # They must be matched before the generic variable pattern gets them.
  #
  parameter_keywords:
    - match: '\b(?i:Array|List)\b'
      scope: keyword.declaration.purebasic

  #
  # Generic parameter list of procedure declarations.
  #
  # Important: procedure implementation have their distinct context.
  #
  parameters:
    - meta_content_scope: meta.function.parameters.purebasic
    - match: '{{opening_parens}}'
      captures:
        1: punctuation.section.parens.begin.purebasic
        2: variable.parameter.purebasic punctuation.definition.variable.purebasic
    - match: '\)'
      scope: punctuation.section.parens.end.purebasic
      pop: true
    - include: parameter_list_contents

  procedures:
    - meta_scope: meta.function.purebasic
    - match: '{{opening_parens}}'
      captures:
        1: punctuation.section.parens.begin.purebasic
        2: variable.parameter.purebasic punctuation.definition.variable.purebasic
      set: procedure_implementation_parameters
    - match: '\bEndProcedure\b'
      scope: keyword.other.purebasic
      pop: true
    - include: calls
    - include: comments
    - include: literals
    - include: declarations
    - include: keywords
    - include: types
    - include: punctuation
    - include: variables
    - include: constants

  #
  # This is a special context for the parameter list of procedure implementations.
  # The sublime text scope naming documentation requires a scope shift back to "procedures" in such case.
  # That would be wrong for other parameter lists like in interface blocks.
  #
  procedure_implementation_parameters:
    - meta_scope: meta.function.parameters.purebasic
    - match: '\)'
      scope: punctuation.section.parens.end.purebasic
      set: procedures
    - include: parameter_list_contents

  punctuation:
    - match: '(,){{following_pointer}}'
      captures:
        1: punctuation.separator.purebasic
        3: variable.other.purebasic punctuation.definition.variable.purebasic

    - match: '{{opening_parens}}'
      captures:
        1: punctuation.section.parens.begin.purebasic
        2: variable.other.purebasic punctuation.definition.variable

    - match: '\)'
      scope: punctuation.section.parens.end.purebasic

    - match: '\['
      scope: punctuation.section.brackets.begin.purebasic

    - match: '\]'
      scope: punctuation.section.brackets.end.purebasic

    #
    # Used for accessing members of a module.
    #
    - match: '::'
      scope: punctuation.accessor.purebasic

    #
    # Used for accessing structure fields.
    #
    - match: '(\\)({{variables}})'
      captures:
        1: punctuation.accessor.purebasic
        2: variable.other.member.purebasic
        5: punctuation.definition.variable.purebasic

  #
  # Commands in PureBasic are typically terminated by the end of the line.
  # However there is also the possibility to concatenate multiple commands in one line by using ":".
  #
  terminators:
    - match: ':'
      scope: punctuation.separator.purebasic
      pop: true
    - match: '$'
      pop: true

  types:
    - match: (\.)\s*(\w[\w-]*)
      captures:
        1: punctuation.separator.purebasic
        2: storage.type.purebasic

  variables:
    - match: '{{variables}}'
      captures:
        0: variable.other.purebasic
        1: punctuation.definition.variable.purebasic
        3: punctuation.definition.variable.purebasic