scarpet.sublime-syntax

%YAML 1.2
---
# See http://www.sublimetext.com/docs/syntax.html
name: Scarpet
scope: source.scarpet
version: 2

extends:
  - Packages/Regular Expressions/RegExp (Basic).sublime-syntax
  - scarpet_strfmt.sublime-syntax

file_extensions:
  - sc
  - scl

variables:
  # Identifiers
  break: (?!{{id_char}})
  identifier: (?![^{{id_char}}]){{id}}
  id: (?:{{id_first_char}}{{id_char}}*)
  id_first_char: '[\p{L}_$]'
  id_char: '[\p{L}\p{N}_$]'
  strftime_spec: '(?:%(?:[aAwdbBGmyYHIpMSfzZjuUVWcxX%]|-[dmHIMSj]))'

  digits: (?:\d+(?:_\d+)*)
  exponent: (?:[eE][-+]?{{digits}})
  literal_variables: |-
    \b(?x:
      _|_a|_i|_x|_y|_z|_trace
    )\b
  builtin_types: |-
    \b(?x:
      bool|number|str|task|m|l
      #|string|list|map|iterator|function <- types not directly accessible

      |block|nbt
      #|text|entityn <- types not directly accessible
    )\b
  builtin_functions: |-
    \b(?x:
      # operator
      get|put|delete|has
      |sum|difference|product|quotient
      |equal|unique|increasing|decreasing|nondecreasing|nonincreasing
      |and|or

      |abs|acos|acosh|acot|all|and|asin|asinh|atan|atan2|atanh
      |bitwise_and|bitwise_or|bitwise_xor|bitwise_shift_left
      |bitwise_shift_right|bitwise_roll_left|bitwise_roll_right
      |bitwise_not|bitwise_popcount|bool|break|call|ceil|c_for
      |continue|copy|cos|cosh|cot|coth|csc|csch|deg
      |double_to_long_bits|exit|fact
      |filter|first|floor|for|hash_code|if|import
      |join|keys|l|length|log|log10|log1p
      |long_bits_to_double|loop|lower|m|mandelbrot|map|max|min
      |not|number|or|outer|pairs
      |perlin|print|profile_expr|rad|rand
      |range|reduce|relu|replace|replace_first|reset_seed|return
      |round|sec|sech|simplex|sin|sinh|sleep|slice|sort|sort_key
      |synchronize|system_variable_get|system_variable_set
      |split|sqrt|str|tan|tanh|task|task_completed|task_count
      |task_dock|task_join|task_thread|task_value|then|throw
      |time|title|try|type|undef|upper|values|var|vars
      |while|air|add_chunk_ticket|biome|blast_resistance|block
      |block_data|block_light|block_list|block_sound|block_state
      |block_tick|block_tags|blocks_daylight|blocks_movement
      |bossbar|brightness|chunk_tickets|convert_date
      |crafting_remaining_item|create_datapack|create_explosion
      |create_marker|current_dimension|day_time|delete_file
      |destroy|diamond|display_title|draw_shape|drop_item
      |emitted_light|enable_hidden_dimensions|encode_nbt
      |entity_area|entity_event|entity_id|entity_list
      |entity_load_handler|entity_selector|entity_types
      |escape_nbt|flammable|format|game_tick|generation_status
      |handle_event|hardness|harvest|in_dimension|in_slime_chunk
      |inhabited_time|inventory_find|inventory_get
      |inventory_remove|inventory_set|inventory_size|item_category
      |item_list|item_tags|last_tick_times|light|liquid|list_files
      |load_app_data|loaded|loaded_status|logger|map_colour
      |material|modify|nbt|nbt_storage|neighbours|opacity|parse_nbt
      |particle|particle_line|particle_rect|place_item|player|plop
      |poi|pos|pos_offset|power|query|random_tick|recipe_data|rect
      |reload_chunk|remove_all_markers|reset_chunk|run|sample_noise
      |save|scan|schedule|scoreboard|scoreboard_add
      |scoreboard_remove|scoreboard_display|scoreboard_property
      |tag_matches|team_add|team_leave|team_list|team_property
      |team_remove|read_file|see_sky|set|set_biome|set_poi
      |set_structure|signal_event|sky_light|solid|sound|spawn
      |spawn_potential|stack_limit|statistic|store_app_data
      |structures|structure_eligibility|structure_references
      |suffocates|system_info|tick_time|ticks_randomly|top
      |transparent|update|unix_time|view_distance|volume
      |without_updates|world_time|write_file

      |__command|__config|__on_chunk_generated|__on_chunk_loaded
      |__on_close|__on_player_attacks_entity|__on_player_breaks_block
      |__on_player_clicks_block|__on_player_changes_dimension
      |__on_player_chooses_recipe|__on_player_collides_with_entity
      |__on_player_deploys_elytra|__on_player_drops_item
      |__on_player_drops_stack|__on_player_finishes_using_item
      |__on_player_interacts_with_block
      |__on_player_interacts_with_entity|__on_player_jumps
      |__on_player_picks_up_item|__on_player_places_block
      |__on_player_releases_item|__on_player_rides
      |__on_player_right_clicks_block|__on_player_starts_sneaking
      |__on_player_starts_sprinting|__on_player_stops_sneaking
      |__on_player_stops_sprinting|__on_player_swings_hand
      |__on_player_switches_slot|__on_player_swaps_hands
      |__on_player_takes_damage|__on_player_trades|__on_player_uses_item
      |__on_player_wakes_up|__on_player_escapes_sleep|__on_statistic
      |__on_start|__on_tick|__on_tick_ender|__on_tick_nether
      |__on_player_takes_damage|__on_player_deals_damage|__on_player_dies
      |__on_player_respawns|__on_player_disconnects|__on_player_connects
      |__on_explosion|__on_explosion_outcome
    )\b

