GLSL.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
# https://www.khronos.org/registry/OpenGL/specs/gl/GLSLangSpec.4.50.pdf
name: GLSL
file_extensions:
  - vs
  - fs
  - gs
  - vsh
  - fsh
  - gsh
  - vshader
  - fshader
  - gshader
  - vert
  - frag
  - geom
  - tesc
  - tese
  - comp
  - glsl
  - mesh
  - task
  - rgen
  - rint
  - rahit
  - rchit
  - rmiss
  - rcall
first_line_match: -[*]-( Mode:)? GLSL -[*]-
scope: source.glsl

variables:
  identifier: \b[[:alpha:]_][[:alnum:]_]*\b
  non_func_keywords: if|for|switch|while
  before_tag: struct
  
  control_keywords: |
    (?x) # ignore whitespace in this regex
      break |
      case |
      continue |
      default |
      discard |
      do |
      else |
      for |
      if |
      return |
      switch |
      while

  basic_types: |
    (?x) # ignore whitespace in this regex
      \b(
        void |
        bool |
        int |
        uint |
        float |
        double |
        vec[2-4] |
        dvec[2-4] |
        bvec[2-4] |
        ivec[2-4] |
        uvec[2-4] |
        mat[2-4] |
        mat2x2 |
        mat2x3 |
        mat2x4 |
        mat3x2 |
        mat3x3 |
        mat3x4 |
        mat4x2 |
        mat4x3 |
        mat4x4 |
        dmat2 |
        dmat3 |
        dmat4 |
        dmat2x2 |
        dmat2x3 |
        dmat2x4 |
        dmat3x2 |
        dmat3x3 |
        dmat3x4 |
        dmat4x2 |
        dmat4x3 |
        dmat4x4 |
        sampler[1-3]D |
        image[1-3]D |
        samplerCube |
        imageCube |
        sampler2DRect |
        image2DRect |
        sampler[12]DArray |
        image[12]DArray |
        samplerBuffer |
        imageBuffer |
        sampler2DMS |
        image2DMS |
        sampler2DMSArray |
        image2DMSArray |
        samplerCubeArray |
        imageCubeArray |
        sampler[12]DShadow |
        sampler2DRectShadow |
        sampler[12]DArrayShadow |
        samplerCubeShadow |
        samplerCubeArrayShadow |
        isampler[1-3]D |
        iimage[1-3]D |
        isamplerCube |
        iimageCube |
        isampler2DRect |
        iimage2DRect |
        isampler[12]DArray |
        iimage[12]DArray |
        isamplerBuffer |
        iimageBuffer |
        isampler2DMS |
        iimage2DMS |
        isampler2DMSArray |
        iimage2DMSArray |
        isamplerCubeArray |
        iimageCubeArray |
        atomic_uint |
        usampler[1-3]D |
        uimage[1-3]D |
        usamplerCube |
        uimageCube |
        usampler2DRect |
        uimage2DRect |
        usampler[12]DArray |
        uimage[12]DArray |
        usamplerBuffer |
        uimageBuffer |
        usampler2DMS |
        uimage2DMS |
        usampler2DMSArray |
        uimage2DMSArray |
        usamplerCubeArray |
        uimageCubeArray
      )\b

  modifiers: |
    (?x) # ignore whitespace in this regex
      \b(
        layout |
        attribute |
        centroid |
        sampler |
        patch |
        const |
        flat |
        in |
        inout |
        invariant |
        noperspective |
        out |
        smooth |
        uniform |
        varying |
        buffer |
        shared |
        coherent |
        readonly |
        writeonly |
        volatile |
        restrict
      )\b
  
  reserved_keyword_for_future_use: |
    (?x) # ignore whitespace in this regex
      \b(?:
        common |
        partition |
        active |
        asm |
        class |
        union |
        enum |
        typedef |
        template |
        this |
        resource |
        goto |
        inline |
        noinline |
        public |
        static |
        extern |
        external |
        interface |
        long |
        short |
        half |
        fixed |
        unsigned |
        superp |
        input |
        output |
        hvec2 |
        hvec3 |
        hvec4 |
        fvec2 |
        fvec3 |
        fvec4 |
        sampler3DRect |
        filter |
        sizeof |
        cast |
        namespace |
        using
      )\b

