Makefile.sublime-syntax

%YAML 1.2
# http://www.sublimetext.com/docs/3/syntax.html
# https://www.gnu.org/software/make/manual/make.html
--- #---------------------------------------------------------------------------
# Converted from Makefile Improved by Kay-Uwe (Kiwi) Lorenz
# Includes a few improvement like special-target, a bit more shell command,
# better variable recognition, fix ifeq/ifneq missing highlight ...
# Rewritten by Raoul Wols on May 2017.
#
# All number references refer to the "Make manual" (see link above).
name: Makefile
scope: source.makefile
version: 2

file_extensions:
  - mk
  - mak
  - make

hidden_file_extensions:
  - GNUmakefile
  - Makefile
  - Makefile.am
  - Makefile.in
  - OCamlMakefile

first_line_match: |-
  (?xi:
    ^ \#! .* \bmake\b |                          # shebang
    ^ \s* \# .*? -\*- .*? \bmakefile\b .*? -\*-  # editorconfig
  )

#-------------------------------------------------------------------------------
variables:

  varassign: (\?|\+|::?)?=
  shellassign: '!='
  startdirective: ifn?(def|eq)
  include: '[s-]?include'
  ruleassign: :(?!=)
  function_call_token_begin: \$\$?\(

  # The big "rule lookahead". What we want to do here is detect if the
  # line that we are parsing is going to define a rule. So we need to check
  # if we have something of the form <rule-name> : <rule-prerequisites>
  # However matters become complicated by the fact that we can have arbitrary
  # variable substitutions anywhere. We try to remedy this by hacking in a
  # regex that matches up to four levels of nested parentheses, and ignores
  # whatever's inside the parentheses.
  nps0: '[^()=]*'     # doesn't look like assignment
  nps: '[^()]*'
  open: '(?:\('
  close: '\))?'       # ignore this invalid.illegal
  just_eat: |         # WARNING: INSANITY FOLLOWS!
    (?x)              # ignore whitespace in this regex
      {{nps0}}        #       level 0
      {{open}}        # start level 1                      __
        {{nps}}       #       level 1          _______    /*_>-<
        {{open}}      # start level 2      ___/ _____ \__/ /
          {{nps}}     #       level 2     <____/     \____/
          {{open}}    # start level 3     is like snek... (by Valerie Haecky)
            {{nps}}   #       level 3
            {{open}}  # start level 4
              {{nps}} #       level 4
            {{close}} #   end level 4
            {{nps}}   #       level 3
          {{close}}   #   end level 3
          {{nps}}     #       level 2
          {{open}}    # start level 3
            {{nps}}   #       level 3
            {{open}}  # start level 4
              {{nps}} #       level 4
            {{close}} #   end level 4
            {{nps}}   #       level 3
          {{close}}   #   end level 3
          {{nps}}     #       level 2
        {{close}}     #   end level 2
        {{nps}}       #       level 1
        {{open}}      # start level 2
          {{nps}}     #       level 2
          {{open}}    # start level 3
            {{nps}}   #       level 3
            {{open}}  # start level 4
              {{nps}} #       level 4
            {{close}} #   end level 4
            {{nps}}   #       level 3
          {{close}}   #   end level 3
          {{nps}}     #       level 2
          {{open}}    # start level 3
            {{nps}}   #       level 3
            {{open}}  # start level 4
              {{nps}} #       level 4
            {{close}} #   end level 4
            {{nps}}   #       level 3
          {{close}}   #   end level 3
          {{nps}}     #       level 2
          {{open}}    # start level 3
            {{nps}}   #       level 3
            {{open}}  # start level 4
              {{nps}} #       level 4
            {{close}} #   end level 4
            {{nps}}   #       level 3
          {{close}}   #   end level 3
          {{nps}}     #       level 2
        {{close}}     #   end level 2
        {{nps}}       #       level 1
      {{close}}       #   end level 1
      {{nps0}}        #       level 0
  rule_lookahead: '{{just_eat}}{{ruleassign}}'

  # Just as with rules we want to look ahead if we are going to define a var.
  var_lookahead: '{{just_eat}}(?:{{varassign}}|{{shellassign}})'

#-------------------------------------------------------------------------------
contexts:

  # 3.1 What Makefiles Contain
  # Makefiles contain five kinds of things: explicit rules, implicit rules,
  # variable definitions, directives, and comments.
  main:
    - include: comments
    - match: (?={{rule_lookahead}})
      push: expect-rule
    - include: variable-definitions
    - include: variable-substitutions
    - include: control-flow
    - include: line-continuation
    - match: ^\s*(endef)
      captures:
        1: invalid.illegal.stray.endef.makefile

  inside-control-flow:
    - meta_scope: meta.group.makefile
    - match: "'"
      scope: punctuation.definition.string.begin.makefile
      push:
        - meta_scope: meta.string.makefile string.quoted.single.makefile
        - match: "'"
          scope: punctuation.definition.string.end.makefile
          pop: 1
        - include: escape-literals
        - include: line-continuation
        - include: variable-substitutions
    - match: '"'
      scope: punctuation.definition.string.begin.makefile
      push:
        - meta_scope: meta.string.makefile string.quoted.double.makefile
        - match: '"'
          scope: punctuation.definition.string.end.makefile
          pop: 1
        - include: escape-literals
        - include: line-continuation
        - include: variable-substitutions
    - match: \(
      scope: punctuation.section.group.begin.makefile
      push:
        - match: \)
          scope: punctuation.section.group.end.makefile
          pop: 1
        - include: variable-substitutions
        - match: \,
          scope: punctuation.separator.makefile
    - match: \)
      scope: invalid.illegal.stray.paren.makefile
    - include: continuation-or-pop-on-line-end

  control-flow:
    - match: ^\s*(vpath)\s
      captures:
        1: keyword.control.vpath.makefile
      push:
        - include: highlight-wildcard-sign
        - match: \s
          set:
            - meta_content_scope: meta.string.makefile string.unquoted.makefile
            - include: pop-on-line-end
        - include: pop-on-line-end
    - match: ^\s*(vpath)$
      captures: keyword.control.vpath.makefile
    - match: ^\s*({{include}})\s+
      captures:
        1: keyword.control.import.makefile
      push:
        - meta_content_scope: meta.string.makefile string.unquoted.makefile
        - include: continuation-or-pop-on-line-end
        - include: variable-substitutions
        - include: comments
    - match: \b{{startdirective}}\b
      scope: keyword.control.conditional.makefile
      push: inside-control-flow
    - match: ^\s*(else)\b
      captures:
        1: keyword.control.conditional.makefile
      push:
        - include: control-flow
        - include: comments
        - include: pop-on-line-end
    - match: ^\s*(endif)\b
      captures:
        1: keyword.control.conditional.makefile
      push:
        - include: comments
        - include: pop-on-line-end

  highlight-percentage-sign:
    - match: \%
      scope: variable.language.makefile

  highlight-wildcard-sign:
    - match: \*
      scope: constant.other.wildcard.asterisk.makefile

  expect-rule:
    # Anything before the colon is part of the rule's name.
    - meta_scope: meta.function.makefile entity.name.function.makefile
    - include: line-continuation
    - include: variable-substitutions
    - include: highlight-percentage-sign
    - match: (?= *::?[^=]+[!:?]?=)
      set:
        - match: ::?
          scope: keyword.operator.assignment.makefile
          set:
            - include: variable-definitions
            - include: variable-substitutions
            - include: continuation-or-pop-on-line-end
    - match: (?= *::?)
      set:
        - match: (::?)\s*
          captures:
            1: keyword.operator.assignment.makefile
          set:
            - meta_content_scope:
                meta.function.arguments.makefile
                string.unquoted.makefile
            - include: line-continuation
            - include: variable-substitutions
            - include: highlight-percentage-sign
            - match: (?=#)
              set:
                - match: \#
                  scope: punctuation.definition.comment.makefile
                  set:
                    - meta_scope: comment.line.number-sign.makefile
                    - match: $
                      set: recipe-junction-between-spaces-or-tabs
            - match: $
              set: recipe-junction-between-spaces-or-tabs
            - match: (?=\s*;)
              set:
                - match: ;
                  scope: punctuation.terminator.makefile
                  set: recipe-inline

  recipe-junction-between-spaces-or-tabs:
    - meta_content_scope: meta.function.body.makefile
    - include: comments
    - match: ^\s*({{startdirective}})
      captures:
        1: keyword.control.conditional.makefile
      push:
        - include: inside-control-flow
        - include: recipe-junction-between-spaces-or-tabs
    - match: ^(?=[ ]+([-@]{1,2})?)
      set: recipe-with-spaces
    - match: ^(?=\t([-@]{1,2})?)
      set: recipe-with-tabs
    - match: ^
      pop: 1

  recipe-inline:
    - meta_content_scope: meta.function.body.makefile source.shell.embedded.makefile
    - include: recipe-junction-between-spaces-or-tabs
    - include: control-flow
    - match: $
      set: recipe-junction-between-spaces-or-tabs
    - include: shell-content

  recipe-with-spaces:
    - meta_content_scope: meta.function.body.makefile
    - match: ^([ ]+)([-@]{1,2})?
      captures:
        2: constant.language.makefile
      push: shell-common
    - match: ^(\t)([-@]{1,2})?
      captures:
        1: invalid.illegal.inconsistent.expected.spaces.makefile
        2: constant.language.makefile
    - include: recipe-common
    - match: ^(?![ ]+)
      pop: 1

  recipe-with-tabs:
    - meta_content_scope: meta.function.body.makefile
    - match: ^\t([-@]{1,2})?
      captures:
        1: constant.language.makefile
      push: shell-common
    - match: ^([ ]+)([-@]{1,2})?
      captures:
        1: invalid.illegal.inconsistent.expected.tab.makefile
        2: constant.language.makefile
    - include: recipe-common
    - match: ^(?!\t)
      pop: 1

  recipe-common:
    - include: control-flow
    - match: ^\n

  shell-common:
    - meta_content_scope: source.shell.embedded.makefile
    - include: pop-on-line-end
    - include: shell-content

  shell-content:
    - include: Packages/Makefile/Embeddings/Shell (for Makefile).sublime-syntax
      apply_prototype: true

  line-continuation:
    - match: (\\)([ ]*)$\n?
      captures:
        1: punctuation.separator.continuation.line.makefile
      # make sure to resume parsing at next line
      push:
        - match: (?=\S|^\s*$)
          pop: 1

  pop-on-line-end:
    - match: $
      pop: 1

  continuation-or-pop-on-line-end:
    - include: line-continuation
    - include: pop-on-line-end

  quoted-string:
    - match: "'"
      scope: punctuation.definition.string.begin.makefile
      push:
        - meta_include_prototype: false
        - meta_scope: meta.string.makefile string.quoted.single.makefile
        - match: "'"
          scope: punctuation.definition.string.end.makefile
          pop: 1
        - include: escape-literals
        - include: line-continuation
        - include: variable-substitutions
    - match: '"'
      scope: punctuation.definition.string.begin.makefile
      push:
        - meta_include_prototype: false
        - meta_scope: meta.string.makefile string.quoted.double.makefile
        - match: '"'
          scope: punctuation.definition.string.end.makefile
          pop: 1
        - include: escape-literals
        - include: line-continuation
        - include: variable-substitutions

  escape-literals:
    - match: \\.
      scope: constant.character.escape.makefile

  comments:
    # This hack is here in order to circumvent false-positives for the big
    # rule lookahead. For example, if this match is not present, then things
    # like
    #
    #     # A comment with a : colon
    #
    # will match the rule-lookahead.
    - match: (?=^\s*#)
      push: comment
    # This is the "normal" comment parsing logic, but not sufficient in every
    # case (see above).
    - match: \#
      scope: punctuation.definition.comment.makefile
      push: comment-body

  comment:
    - match: \#
      scope: punctuation.definition.comment.makefile
      set: comment-body

  comment-body:
    - meta_scope: comment.line.number-sign.makefile
    - include: line-continuation
    - match: \\\\
    - match: \n
      pop: 1

  inside-function-call:
    - meta_content_scope: meta.function-call.arguments.makefile
    - match: \)
      scope: keyword.other.block.end.makefile
      pop: 1
    - match: \(
      push: textual-parenthesis-balancer
    - match: \,
      scope: punctuation.separator.makefile
    # eat escaped or unbalanced quotation marks in front of the `,` separator
    # to highlight them as ordinary part of the surrounding unquoted string
    - match: '\\[''""]|[''""](?=\s*,)'
    - include: variable-substitutions
    - include: quoted-string

  function-invocations:
    - match: ({{function_call_token_begin}})(call)\s
      captures:
        0: meta.function-call.makefile
        1: keyword.other.block.begin.makefile
        2: constant.language.call.makefile
      push:
        - meta_content_scope:
            meta.function-call.makefile
            variable.function.makefile
        - match: (?=\))
          set: inside-function-call
        - match: (?=,)
          set:
            - meta_content_scope: meta.function-call.makefile
            - match: \,
              scope: punctuation.separator.makefile
              set: inside-function-call
        - include: variable-substitutions
    - match: ({{function_call_token_begin}})(patsubst|filter)\s
      captures:
        0: meta.function-call.makefile
        1: keyword.other.block.begin.makefile
        2: support.function.builtin.makefile
      push:
        - meta_content_scope: meta.function-call.arguments.makefile
        - include: highlight-percentage-sign
        - include: inside-function-call
    - match: ({{function_call_token_begin}})(wildcard)\s
      captures:
        0: meta.function-call.makefile
        1: keyword.other.block.begin.makefile
        2: support.function.builtin.makefile
      push:
        - meta_content_scope: meta.function-call.arguments.makefile
        - include: inside-function-call
        - include: highlight-wildcard-sign
    - match: ({{function_call_token_begin}})(info|warning|error)\s
      captures:
        0: meta.function-call.makefile
        1: keyword.other.block.begin.makefile
        2: support.function.builtin.makefile
      push:
        - meta_content_scope: meta.function-call.arguments.makefile
        - match: \)
          scope: keyword.other.block.end.makefile
          pop: 1
        - match: \(
          push: textual-parenthesis-balancer
        - match: \,
          scope: punctuation.separator.makefile
        - include: variable-substitutions
    - match: | # multiline string
        (?x)   # ignore whitespace
        ({{function_call_token_begin}})
          (
            subst|
            strip|
            findstring|
            filter-out|
            sort|
            word|
            wordlist|
            words|
            firstword|
            lastword|
            dir|
            notdir|
            suffix|
            basename|
            addsuffix|
            addprefix|
            join|
            realpath|
            abspath|
            if|
            or|
            and|
            foreach|
            file|
            value|
            eval|
            origin|
            flavor|
            guile
          )
          \s
      captures:
        0: meta.function-call.makefile
        1: keyword.other.block.begin.makefile
        2: support.function.builtin.makefile
      push: inside-function-call
    - match: ({{function_call_token_begin}})(shell)\s
      captures:
        1: keyword.other.block.begin.makefile
        2: support.function.builtin.makefile
      push:
        - meta_content_scope: source.shell.embedded.makefile
        - match: \)
          scope: keyword.other.block.end.makefile
          pop: 1
        - include: shell-content

  variable-definitions:
    - match: \s*(override)\b
      captures:
        1: keyword.control.makefile
    - match: \s*(define)\b
      captures:
        1: keyword.control.makefile
      push: inside-define-directive-context
    - match: ^\s*(export)\b
      captures:
        1: keyword.control.makefile
      push:
        - meta_content_scope: variable.other.makefile
        - include: continuation-or-pop-on-line-end
        - include: variable-substitutions
        - match: (\?|\+|::?)?=
          scope: keyword.operator.assignment.makefile
          set: [value-to-be-defined, eat-whitespace-then-pop]
    - match: (?={{var_lookahead}})
      push:
        - meta_content_scope: variable.other.makefile
        - match: (?=\s*!=)
          set:
            - match: '!='
              scope: keyword.operator.assignment.makefile
              set: shell-common
        - match: (?=\s*(!|\?|\+|::?)?=)
          set:
            - match: (!|\?|\+|::?)?=
              scope: keyword.operator.assignment.makefile
              set: [value-maybe-shellscript, eat-whitespace-then-pop]
            - include: variable-substitutions
            - include: continuation-or-pop-on-line-end
        - include: variable-substitutions

  textual-parenthesis-balancer:
    - match: \)
      pop: 1
    - include: variable-substitutions

  eat-whitespace-then-pop:
    - clear_scopes: 1
    - match: \s*
      pop: 1

  value-maybe-shellscript:
    - match: ((?:bash|sh|zsh)\s+-c\s+)(['"`])
      captures:
        1: meta.string.makefile string.unquoted.makefile
        2: meta.string.makefile meta.interpolation.makefile punctuation.section.interpolation.begin.makefile
      embed: shell-content
      embed_scope: meta.string.makefile meta.interpolation.makefile source.shell.embedded.makefile
      escape: (?!<\\)\2
      escape_captures:
        0: meta.string.makefile meta.interpolation.makefile punctuation.section.interpolation.end.makefile
    - match: ''
      set: value-to-be-defined

  value-to-be-defined:
    - meta_content_scope: meta.string.makefile string.unquoted.makefile
    - include: escape-literals
    - match: (?=#)
      set: comment
    - include: variable-substitutions
    - include: continuation-or-pop-on-line-end

  inside-define-directive-context:
    - meta_content_scope: variable.other.makefile
    - match: (?=(!|\?|\+|::?)?=\s*\n)
      set:
        - match: ((!|\?|\+|::?)?=)\s*\n
          captures:
            1: keyword.operator.assignment.makefile
          set: inside-define-directive-value

    # Need to eat the actual newline character in order to start the
    # string.unquoted scope on the next line.
    - match: \n
      set: inside-define-directive-value
    - include: variable-substitutions

  inside-define-directive-value:
    - meta_content_scope: meta.string.makefile string.unquoted.makefile
    - match: ^\s*(endef)\b
      captures:
        1: keyword.control.makefile
      pop: 1
    # keep in balance with nested define statements
    # see: https://github.com/sublimehq/Packages/issues/1998
    - match: ^\s*define\b
      push:
        - match: ^\s*endef\b
          pop: 1

  variable-substitution-common:
    - match: ':'
      scope: punctuation.definition.substitution.makefile
      pop: 1
    - include: highlight-percentage-sign
    - include: variable-substitutions

  variable-substitution-name-inside-paren:
    - meta_content_scope: variable.parameter.makefile
    - match: \)
      scope: keyword.other.block.end.makefile
      pop: 2
    - include: variable-substitution-common

  variable-substitution-reference-inside-paren:
    - meta_scope: meta.interpolation.makefile
    - match: \)
      scope: keyword.other.block.end.makefile
      pop: 1
    - include: variable-substitution-reference-common

  variable-substitution-name-inside-brace:
    - meta_content_scope: variable.parameter.makefile
    - match: \}
      scope: keyword.other.block.end.makefile
      pop: 2
    - include: variable-substitution-common

  variable-substitution-reference-inside-brace:
    - meta_scope: meta.interpolation.makefile
    - match: \}
      scope: keyword.other.block.end.makefile
      pop: 1
    - include: variable-substitution-reference-common

  variable-substitution-reference-common:
    - match: =
      scope: keyword.operator.assignment.makefile
    - include: highlight-percentage-sign
    - include: variable-substitutions

  variable-substitutions:
    - include: function-invocations
    - match: \$\(
      scope: keyword.other.block.begin.makefile
      push:
        - variable-substitution-reference-inside-paren
        - variable-substitution-name-inside-paren
    - match: \${
      scope: keyword.other.block.begin.makefile
      push:
        - variable-substitution-reference-inside-brace
        - variable-substitution-name-inside-brace
    - match: \$\$?[@%<?^+|*]
      scope: variable.language.automatic.makefile
    - match: \$(?=\$[{\w])
      scope: constant.character.escape.makefile
      push:
        - include: scope:source.shell.bash#parameter-expansions
        - match: ''
          pop: 1
    - match: \$(?=\$\()
      scope: constant.character.escape.makefile
      push:
        - include: scope:source.shell.embedded.makefile#command-expansions
        - match: ''
          pop: 1
    - match: (\$)[[:alpha:]]
      captures:
        0: variable.parameter.makefile
        1: keyword.other.single-character-variable.makefile