contexts:
  main:
    - meta_include_prototype: false
    - match: ''
      push: scarpet

  scarpet:
    - include: statements
    - include: else-expressions

  statements:
    - include: member-statements

  member-statements:
    - include: blocks
    - include: illegal-punctuation-separator-comma

  expressions:
    - include: expressions-wo-variables
    - include: variables

  expressions-wo-variables:
    - include: literals
    - include: punctuations
    - include: comments
    - include: numbers
    - include: operators
    - include: list
    - include: map
    - include: strings

###[ OPERATORS ]################################################################

  operators:
    - match: '[+]='
      scope: keyword.operator.assignment.augmented.scarpet
    - match: '==|!=|<=|>=|<>|<|>'
      scope: keyword.operator.comparison.scarpet
    - match: '='
      scope: keyword.operator.assignment.scarpet
    - match: ->
      scope: invalid.illegal.arrow.scarpet
    - match: '[\+\-*/%^]'
      scope: keyword.operator.arithmetic.scarpet
    - match: '!|&&|\|\|'
      scope: keyword.operator.logical.scarpet
    - match: '~'
      scope: keyword.operator.match.scarpet
      set: variable-match-item-access
    - match: ':'
      scope: keyword.operator.get.scarpet

###[ PUNCTUATIONS ]#############################################################

  illegal-punctuation-separator-comma:
    - match: ','
      scope: invalid.illegal.stray.scarpet

  punctuation-separator-comma:
    - match: ','
      scope: punctuation.separator.comma.scarpet

  punctuation-terminator-semicolon:
    - match: ;
      scope: punctuation.terminator.scarpet