contexts:
  main:
    - include: preprocessor-global
    - include: global

  comments:
    - match: ^/\* =(\s*.*?)\s*= \*/$\n?
      scope: comment.block.glsl
      captures:
        1: meta.toc-list.banner.block.glsl
    - match: /\*
      scope: punctuation.definition.comment.glsl
      push:
        - meta_scope: comment.block.glsl
        - match: \*/
          scope: punctuation.definition.comment.glsl
          pop: true
    - match: \*/(?!\*)
      scope: invalid.illegal.stray-comment-end.glsl
    - match: ^// =(\s*.*?)\s*=\s*$\n?
      scope: comment.line.banner.glsl
      captures:
        1: meta.toc-list.banner.line.glsl
    - match: //
      scope: punctuation.definition.comment.glsl
      push:
        - meta_scope: comment.line.double-slash.glsl
        - match: (\\)$\n
          captures:
            1: punctuation.separator.continuation.glsl
        - match: \n
          pop: true

  keywords:
    - match: \b({{control_keywords}})\b
      scope: keyword.control.glsl

  modifiers:
    - match: \b({{modifiers}})\b
      scope: storage.modifier.glsl

  variables:
    - match: |
        (?x) # ignore whitespace in this regex
          \bgl_(
            BackColor |
            BackLightModelProduct |
            BackLightProduct |
            BackMaterial |
            BackSecondaryColor |
            ClipDistance |
            ClipPlane |
            ClipVertex |
            Color |
            DepthRange |
            DepthRangeParameters |
            EyePlaneQ |
            EyePlaneR |
            EyePlaneS |
            EyePlaneT |
            Fog |
            FogCoord |
            FogFragCoord |
            FogParameters |
            FragColor |
            FragCoord |
            FragDat |
            FragDept |
            FrontColor |
            FrontFacing |
            FrontLightModelProduct |
            FrontLightProduct |
            FrontMaterial |
            FrontSecondaryColor |
            InstanceID |
            Layer |
            LightModel |
            LightModelParameters |
            LightModelProducts |
            LightProducts |
            LightSource |
            LightSourceParameters |
            MaterialParameters |
            ModelViewMatrix |
            ModelViewMatrixInverse |
            ModelViewMatrixInverseTranspose |
            ModelViewMatrixTranspose |
            ModelViewProjectionMatrix |
            ModelViewProjectionMatrixInverse |
            ModelViewProjectionMatrixInverseTranspose |
            ModelViewProjectionMatrixTranspose |
            MultiTexCoord[0-7] |
            Normal |
            NormalMatrix |
            NormalScale |
            ObjectPlaneQ |
            ObjectPlaneR |
            ObjectPlaneS |
            ObjectPlaneT |
            Point |
            PointCoord |
            PointParameters |
            PointSize |
            Position |
            PrimitiveIDIn |
            ProjectionMatrix |
            ProjectionMatrixInverse |
            ProjectionMatrixInverseTranspose |
            ProjectionMatrixTranspose |
            SecondaryColor |
            TexCoord |
            TextureEnvColor |
            TextureMatrix |
            TextureMatrixInverse |
            TextureMatrixInverseTranspose |
            TextureMatrixTranspose |
            Vertex |
            VertexID
          )\b
      scope: variable.language.glsl

  constants:
    - match: |
        (?x) # ignore whitespace in this regex
          \bgl_(
            MaxClipPlanes |
            MaxCombinedTextureImageUnits |
            MaxDrawBuffers |
            MaxFragmentUniformComponents |
            MaxLights |
            MaxTextureCoords |
            MaxTextureImageUnits |
            MaxTextureUnits |
            MaxVaryingFloats |
            MaxVertexAttribs |
            MaxVertexTextureImageUnits |
            MaxVertexUniformComponents
          )\b
      scope: support.constant.glsl

  functions-builtin:
    - match: |
        (?x) # ignore whitespace in this regex
          \b(
            abs |
            acos |
            all |
            any |
            asin |
            atan |
            ceil |
            clamp |
            cos |
            cross |
            degrees |
            dFdx |
            dFdy |
            distance |
            dot |
            equal |
            exp |
            exp2 |
            faceforward |
            floor |
            fract |
            ftransform |
            fwidth |
            greaterThan |
            greaterThanEqual |
            inversesqrt |
            length |
            lessThan |
            lessThanEqual |
            log |
            log2 |
            matrixCompMult |
            max |
            min |
            mix |
            mod |
            noise[1-4] |
            normalize |
            not |
            notEqual |
            outerProduct |
            pow |
            radians |
            reflect |
            refract |
            shadow1D |
            shadow1DLod |
            shadow1DProj |
            shadow1DProjLod |
            shadow2D |
            shadow2DLod |
            shadow2DProj |
            shadow2DProjLod |
            sign |
            sin |
            smoothstep |
            sqrt |
            step |
            tan |
            texture |
            texture1D |
            texture1DLod |
            texture1DProj |
            texture1DProjLod |
            texture2D |
            texture2DLod |
            texture2DProj |
            texture2DProjLod |
            texture3D |
            texture3DLod |
            texture3DProj |
            texture3DProjLod |
            textureCube |
            textureCubeLod |
            transpose
          )\b
      scope: support.function.glsl

  types:
    - match: \b({{basic_types}}|{{before_tag}})\b
      scope: storage.type.glsl
  numbers:
    - match: \b((0(x|X)[0-9a-fA-F]*(\.[0-9a-fA-F]+p-?\d+)?)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)([fF]|(l{1,2}|L{1,2})[uU]?|[uU](l{0,2}|L{0,2}))?\b
      scope: constant.numeric.glsl

  operators:
    - match: \+\=|-\=|\*\=|/\=|%\=|&\=|\|\=|\^\=|>>\=|<<\=
      scope: keyword.operator.assignment.augmented.glsl
    - match: \+|\-|/|%|<<|>>|&&|\|\||\||\^|~|!
      scope: keyword.operator.arithmetic.glsl
    - match: <\=|>\=|\=\=|<|>|\!\=
      scope: keyword.operator.comparison.glsl
    - match: \*|&
      scope: keyword.operator.glsl
    - match: \=
      scope: keyword.operator.assignment.glsl

  access:
    - match: (\.)({{identifier}})(?!\s*\()
      captures:
        1: punctuation.accessor.glsl
        2: variable.other.member.glsl

  preprocessor-disabled:
    - match: ^\s*(#\s*if(n?def)?)\b
      captures:
        1: meta.preprocessor.glsl
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.glsl
          pop: true
        - include: preprocessor-disabled
        - include: pragma-mark
    - include: pragma-mark

  preprocessor-line-continuation:
    - match: (\\)$\n
      captures:
        1: punctuation.separator.continuation.glsl
    - match: \\(\s+?)$
      captures:
        1: invalid.illegal.space-after-continuation.glsl

  preprocessor-line-ending:
    - match: $\n
      pop: true

  # Comment handling in preprocessor directives are complicated by the fact
  # that a single-line comment will normally consume the newline to prevent
  # completions from being presented to the user. Additionally, a multi-line
  # comment without a line continuation ends at the newline.
  preprocessor-comments:
    - match: /\*
      scope: punctuation.definition.comment.glsl
      push:
        - meta_scope: comment.block.glsl
        - match: '\\$\n'
          scope: punctuation.separator.continuation.glsl
        - match: \*/
          scope: punctuation.definition.comment.glsl
          pop: true
    - match: //
      scope: punctuation.definition.comment.glsl
      push:
        - meta_scope: comment.line.double-slash.glsl
        - match: (\\)$\n
          captures:
            1: punctuation.separator.continuation.glsl
          pop: true
        - match: (?=\n)
          pop: true

  pragma-mark:
    - match: ^\s*((#\s*pragma\s+mark)\s+(.*))
      scope: meta.section.glsl
      captures:
        1: meta.preprocessor.glsl
        2: keyword.control.import.pragma.glsl
        3: meta.toc-list.pragma-mark.glsl

  # Used by "inc" snippets to prevent double ##include
  incomplete-inc:
    - match: ^\s*(#i(nc?)?)\b\s*
      scope: meta.preprocessor.incomplete.glsl

  global:
    - include: early-expressions
    - match: ^\s*(?=\w+)
      push: global-modifier
    - include: late-expressions

  statements:
    - include: preprocessor-statements
    - include: expressions

  expressions:
    - include: early-expressions
    - include: late-expressions

  early-expressions:
    - include: preprocessor-expressions
    - include: comments
    - include: case-default
    - include: access
    - include: typedef
    - include: keywords
    - include: numbers
    - include: operators
    - include: parens
    - include: brackets
    - include: block
    - include: variables
    - include: constants
    - match: \,
      scope: punctuation.separator.glsl
    - match: '[)}]'
      scope: invalid.illegal.stray-bracket-end.glsl
    - match: '{{reserved_keyword_for_future_use}}'
      scope: invalid.illegal.reserved-keyword.glsl

  late-expressions:
    - include: modifiers
    - include: types
    - include: function-call
    - match: ';'
      scope: punctuation.terminator.glsl

  global-modifier:
    - include: comments
    - include: modifiers
    - match: (?=\S)
      set: global-type

  global-type:
    - include: comments
    - match: \*
      scope: keyword.operator.glsl
    # If a struct followed by a name that is not a macro or declspec
    # then this is likely a return type of a function. This is uncommon.
    - match: |-
        (?x:
          ({{before_tag}})
          \s+
          (?=
            (?![[:upper:][:digit:]_]+\b|__declspec)
            {{identifier}}
            (\s+{{identifier}}(?!\s*[{=;])|\s*\*+)
          )
        )
      captures:
        1: storage.type.glsl
      set: global-maybe-function
    # The previous match handles return types of struct from a func,
    # there this one exits the context to allow matching an actual struct
    - match: (?=\b({{before_tag}})\b)
      set: data-structures
    - match: (?=\b({{control_keywords}})\b)
      pop: true
    - match: (?=\s)
      set: global-maybe-function
    # Allow a macro call
    - match: ({{identifier}})\s*(\()(?=[^\)]+\))
      captures:
        1: variable.function.glsl
        2: meta.group.glsl punctuation.section.group.begin.glsl
      push:
        - meta_scope: meta.function-call.glsl
        - meta_content_scope: meta.group.glsl
        - match: \)
          scope: meta.group.glsl punctuation.section.group.end.glsl
          pop: true
        - include: expressions
    - match: (?={{identifier}}\s*\()
      set:
        - include: function-call
        - match: ''
          pop: true
    - include: types
    - match: '{{identifier}}'
    - match: (?=\W)
      pop: true

  global-maybe-function:
    - include: comments
    # Consume pointer info, macros and any type info that was offset by macros
    - match: \*
      scope: keyword.operator.glsl
    - include: types
    - include: modifiers
    # All uppercase identifier just before a newline is most likely a macro
    - match: '[[:upper:][:digit:]_]+\s*$'
    # Identifier that is not the function name - likely a macro
    - match: '{{identifier}}(?!\s*(\(|$))(?=\s+)'
    # Real function definition
    - match: '{{identifier}}(?=\s*(\(|$))'
      scope: meta.function.glsl entity.name.function.glsl
      set: function-definition-params
    - match: (?=\S)
      pop: true

  function-definition-params:
    - meta_content_scope: meta.function.glsl
    - include: comments
    - match: (?=\()
      set:
        - match: \(
          scope: meta.function.parameters.glsl meta.group.glsl punctuation.section.group.begin.glsl
          set:
            - meta_content_scope: meta.function.parameters.glsl meta.group.glsl
            - match : \)
              scope: punctuation.section.group.end.glsl
              set: function-definition-continue
            - match: \bvoid\b
              scope: storage.type.glsl
            - match: '{{identifier}}(?=\s*(\[|,|\)))'
              scope: variable.parameter.glsl
            - include: expressions
    - match: (?=\S)
      pop: true

  function-definition-continue:
    - meta_content_scope: meta.function.glsl
    - include: comments
    - match: (?=;)
      pop: true
    - match: \b(const|final|noexcept|override)\b
      scope: storage.modifier.glsl
    - match: (?={)
      set: function-definition-body
    - match: (?=\S)
      pop: true

  function-definition-body:
    - meta_content_scope: meta.function.glsl
    - match: \{
      scope: meta.block.glsl punctuation.section.block.begin.glsl
      set:
        - meta_content_scope: meta.function.glsl meta.block.glsl
        - match: \}
          scope: meta.function.glsl meta.block.glsl punctuation.section.block.end.glsl
          pop: true
        - match: (?=^\s*#\s*(elif|else|endif)\b)
          pop: true
        - match: (?=({{before_tag}})([^(;]+$|.*{))
          push: data-structures
        - include: statements

  data-structures:
    # Detect variable type definitions using struct followed by a tag
    - match: \b({{before_tag}})(?=\s+{{identifier}}\s+{{identifier}}\s*[=;\[])
      scope: storage.type.glsl
    - match: \bstruct\b
      scope: storage.type.glsl
      set: data-structures-struct-definition
    - match: (?=\S)
      pop: true

  data-structures-struct-definition:
    - meta_scope: meta.struct.glsl
    - include: data-structures-definition-common-begin
    - match: '{{identifier}}(?=\s*;)'
      scope: entity.name.struct.forward-decl.glsl
    - match: '{{identifier}}'
      scope: entity.name.struct.glsl
    - match: (?=;)
      pop: true
    - match: \{
      scope: meta.block.glsl punctuation.section.block.begin.glsl
      set:
        - meta_content_scope: meta.struct.glsl meta.block.glsl
        - match: \}
          scope: meta.struct.glsl meta.block.glsl punctuation.section.block.end.glsl
          pop: true
        - include: data-structures-body

  data-structures-definition-common-begin:
    - include: comments
    - match: (?=\b(?:{{before_tag}}|{{control_keywords}})\b)
      pop: true
    - include: modifiers
    # Handle macros so they aren't matched as the class name
    - match: \b[[:upper:][:digit:]_]+\b

  data-structures-definition-common-end:
    - match: (?=;)
      pop: true

  data-structures-body:
    - include: preprocessor-data-structures
    - match: (?={{before_tag}})
      push: data-structures
    - include: expressions

  block:
    - match: \{
      scope: punctuation.section.block.begin.glsl
      push:
        - meta_scope: meta.block.glsl
        - match: (?=^\s*#\s*(elif|else|endif)\b)
          pop: true
        - match: \}
          scope: punctuation.section.block.end.glsl
          pop: true
        - include: statements

  parens:
    - match: \(
      scope: punctuation.section.group.begin.glsl
      push:
        - meta_scope: meta.group.glsl
        - match: \)
          scope: punctuation.section.group.end.glsl
          pop: true
        - include: expressions

  brackets:
    - match: \[
      scope: punctuation.section.brackets.begin.glsl
      push:
        - meta_scope: meta.brackets.glsl
        - match: \]
          scope: punctuation.section.brackets.end.glsl
          pop: true
        - include: expressions

  case-default:
    - match: \b(default|case)\b
      scope: keyword.control.glsl
      push:
        - match: ':'
          scope: punctuation.separator.glsl
          pop: true
        - include: expressions

  typedef:
    - match: \btypedef\b
      scope: storage.type.glsl
      push:
        - match: ({{identifier}})?\s*(?=;)
          captures:
            1: entity.name.type.typedef.glsl
          pop: true
        - match: \b(struct)\s+({{identifier}})
          captures:
            1: storage.type.glsl
        - include: expressions

  function-call:
    - match: (?={{identifier}}\s*\()
      push:
        - meta_content_scope: meta.function-call.glsl
        - include: functions-builtin
        - match: '{{identifier}}'
          scope: variable.function.glsl
        - match: '\('
          scope: meta.group.glsl punctuation.section.group.begin.glsl
          set:
            - meta_content_scope: meta.function-call.glsl meta.group.glsl
            - match : \)
              scope: meta.function-call.glsl meta.group.glsl punctuation.section.group.end.glsl
              pop: true
            - include: expressions

  ## Preprocessor for data-structures

  preprocessor-data-structures:
    - include: preprocessor-rule-enabled-data-structures
    - include: preprocessor-rule-disabled-data-structures

  preprocessor-rule-disabled-data-structures:
    - match: ^\s*((#if)\s+(0))\b
      captures:
        1: meta.preprocessor.glsl
        2: keyword.control.import.glsl
        3: constant.numeric.preprocessor.glsl
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.glsl
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.else.glsl
          push:
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: negated-block
            - include: data-structures-body
        - match: ""
          push:
            - meta_scope: comment.block.preprocessor.if-branch.glsl
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: preprocessor-disabled

  preprocessor-rule-enabled-data-structures:
    - match: ^\s*((#if)\s+(0*1))\b
      captures:
        1: meta.preprocessor.glsl
        2: keyword.control.import.glsl
        3: constant.numeric.preprocessor.glsl
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.glsl
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.else.glsl
          push:
            - meta_content_scope: comment.block.preprocessor.else-branch.glsl
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: preprocessor-disabled
        - match: ""
          push:
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: negated-block
            - include: data-structures-body

  ## Preprocessor for global

  preprocessor-global:
    - include: preprocessor-rule-enabled-global
    - include: preprocessor-rule-disabled-global
    - include: preprocessor-rule-other-global

  preprocessor-statements:
    - include: preprocessor-rule-enabled-statements
    - include: preprocessor-rule-disabled-statements
    - include: preprocessor-rule-other-statements

  preprocessor-expressions:
    - include: incomplete-inc
    - include: preprocessor-macro-version
    - include: preprocessor-macro-define
    - include: preprocessor-macro-extension
    - include: pragma-mark
    - include: preprocessor-other

  preprocessor-rule-disabled-global:
    - match: ^\s*((#if)\s+(0))\b
      captures:
        1: meta.preprocessor.glsl
        2: keyword.control.import.glsl
        3: constant.numeric.preprocessor.glsl
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.glsl
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.else.glsl
          push:
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: preprocessor-global
            - include: negated-block
            - include: global
        - match: ""
          push:
            - meta_scope: comment.block.preprocessor.if-branch.glsl
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: preprocessor-disabled

  preprocessor-rule-enabled-global:
    - match: ^\s*((#if)\s+(0*1))\b
      captures:
        1: meta.preprocessor.glsl
        2: keyword.control.import.glsl
        3: constant.numeric.preprocessor.glsl
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.glsl
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.else.glsl
          push:
            - meta_content_scope: comment.block.preprocessor.else-branch.glsl
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: preprocessor-disabled
        - match: ""
          push:
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: preprocessor-global
            - include: negated-block
            - include: global

  preprocessor-rule-other-global:
    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
      captures:
        1: keyword.control.import.glsl
      push:
        - meta_scope: meta.preprocessor.glsl
        - include: preprocessor-line-continuation
        - include: preprocessor-comments
        - match: \bdefined\b
          scope: keyword.control.glsl
        # Enter a new scope where all elif/else branches have their
        # contexts popped by a subsequent elif/else/endif. This ensures that
        # preprocessor branches don't push multiple meta.block scopes on
        # the stack, thus messing up the "global" context's detection of
        # functions.
        - match: $\n
          set: preprocessor-if-branch-global

  # These gymnastics here ensure that we are properly handling scope even
  # when the preprocessor is used to create different scope beginnings, such
  # as a different if/while condition
  preprocessor-if-branch-global:
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
      pop: true
    - match: (?=^\s*#\s*(elif|else)\b)
      push: preprocessor-elif-else-branch-global
    - match: \{
      scope: punctuation.section.block.begin.glsl
      set: preprocessor-block-if-branch-global
    - include: preprocessor-global
    - include: negated-block
    - include: global

  preprocessor-block-if-branch-global:
    - meta_scope: meta.block.glsl
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
      set: preprocessor-block-finish-global
    - match: (?=^\s*#\s*(elif|else)\b)
      push: preprocessor-elif-else-branch-global
    - match: \}
      scope: punctuation.section.block.end.glsl
      set: preprocessor-if-branch-global
    - include: statements

  preprocessor-block-finish-global:
    - meta_scope: meta.block.glsl
    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
      set: preprocessor-block-finish-if-branch-global
    - match: \}
      scope: punctuation.section.block.end.glsl
      pop: true
    - include: statements

  preprocessor-block-finish-if-branch-global:
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
      pop: true
    - match: \}
      scope: punctuation.section.block.end.glsl
      set: preprocessor-if-branch-global
    - include: statements

  preprocessor-elif-else-branch-global:
    - match: (?=^\s*#\s*endif\b)
      pop: true
    - include: negated-block
    - include: preprocessor-global
    - include: global

  ## Preprocessor for statements

  preprocessor-rule-disabled-statements:
    - match: ^\s*((#if)\s+(0))\b
      captures:
        1: meta.preprocessor.glsl
        2: keyword.control.import.glsl
        3: constant.numeric.preprocessor.glsl
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.glsl
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.else.glsl
          push:
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: negated-block
            - include: statements
        - match: ""
          push:
            - meta_scope: comment.block.preprocessor.if-branch.glsl
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: preprocessor-disabled

  preprocessor-rule-enabled-statements:
    - match: ^\s*((#if)\s+(0*1))\b
      captures:
        1: meta.preprocessor.glsl
        2: keyword.control.import.glsl
        3: constant.numeric.preprocessor.glsl
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.glsl
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.glsl keyword.control.import.else.glsl
          push:
            - meta_content_scope: comment.block.preprocessor.else-branch.glsl
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: preprocessor-disabled
        - match: ""
          push:
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: negated-block
            - include: statements

  preprocessor-rule-other-statements:
    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
      captures:
        1: keyword.control.import.glsl
      push:
        - meta_scope: meta.preprocessor.glsl
        - include: preprocessor-line-continuation
        - include: preprocessor-comments
        - match: \bdefined\b
          scope: keyword.control.glsl
        # Enter a new scope where all elif/else branches have their
        # contexts popped by a subsequent elif/else/endif. This ensures that
        # preprocessor branches don't push multiple meta.block scopes on
        # the stack, thus messing up the "global" context's detection of
        # functions.
        - match: $\n
          set: preprocessor-if-branch-statements

  # These gymnastics here ensure that we are properly handling scope even
  # when the preprocessor is used to create different scope beginnings, such
  # as a different if/while condition
  preprocessor-if-branch-statements:
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
      pop: true
    - match: (?=^\s*#\s*(elif|else)\b)
      push: preprocessor-elif-else-branch-statements
    - match: \{
      scope: punctuation.section.block.begin.glsl
      set: preprocessor-block-if-branch-statements
    - match: (?=(?!{{non_func_keywords}}){{identifier}}\s*\()
      set: preprocessor-if-branch-function-call
    - include: negated-block
    - include: statements

  preprocessor-if-branch-function-call:
    - meta_content_scope: meta.function-call.glsl
    - include: functions-builtin
    - match: '{{identifier}}'
      scope: variable.function.glsl
    - match: \(
      scope: meta.group.glsl punctuation.section.group.begin.glsl
      set: preprocessor-if-branch-function-call-arguments

  preprocessor-if-branch-function-call-arguments:
    - meta_content_scope: meta.function-call.glsl meta.group.glsl
    - match : \)
      scope: meta.function-call.glsl meta.group.glsl punctuation.section.group.end.glsl
      set: preprocessor-if-branch-statements
    - match: ^\s*(#\s*(?:elif|else))\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
      set: preprocessor-if-branch-statements
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
      set: preprocessor-if-branch-function-call-arguments-finish
    - include: expressions

  preprocessor-if-branch-function-call-arguments-finish:
    - meta_content_scope: meta.function-call.glsl meta.group.glsl
    - match: \)
      scope: meta.function-call.glsl meta.group.glsl punctuation.section.group.end.glsl
      pop: true
    - include: expressions

  preprocessor-block-if-branch-statements:
    - meta_scope: meta.block.glsl
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
      set: preprocessor-block-finish-statements
    - match: (?=^\s*#\s*(elif|else)\b)
      push: preprocessor-elif-else-branch-statements
    - match: \}
      scope: punctuation.section.block.end.glsl
      set: preprocessor-if-branch-statements
    - include: statements

  preprocessor-block-finish-statements:
    - meta_scope: meta.block.glsl
    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
      set: preprocessor-block-finish-if-branch-statements
    - match: \}
      scope: punctuation.section.block.end.glsl
      pop: true
    - include: statements

  preprocessor-block-finish-if-branch-statements:
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
      pop: true
    - match: \}
      scope: punctuation.section.block.end.glsl
      set: preprocessor-if-branch-statements
    - include: statements

  preprocessor-elif-else-branch-statements:
    - match: (?=^\s*#\s*endif\b)
      pop: true
    - include: negated-block
    - include: statements

  ## Preprocessor other

  negated-block:
    - match: \}
      scope: punctuation.section.block.end.glsl
      push:
        - match: \{
          scope: punctuation.section.block.begin.glsl
          pop: true
        - match: (?=^\s*#\s*(elif|else|endif)\b)
          pop: true
        - include: statements

  preprocessor-macro-define-or-version-inside:
    - meta_content_scope: meta.preprocessor.macro.glsl
    - include: preprocessor-line-continuation
    - include: preprocessor-line-ending
    - include: preprocessor-comments
    - match: ({{identifier}})(?=\()
      scope: entity.name.function.preprocessor.glsl
      set:
        - match: \(
          scope: punctuation.section.group.begin.glsl
          set: preprocessor-macro-params
    - match: '{{identifier}}'
      scope: entity.name.constant.preprocessor.glsl
      set: preprocessor-macro-definition

  preprocessor-macro-extension:
    - match: ^\s*(#\s*extension)\b
      captures:
        1: meta.preprocessor.macro.glsl keyword.control.import.extension.glsl
      push:
        - meta_content_scope: meta.preprocessor.macro.glsl
        - include: preprocessor-line-continuation
        - include: preprocessor-line-ending
        - include: preprocessor-comments
        - match: \ball\b
          scope: string.unquoted.glsl constant.language.glsl
          set: preprocessor-macro-extension-inside
        - match: '{{identifier}}'
          scope: string.unquoted.glsl
          set: preprocessor-macro-extension-inside
        - match: (?=\S)
          pop: true

  preprocessor-macro-extension-inside:
    - meta_content_scope: meta.preprocessor.macro.glsl
    - include: preprocessor-line-continuation
    - include: preprocessor-line-ending
    - include: preprocessor-comments
    - match: ":"
      scope: punctuation.separator.glsl
      set:
        - meta_content_scope: meta.preprocessor.macro.glsl
        - include: preprocessor-line-continuation
        - include: preprocessor-line-ending
        - include: preprocessor-comments
        - match: '{{identifier}}'
          scope: variable.parameter.glsl
          pop: true
        - match: (?=\S)
          pop: true
    - match: (?=\S)
      pop: true

  preprocessor-macro-version:
    - match: ^\s*(#\s*version)\b
      captures:
        1: meta.preprocessor.macro.glsl keyword.control.import.version.glsl
      push: preprocessor-macro-define-or-version-inside

  preprocessor-macro-define:
    - match: ^\s*(#\s*define)\b
      captures:
        1: meta.preprocessor.macro.glsl keyword.control.import.define.glsl
      push: preprocessor-macro-define-or-version-inside

  preprocessor-macro-params:
    - meta_scope: meta.preprocessor.macro.parameters.glsl meta.group.glsl
    - match: '{{identifier}}'
      scope: variable.parameter.glsl
    - match: \)
      scope: punctuation.section.group.end.glsl
      set: preprocessor-macro-definition
    - match: \,
      scope: punctuation.separator.glsl
      push:
        - match: '{{identifier}}'
          scope: variable.parameter.glsl
          pop: true
        - include: preprocessor-line-continuation
        - include: preprocessor-comments
        - match: \.\.\.
          scope: keyword.operator.variadic.glsl
        - match: (?=\))
          pop: true
        - match: (/\*).*(\*/)
          scope: comment.block.glsl
          captures:
            1: punctuation.definition.comment.glsl
            2: punctuation.definition.comment.glsl
        - match: \S+
          scope: invalid.illegal.unexpected-character.glsl
    - include: preprocessor-line-continuation
    - include: preprocessor-comments
    - match: \.\.\.
      scope: keyword.operator.variadic.glsl
    - match: (/\*).*(\*/)
      scope: comment.block.glsl
      captures:
        1: punctuation.definition.comment.glsl
        2: punctuation.definition.comment.glsl
    - match: $\n
      scope: invalid.illegal.unexpected-end-of-line.glsl

  preprocessor-macro-definition:
    - meta_content_scope: meta.preprocessor.macro.glsl
    - include: preprocessor-line-continuation
    - include: preprocessor-line-ending
    - include: preprocessor-comments
    # Don't define blocks in define statements
    - match: \{
      scope: punctuation.section.block.begin.glsl
    - match: \}
      scope: punctuation.section.block.end.glsl
    - include: expressions

  preprocessor-other:
    - match: ^\s*(#\s*(?:if|ifdef|ifndef|elif|else|line|pragma|undef))\b
      captures:
        1: keyword.control.import.glsl
      push:
        - meta_scope: meta.preprocessor.glsl
        - include: preprocessor-line-continuation
        - include: preprocessor-line-ending
        - include: preprocessor-comments
        - match: \bdefined\b
          scope: keyword.control.glsl
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.glsl keyword.control.import.glsl
    - match: ^\s*(#\s*(?:error))\b
      captures:
        1: keyword.control.import.error.glsl
      push:
        - meta_scope: meta.preprocessor.diagnostic.glsl
        - include: preprocessor-line-continuation
        - include: preprocessor-line-ending
        - include: preprocessor-comments
        - match: \S+
          scope: string.unquoted.glsl
    - match: ^\s*(#\s*(?:include|include_next|import))\b
      captures:
        1: keyword.control.import.include.glsl
      push:
        - meta_scope: meta.preprocessor.include.glsl
        - include: preprocessor-line-continuation
        - include: preprocessor-line-ending
        - include: preprocessor-comments
        - match: '"'
          scope: punctuation.definition.string.begin.glsl
          push:
            - meta_scope: string.quoted.double.include.glsl
            - match: '"'
              scope: punctuation.definition.string.end.glsl
              pop: true
        - match: <
          scope: punctuation.definition.string.begin.glsl
          push:
            - meta_scope: string.quoted.other.lt-gt.include.glsl
            - match: ">"
              scope: punctuation.definition.string.end.glsl
              pop: true