###[ STRINGS ]##################################################################

  strings:
    - include: single-quoted-strings
    - include: double-quoted-strings

  double-quoted-strings:
    # scarpet doesn't support double quoted strings
    - match: \"
      scope: invalid.illegal.not-a-str.scarpet
      push: double-quoted-strings-body

  double-quoted-strings-body:
    - meta_content_scope: invalid.illegal.not-a-str.scarpet
    - meta_include_prototype: false
    - match: \"
      scope: invalid.illegal.not-a-str.scarpet
      pop: 1
    - include: escaped-chars
    - include: string-placeholders
    - include: illegal-string-end
    - include: string-continuations

  single-quoted-strings:
    - match: \'
      scope: punctuation.definition.string.begin.scarpet
      push: single-quoted-string-body

  single-quoted-string-body:
    - meta_include_prototype: false
    - meta_scope: meta.string.scarpet string.quoted.single.scarpet
    - match: \'
      scope: punctuation.definition.string.end.scarpet
      pop: 1
    - include: escaped-chars
    - include: string-placeholders
    - include: illegal-string-end
    - include: string-continuations

  single-quoted-regex-strings:
    - match: \'
      scope: punctuation.definition.string.begin.scarpet
      push: single-quoted-regex-string-body

  single-quoted-regex-string-body:
    - meta_include_prototype: false
    - meta_scope: meta.string.scarpet string.quoted.single.scarpet
    - match: \'
      scope: punctuation.definition.string.end.scarpet
      pop: 1
    - match: ''
      embed: scope:source.regexp.basic
      escape: (?='|\n)

  single-quoted-format-string-body:
    - meta_include_prototype: false
    - meta_scope: meta.string.scarpet string.quoted.single.scarpet
    - match: \'
      scope: punctuation.definition.string.end.scarpet
      pop: 1
    - match: ''
      embed: scope:source.string-format.scarpet
      escape: (?='|\n)

  illegal-string-end:
    - match: \n
      scope: invalid.illegal.unclosed-string.scarpet
      set: after-expression

  string-continuations:
    - match: \\$
      scope: punctuation.separator.continuation.line.scarpet
      push:
        - meta_include_prototype: false
        - match: ^
          pop: 1

  after-expression:
    - match: ''
      pop: true

  string-placeholders:
    - match: |- # printf style
        (?x)
        %
          ( \( ({{identifier}}) \) )? # mapping key
          \#?            # alternate form
          0?             # pad with zeros
          \-?            # left-adjust
          \ ?            # implicit sign
          [+-]?          # sign
          (\d*|\*)       # width
          (\. (\d*|\*))? # precision
          [hlL]?         # length modifier (but ignored)
          [acdeEfFgGiorsuxX%]
      scope: constant.other.placeholder.scarpet
      captures:
        2: variable.other.placeholder.scarpet
    - match: '{{strftime_spec}}'
      scope: constant.other.placeholder.scarpet

  escaped-chars:
    - match: \\r
      # carrige return character is not supported
      scope: constant.character.escape.scarpet invalid.illegal.character.escape.scarpet
    - match: \\.
      scope: constant.character.escape.scarpet

###[ LITERALS ]#################################################################

  literals:
    - include: literal-strings
    - include: literal-numbers
    - include: literal-constants
    - include: literal-variables

  literal-variables:
    - match: '{{literal_variables}}\b'
      scope: variable.language.anonymous.scarpet

  literal-constants:
    - match: (false|true)\b
      scope: constant.language.boolean.scarpet
    - match: (euler|pi)\b
      scope: constant.language.anonymous.scarpet
    - match: (null)\b
      scope: constant.language.null.scarpet

  literal-numbers:
    # hexadecimal
    - match: \b(0[xX])(\h*)([lL])
      scope: meta.number.integer.hexadecimal.scarpet invalid.illegal.number.scarpet
      captures:
        1: constant.numeric.base.scarpet
        2: constant.numeric.value.scarpet
        3: constant.numeric.suffix.scarpet
    - match: \b(0[xX])((?:_?\h)+)
      scope: meta.number.integer.hexadecimal.scarpet
      captures:
        1: constant.numeric.base.scarpet
        2: constant.numeric.value.scarpet
    # octal
    - match: \b(0[oO]?)((?=[oO]|[0-7])[0-7]*)([lL])
      scope: meta.number.integer.octal.scarpet invalid.illegal.number.scarpet
      captures:
        1: constant.numeric.base.scarpet
        2: constant.numeric.value.scarpet
        3: constant.numeric.suffix.scarpet
    - match: \b(0)([0-7]+) # py2
      scope: meta.number.integer.octal.scarpet
      captures:
        1: constant.numeric.base.scarpet
        2: constant.numeric.value.scarpet
    - match: \b(0[oO])((?:_?[0-7])+)
      scope: meta.number.integer.octal.scarpet
             invalid.illegal.number.scarpet
      captures:
        1: constant.numeric.base.scarpet
        2: constant.numeric.value.scarpet
    # binary
    - match: \b(0[bB])([01]*)([lL]) # py2
      scope: meta.number.integer.binary.scarpet
             invalid.illegal.number.scarpet
      captures:
        1: constant.numeric.base.scarpet
        2: constant.numeric.value.scarpet
        3: constant.numeric.suffix.scarpet
    - match: \b(0[bB])((?:_?[01])*)
      scope: meta.number.integer.binary.scarpet
      captures:
        1: constant.numeric.base.scarpet
        2: constant.numeric.value.scarpet
    # complex
    - match: |-
        (?x)
        (
          # 1.j, 1.1j, 1.1e1j, 1.1e-1j, 1.e1j, 1.e-1 | 1e1j, 1e-1j
          \b{{digits}} (\.)? {{digits}}? {{exponent}}?
          # .1j, .1e1j, .1e-1j
          | (\.) {{digits}} {{exponent}}?
        )
        ([jJ])
      scope: meta.number.imaginary.decimal.scarpet invalid.illegal.number.scarpet
      captures:
        1: constant.numeric.value.scarpet
        2: punctuation.separator.decimal.scarpet
        3: punctuation.separator.decimal.scarpet
        4: constant.numeric.suffix.scarpet
    # floating point
    - match: |-
        (?x:
          # 1., 1.1, 1.1e1, 1.1e-1, 1.e1, 1.e-1 | 1e1, 1e-1
          \b{{digits}} (?: (\.) {{digits}}? {{exponent}}? | {{exponent}} )
          # .1, .1e1, .1e-1
          | (\.) {{digits}} {{exponent}}?
        )
      scope: meta.number.float.decimal.scarpet constant.numeric.value.scarpet
      captures:
        1: punctuation.separator.decimal.scarpet
        2: punctuation.separator.decimal.scarpet
    # integer
    - match: \b([1-9]\d*|0)([lL])\b # py2
      scope: meta.number.integer.decimal.scarpet invalid.illegal.number.scarpet
      captures:
        1: constant.numeric.value.scarpet
        2: constant.numeric.suffix.scarpet
    - match: \b([1-9][\d_]*|0)\b
      scope: meta.number.integer.decimal.scarpet constant.numeric.value.scarpet

###[ PRINT FUNCTIONS ]##########################################################

  print-function:
    - match: print\b
      scope: keyword.other.print.scarpet
      set: reference-function-call-arguments

###[ LOOP FUNCTIONS ]###########################################################

  loop-functions:
    - match: (while|loop|map|filter|first|all|c_for|for)\b
      scope: keyword.control.loop.scarpet
      set: reference-function-call-arguments

###[ IMPORT FUNCTIONS ]#########################################################

  import-function:
    - match: import\b
      scope: keyword.control.import.scarpet
      set: reference-function-call-arguments

###[ FLOW CONTROL FUNCTIONS ]###################################################

  flow-control-functions:
    - match: return\b
      scope: keyword.control.flow.return.scarpet
      set: reference-function-call-arguments
    - match: exit\b
      scope: keyword.control.flow.exit.scarpet
      set: reference-function-call-arguments
    - match: try\b
      scope: keyword.control.exception.try.scarpet
      set: reference-function-call-arguments
    - match: throw\b
      scope: keyword.control.flow.throw.scarpet
      set: reference-function-call-arguments
    - match: if\b
      scope: keyword.control.conditional.if.scarpet
      set: reference-function-call-arguments
    - match: break\b
      scope: keyword.control.flow.break.scarpet
      set: reference-function-call-arguments
    - match: continue\b
      scope: keyword.control.flow.continue.scarpet
      set: reference-function-call-arguments

###[ TYPE CONVERSION FUNCTIONS ] ###############################################

  type-conversion-functions:
    - match: '{{builtin_types}}'
      scope: support.type.scarpet
      set: reference-function-call-arguments

###[ STRING FORMAT FUNCTIONS ] #################################################

  string-format-function:
    - match: format\b
      scope: support.function.builtin.scarpet
      set: string-format-function-call-arguments

###[ COMMENTS ]#################################################################

  comments:
    - include: line-comment

  line-comment:
    - match: //+
      scope: punctuation.definition.comment.scarpet
      push: line-comment-body

  line-comment-body:
    - meta_include_prototype: false
    - meta_scope: comment.line.double-slash.scarpet
    - match: (//+)?\n
      captures:
        1: punctuation.definition.comment.scarpet
      pop: 1
###[ BLOCKS ]###################################################################

  block-or-expression:
    - include: block
    - include: else-expression

  block:
    - include: paren-block

  blocks:
    - include: paren-blocks

  paren-blocks:
    - match: \(
      scope: punctuation.section.block.begin.scarpet
      push: paren-block-body
    - include: stray-paren-block

  paren-block:
    - match: \(
      scope: punctuation.section.block.begin.scarpet
      set: paren-block-body

  paren-block-end:
    - match: \)
      scope: punctuation.section.block.end.scarpet
      pop: 1

  paren-block-body:
    - meta_scope: meta.block.scarpet
    - include: paren-block-end
    - include: blocks
    - include: expression

  stray-paren-block:
    - match: \)
      scope: invalid.illegal.stray.scarpet

###[ EXPRESSIONS ]##############################################################

  else-expressions:
    - match: (?=\S)
      push: expression

  else-expression:
    - match: (?=\S)
      set: expression

  expression:
    - include: expression-terminator
    - include: expressions

  expression-terminator:
    - meta_content_scope: punctuation.terminator.scarpet
    - match: (?=[,\]\}])
      pop: 1

###[ VARIABLES ]################################################################

  variables:
    - match: (?={{id_first_char}})
      branch_point: variables
      branch:
        - variable-other
        - function-call-identifier
        - function-declaration-identifier

  variable-other:
    - match: '{{id}}'
      scope: meta.variable.identifier.scarpet variable.other.scarpet
      set: variable-other-end
    - include: immediately-pop

  variable-other-end:
    - meta_content_scope: meta.variable.identifier.scarpet
    - match: \s*(\()
      fail: variables
    - include: else-pop

  else-pop:
    - match: (?=\S)
      pop: 1

  immediately-pop:
    - match: ''
      pop: 1

###[ CONTAINERS ]###############################################################

  list:
    - match: \[
      scope: punctuation.section.sequence.begin.scarpet
      push: list-body

  list-body:
    - meta_scope: meta.sequence.list.scarpet
    - match: \]
      scope: punctuation.section.sequence.end.scarpet
      pop: 1
    - include: punctuation-separator-comma
    - include: blocks
    - include: expression

  map:
    - match: \{
      scope: punctuation.section.mapping.begin.scarpet
      push: map-body

  map-body:
    - meta_scope: meta.mapping.scarpet
    - match: \}
      scope: punctuation.section.mapping.end.scarpet
      pop: 1
    - include: punctuation-separator-comma
    - match: (?=\S)
      push: map-key

  map-value:
    - clear_scopes: 1
    - meta_content_scope: meta.mapping.scarpet meta.mapping.value.scarpet
    - match: (?=[,\}])
      pop: 1
    - include: blocks
    - include: expression

  map-key-value-separator:
    - match: ->
      scope: meta.mapping.scarpet punctuation.separator.key-value.scarpet
      set: map-value

  map-key:
    - clear_scopes: 1
    - meta_content_scope: meta.mapping.scarpet meta.mapping.key.scarpet
    - match: (?=->)
      set: map-key-value-separator
    - include: blocks
    - include: expression-terminator
    - include: reference-expressions

  variable-match-item-access:
    - meta_scope: meta.variable.item-access.match.scarpet
    - match: \'
      scope: punctuation.definition.string.begin.scarpet
      set: single-quoted-regex-string-body
    - include: block-or-expression

###[ FUNCTIONS ]################################################################

  function-declaration-identifier:
    - match: '{{id}}'
      scope: entity.name.function.scarpet meta.function.identifier.scarpet
    - match: \(
      scope: punctuation.section.parameters.begin.scarpet
      set: function-declaration-parameters

  function-declaration-parameters:
    - meta_scope: meta.function.parameters.scarpet
    - match: \)
      scope: punctuation.section.parameters.end.scarpet
      set: define-as
    - include: punctuation-separator-comma
    - include: parameter

  define-as:
    - match: \s*->
      scope:
        keyword.declaration.function.arrow.scarpet meta.function.scarpet
      set: function-meta

  function-meta:
    - meta_content_scope: meta.function.scarpet
    - include: blocks
    - include: expression
    - include: else-pop

  function-call-identifier:
    - meta_scope: meta.function-call.identifier.scarpet variable.function.scarpet
    - include: builtin-functions
    - match: '{{id}}'
      set: function-call-arguments
    - include: immediately-pop

  function-call-arguments:
    - meta_content_scope: meta.function-call.arguments.scarpet
    - match: \(
      scope: punctuation.section.arguments.begin.scarpet
      set: function-call-arguments-body

  function-call-arguments-body:
    - meta_scope: meta.function-call.arguments.scarpet
    - match: \)
      scope: punctuation.section.arguments.end.scarpet
      set: function-call-arguments-end
    - include: punctuation-separator-comma
    - include: blocks
    - include: expression

  function-call-arguments-end:
    - match: \s*(->)
      fail: variables
    - include: else-pop

  builtin-functions:
    - include: loop-functions
    - include: import-function
    - include: flow-control-functions
    - include: print-function
    - include: type-conversion-functions
    - include: string-format-function
    - match: '{{builtin_functions}}'
      scope: support.function.builtin.scarpet
      set: function-call-arguments

###[ PARAMETERS ]###############################################################

  parameter:
    - match: '(?=\S)'
      branch_point: parameter-maybe-variadic
      branch:
        - parameter-identifier
        - parameter-variadic

  parameter-variadic:
    - match: \.\.\.
      scope: keyword.operator.unpacking.list.scarpet keyword.operator.unpacking.mapping.scarpet
      set: parameter-identifier

  parameter-identifier:
    - match: (?=\.\.\.)
      fail: parameter-maybe-variadic
    - match: '{{identifier}}'
      scope: variable.parameter.scarpet
      pop: 1

###[ PROTOTYPES ]###############################################################

  prototype:
    - include: comments

###[ REFERENCE EXPRESSIONS ]####################################################

  reference-expressions:
    - include: expressions-wo-variables
    - include: reference-variables

  reference-variables:
    - match: (?={{id_first_char}})
      branch_point: reference-variables
      branch:
        - reference-variable-other
        - reference-function-call-identifier

  reference-variable-other:
    - match: '{{id}}'
      scope: meta.variable.identifier.scarpet variable.other.scarpet
      set: reference-variable-other-end
    - include: immediately-pop

  reference-variable-other-end:
    - meta_content_scope: meta.variable.identifier.scarpet
    - match: \s*(\()
      fail: reference-variables
    - include: else-pop

  reference-function-call-identifier:
    - include: builtin-functions
    - match: '{{id}}'
      scope: meta.function-call.identifier.scarpet variable.function.scarpet
      set: reference-function-call-arguments

  reference-function-call-arguments:
    - meta_content_scope: meta.function-call.arguments.scarpet
    - match: \(
      scope: punctuation.section.arguments.begin.scarpet
      set: reference-function-call-arguments-body

  reference-function-call-arguments-body:
    - meta_scope: meta.function-call.arguments.scarpet
    - match: \)
      scope: punctuation.section.arguments.end.scarpet
      pop: 1
    - include: punctuation-separator-comma
    - include: blocks
    - include: reference-expressions

  string-format-function-call-arguments:
    - meta_content_scope: meta.function-call.arguments.scarpet
    - match: \(
      scope: punctuation.section.arguments.begin.scarpet
      set: string-format-function-call-arguments-body

  string-format-function-call-arguments-body:
    - meta_scope: meta.function-call.arguments.scarpet
    - match: \)
      scope: punctuation.section.arguments.end.scarpet
      pop: 1
    - include: punctuation-separator-comma
    - match: \'
      scope: punctuation.definition.string.begin.scarpet
      push: single-quoted-format-string-body
    - include: blocks
    - include: reference-expressions