modern-fortran.sublime-syntax

%YAML 1.2
---
#
# Modern Fortran syntax - Sublime Text syntax highlighting for modern Fortran code
#
# Copyright (c) 2020-2021 by the authors
#
name: Modern-Fortran
file_extensions: [F90,F95,F03,F08,F18,f90,f95,f03,f08,f18]
scope: source.fortran

variables:
  intrinsicType: '(real|integer|complex|character|logical|byte|double precision|double complex)'
  intrinsicAttribute: '(allocatable|asynchronous|automatic|bind|codimension|contiguous|dimension|external|intent|intrinsic|optional|parameter|pointer|private|protected|public|save|static|target|value|volatile|deferred|pass|nopass|overridable|non_overridable)'
  intrinsicFunction: '(abs|achar|acos|acosh|adjustl|adjustr|aimag|aint|all|allocated|anint|any|asin|asinh|associated|atan|atan2|atanh|atomic_add|atomic_and|atomic_cas|atomic_define|atomic_fetch_add|atomic_fetch_and|atomic_fetch_or|atomic_fetch_xor|atomic_or|atomic_ref|atomic_xor|bessel_j0|bessel_j1|bessel_jn|bessel_y0|bessel_y1|bessel_yn|bge|bgt|bit_size|ble|bit|btest|c_associated|c_funloc|c_f_pointer|c_f_procpointer|c_loc|c_sizeof|ceiling|char|cmplx|co_broadcast|co_max|co_min|co_reduce|co_sum|coshape|command_argument_count|compiler_options|compiler_version|conjg|cos|cosh|count|cpu_time|cshift|date_and_time|dble|digits|dim|dot_product|dprod|dshiftl|dshiftr|eoshift|epsilon|erf|erfc|erfc_scaled|event_query|execute_command_line|exp|exponent|extends_type_of|float|floor|fraction|gamma|get_command|get_command_argument|get_environment_variable|huge|hypot|iachar|iall|iand|iany|ibclr|ibits|ibset|ichar|ieor|image_index|index|int|ior|iparity|is_iostat_end|is_iostat_eor|ishft|isfhtc|kind|lbound|lcobound|leadz|len|len_trim|lge|lgt|lle|llt|log|log10|log_gamma|logical|maskl|maskr|matmul|max|maxexponent|maxloc|maxval|merge|merge_bits|min|minexponent|minloc|minval|mod|module|move_alloc|mvbits|nearest|new\_line|nint|not|norm2|null|num_images|pack|parity|popcnt|poppar|precision|present|product|radix|random_number|random_seed|range|rank|real|repeat|reshape|rrspacing|same_type_as|scale|scan|selected_char_kind|selected_int_kind|selected_real_kind|set_exponent|shape|shifta|shiftl|shiftr|sign|sin|sinh|size|sngl|spacing|spread|sqrt|storage_size|sum|system_clock|tan|tanh|this_image|tiny|trailz|transfer|transpose|trim|ubound|ucobound|unpack|verify)'
  intrinsicSubroutine: '(nullify|allocate|deallocate)'
  intrinsicIO: '(print|write|read|inquire|open|close|rewind|backspace|endfile|flush|namelist)'
  intrinsicIOArguments: (unit|newunit|iunit|eunit|position|format|advance|asynchronous|blank|decimal|id|pad|pos|round|size|iostat|err|end|eor|iomsg|io-list|form|nml-group|nml|rec|delim|sign|name|label|msg-var|i-var|slist|access|action|associatevariable|blocksize|buffercount|buffered|carriagecontrol|convert|decimal|defaultfile|dispose|encoding|file|iofocus|maxrec|mode|noshared|organization|readonly|recordsize|recordtype|share|status|title|type|useropen|sz|slist|def)

  firstOnLine: '^\s*'
  parenthesisStart: '\(\s*'
  parenthesisEnd: '\s*\)'
  variableMatch: '[A-Za-z_][A-Za-z_0-9]*'
  accDirectives: '(end|parallel|kernels|serial|data|enter|exit|host_data|loop|cache|atomic|update|wait|routine|declare|init|shutdown|set)'
  accClauses: (device_type|dtype|async|wait|num_gangs|num_workers|vector_length|reduction|private|firstprivate|copyin|copyout|copy|create|no_create|present|deviceptr|attach|detach|use_device|if_present|if|collapse|gang|worker|vector|seq|auto|independent|tile|read|write|update|capture|device_resident|link|self|device|host)
  ompDirectives: '(end|parallel|do|simd|single|target|update|workshare|declare|sections|distribute|teams|taskyield|master|critical|barrier|taskwait|taskgroup|task|atomic|flush|ordered|cancel|cancellation point|reduction)'
  ompIntrinsics: (omp_set_num_threads|omp_get_num_threads|omp_get_max_threads|omp_get_thread_num|omp_get_num_procs|omp_in_parallel|omp_set_dynamic|omp_get_dynamic|omp_get_cancellation|omp_set_nested|omp_get_nested|omp_set_schedule|omp_get_schedule|omp_get_thread_limit|omp_set_max_active_levels|omp_get_max_active_levels|omp_get_level|omp_get_ancestor_thread_num|omp_get_team_size|omp_get_active_level|omp_in_final|omp_get_proc_bind|omp_set_default_device|omp_get_default_device|omp_get_num_devices|omp_get_num_teams|omp_get_team_num|omp_is_initial_device|omp_init_lock|omp_init_nest_lock|omp_destroy_lock|omp_destroy_nest_lock|omp_set_lock|omp_set_nest_lock|omp_unset_lock|omp_unset_nest_lock|omp_test_lock|omp_test_nest_lock|omp_get_wtime|omp_get_wtick)
  ompClauses: (default|shared|private|firstprivate|lastprivate|linear|reduction|copyin|copyprivate|map|tofrom|safelen|collapse|simdlen|aligned|uniform|Inbrach|notinbranch)
  fppCommands: (define|undef|ifdef|ifndef|if|elif|else|endif|include|error|warning|line-number|line)

contexts:
  main:
    - include: attribute
    - include: interfaces
    - include: class-definitions
    - include: control
    - include: coarray
    - include: program
    - include: stop
    - include: acc
    - include: omp
    - include: expressions

  expressions:
    - include: comments
    - include: preprocessing
    - include: types
    - include: operators
    - include: procedures
    - include: modules
    - include: strings
    - include: continuation
    - include: separators
    - include: numbers
    - include: constants
    - include: class-accessing
    - include: io
    - include: associate 
    - include: block
    - include: function-call
    - include: pointer-symbol
    - include: match-end
    - include: match-variable
    - include: parens
    - include: brackets

  eol-pop:
    - match: (?=\s*[!\n])
      pop: true

  line-continuation:
    - match: (\&)\s*(?:((!).*$\n?)|$\n?)
      captures:
        1: punctuation.separator.continuation.fortran
        2: comment.line.fortran
        3: punctuation.definition.comment.fortran
      push:
        - include: comments
        - match: (?=\S)
          pop: true

  comments:
    - match: '!(?![$])'
      scope: punctuation.definition.comment.fortran
      push:
      - meta_scope: comment.line.fortran
      - match: \n
        pop: true

  parens:
    - match: \(/
      scope: punctuation.section.parens.begin.fortran
      push:
        - meta_scope: meta.parens.fortran
        - include: line-continuation
        - include: eol-pop
        - match: /\)
          scope: punctuation.section.parens.end.fortran
          pop: true
        - include: expressions
    - match: \(
      scope: punctuation.section.parens.begin.fortran
      push:
        - meta_scope: meta.parens.fortran
        - include: line-continuation
        - include: eol-pop
        - match: \)
          scope: punctuation.section.parens.end.fortran
          pop: true
        - include: expressions

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

  types:
    - match: '(?i)\b{{intrinsicType}}\b(?=.*(function))' # type of return value in function
      scope: storage.type.intrinsic.fortran
    - match: '(?i)\b{{intrinsicType}}\s+(?=\w+)' # old-style declaration
      scope: storage.type.intrinsic.fortran
    - match: '(?i){{firstOnLine}}\b{{intrinsicType}}(?=\,)' # type declaration
      scope: storage.type.intrinsic.fortran
    - match: '(?i){{firstOnLine}}\b{{intrinsicType}}(?=\(.*\)\,)' # type declaration
      scope: storage.type.intrinsic.fortran
    - match: '(?i){{firstOnLine}}\b{{intrinsicType}}\b(?=.*::)' # type declaration
      scope: storage.type.intrinsic.fortran
    - match: '(?i)\b(in|out|inout)\b'
      scope: keyword.other.intent.fortran
    - match: (::)\s*(\w+)
      captures:
        1: punctuation.separator.double-colon.fortran
        2: variable.other.fortran
    - match: (?i){{firstOnLine}}(type|class)\s*((\()\s*(\w*)\s*(\)))
      captures:
        1: keyword.other.fortran
        2: meta.parens.fortran
        3: punctuation.section.parens.begin.fortran
        4: storage.type.class.fortran
        5: punctuation.section.parens.end.fortran

  attribute:
    - match: '(?i)\b{{intrinsicAttribute}}\b'
      scope: storage.modifier.fortran

  pointer-symbol:
    - match: (=>)
      scope: keyword.operator.points-to.fortran

  operators:
    - match: (==|/=|>=|<=|<|>)
      scope: keyword.operator.comparison.fortran
    - match: (?i)(\.and\.|\.or\.|\.ne\.|\.lt\.|\.le\.|\.gt\.|\.ge\.|\.eq\.|\.not\.)
      scope: keyword.operator.word.fortran
    - match: (\*|\+|-)
      scope: keyword.operator.arithmetic.fortran
    - match: (\/)(?!/)
      scope: keyword.operator.arithmetic.fortran # division, not string concatenation!
    - match: (=)(?!>)
      scope: keyword.operator.assignment.fortran

  separators:
    - match: (::)
      scope: punctuation.separator.double-colon.fortran
    - match: (:)
      scope: punctuation.separator.single-colon.fortran
    - match: ','
      scope: punctuation.separator.comma.fortran
    - match: '\%'
      scope: punctuation.accessor.fortran
    - match: '\;'
      scope: punctuation.terminator.fortran

  control:
    - include: comments
    - match: (?i){{firstOnLine}}(end)\s*(if|do|select)\b
      captures:
        1: keyword.control.fortran
        2: keyword.control.fortran
      push: seek-conditional-label
    - match: (?i)(;)\s*(end)\s*(if|do)\b
      captures:
        1: punctuation.terminator.fortran
        2: keyword.control.fortran
        3: keyword.control.fortran
      push: seek-conditional-label
    - match: (?i)\b(then|exit|cycle)\b
      scope: keyword.control.fortran
      push: seek-conditional-label
    - match: (?i)\b(else)\b(?!\s*if)
      scope: keyword.control.fortran
      push: seek-conditional-label
    - match: (?i)\b(elseif)\b
      scope: keyword.control.fortran
    - match: (?i)\b(else|if|do|while)\b
      scope: keyword.control.fortran
    - match: (?i)(\w+)\s*(\:)\s*(?=do|if|select)
      captures:
        1: entity.name.label.conditional.fortran
        2: punctuation.separator.single-colon.fortran
    - match: (?i)\b(concurrent|local|shared|local_init|default)\b
      scope: keyword.control.fortran
    - match: (?i)\b(class)\s+(?=default)\b
      scope: keyword.control.fortran
    - match: (?i)\b(case|default)\b
      scope: keyword.control.fortran
    - match: (?i)\b(exit|cycle|return)\b
      scope: keyword.control.fortran
    - match: (?i)\b(select)\b\s*(?:(case|type|class)\b)?
      captures:
        1: keyword.control.fortran
        2: keyword.control.fortran
    - match: (?i)(class\s+is)\b\s*\(\s*(\w+)\s*\)
      captures:
        1: keyword.control.fortran
        2: entity.name.class.fortran
    - match: (?i)(type\s+is)\b\s*\(\s*(\w+)\s*\)
      captures:
        1: keyword.control.fortran
        2: entity.name.class.fortran

  seek-conditional-label: # look for possible name label & pop
    - include: comment-pop
    - include: newline-pop
    - match: \b(\w+)
      scope: entity.name.label.conditional.fortran
      pop: true

  newline-pop:
    - match: '\n'
      pop: true

  continuation:
    - match: "&"
      scope: punctuation.separator.continuation.fortran

  strings:
    - match: "//"
      scope: keyword.operator.arithmetic.string-concatenation.fortran
    - match: "'"
      scope: punctuation.definition.string.begin.fortran
      push: string-single
    - match: '"'
      scope: punctuation.definition.string.begin.fortran
      push: string-double

  string-single:
    - meta_scope: string.quoted.single.fortran
    - include: string-continuation
    - include: newline-pop
    - match: "'"
      scope: punctuation.definition.string.end.fortran
      pop: true

  string-double:
    - meta_scope: string.quoted.double.fortran
    - include: string-continuation
    - include: newline-pop
    - match: '"'
      scope: punctuation.definition.string.end.fortran
      pop: true

  string-continuation:
    - match: (\&)\s*$\n?
      captures:
        1: punctuation.separator.continuation.fortran
      push:
        # locate continuation on next line and pop
        - match: "&"
          scope: punctuation.separator.continuation.fortran
          pop: true
        - include: comments
        - match: (?=\S)
          pop: true

  procedures:
    - match: (?i)\b({{intrinsicFunction}})\b\s*(?=\()
      captures:
        1: support.function.intrinsic.fortran

    - match: (?i)\b({{intrinsicSubroutine}})\b\s*(?=\()
      captures:
        1: support.function.subroutine.fortran

    - match: (?i)\b(impure|pure|elemental|non\_recursive|recursive)\b
      scope: storage.modifier.function.prefix.fortran

    - match: (?i)\b(implicit)(?:\s+(none))?\b
      captures:
        1: keyword.control.fortran
        2: keyword.control.fortran

    - match: '(?i)\b(module)(?=\s+procedure\b)'
      scope: storage.modifier.function.prefix.fortran

    - match: (?i)(?:\b(module)\s+)?\b(function)\b
      scope: meta.function.declaration.fortran
      captures:
         1: storage.modifier.function.prefix.fortran
         2: keyword.declaration.function.fortran
      push:
        - meta_content_scope: meta.function.declaration.fortran
        - include: line-continuation
        - include: eol-pop
        - match: \w+
          scope: entity.name.function.fortran
        - match: \(
          scope: punctuation.section.parens.begin.fortran
          push:
            - clear_scopes: 1
            - meta_scope: meta.function.parameters.fortran
            - include: line-continuation
            - include: eol-pop
            - match: \w+
              scope: variable.parameter.input.fortran
            - match: \,
              scope: punctuation.separator.comma.fortran
            - match: \)
              scope: punctuation.section.parens.end.fortran
              set:
                - include: line-continuation
                - include: eol-pop
                - match: (?i)\bresult\b
                  scope: keyword.control.function-result.fortran
                - match: (?=\()
                  set:
                    - clear_scopes: 1
                    - match: \(
                      scope: punctuation.section.parens.begin.fortran
                      set:
                        - clear_scopes: 1
                        - meta_scope: meta.function.parameters.fortran
                        - include: line-continuation
                        - include: eol-pop
                        - match: \w+
                          scope: variable.parameter.output.fortran
                        - match: \,
                          scope: punctuation.separator.comma.fortran
                        - match: \)
                          scope: punctuation.section.parens.end.fortran
                          pop: true

    - match: (?i)(?:\b(module)\s+)?\b(subroutine)\b
      captures:
        1: storage.modifier.function.prefix.fortran
        2: keyword.declaration.function.fortran
      push:
        - meta_scope: meta.function.declaration.fortran
        - include: line-continuation
        - include: eol-pop
        - match: \w+
          scope: entity.name.function.fortran
        - match: \(
          scope: punctuation.section.parens.begin.fortran
          push:
            - clear_scopes: 1
            - meta_scope: meta.function.parameters.fortran
            - include: line-continuation
            - include: eol-pop
            - match: \w+
              scope: variable.parameter.fortran
            - match: \,
              scope: punctuation.separator.comma.fortran
            - match: \)
              scope: punctuation.section.parens.end.fortran
              pop: true

    - match: (?i)\b(end)\s+(?:(function|subroutine)(?:\s+(\w+))?|(procedure))\b
      captures:
        1: keyword.declaration.function.fortran
        2: keyword.declaration.function.fortran
        3: entity.name.function.fortran
        4: keyword.declaration.function.fortran

    - match: '(?i)\b(call)\b'
      captures:
        1: keyword.control.fortran

  io:
    - match: '(?i)\b({{intrinsicIO}})\b'
      captures:
        1: variable.function.subroutine.intrinsic.io.fortran
    - match: '(?i)\b({{intrinsicIOArguments}})\b\s*(?=\=)'
      captures:
        1: variable.language.io.fortran

  stop:
    - match: (?i)\b(stop)\b
      scope: keyword.control.fortran
    - match: (?i)\b(error)\s+(?=stop)\b
      scope: keyword.control.fortran
    - match: (?i)\b(quiet)\b
      scope: keyword.control.fortran

  modules:
    - match: (?i)\b(module)(?:\s+(\w+))?\b
      scope: meta.module.declaration.fortran
      captures:
        1: keyword.declaration.interface.module.fortran
        2: entity.name.interface.module.fortran
    - match: (?i){{firstOnLine}}(end)\s+(module)(?:\s+(\w+))?\b
      captures:
        1: keyword.declaration.interface.module.fortran
        2: keyword.declaration.interface.module.fortran
        3: entity.name.interface.module.fortran
    - match: (?i){{firstOnLine}}(submodule)(?:\s+(\()\s*(\w+)\s*(\))(?:\s+(\w+))?)?
      scope: meta.submodule.declaration.fortran
      captures:
        1: keyword.declaration.interface.submodule.fortran
        2: punctuation.section.parens.begin.fortran
        3: entity.name.interface.inherited-module.fortran
        4: punctuation.section.parens.end.fortran
        5: entity.name.interface.submodule.fortran
    - match: (?i){{firstOnLine}}(end)\s+(submodule)(?:\s+(\w+))?\b
      captures:
        1: keyword.declaration.interface.submodule.fortran
        2: keyword.declaration.interface.submodule.fortran
        3: entity.name.interface.submodule.fortran
    - match: (?i)\b(use)\b
      scope: keyword.control.import.fortran
      push: find-use-module
    - match: (?i)\b(import)\b
      scope: keyword.control.import.fortran
    - match: (?i)\b(only)\b
      scope: keyword.control.fortran

  find-use-module:
    - include: eol-pop
    - include: separators
    - include: attribute
    - match: (\w+)
      scope: entity.name.interface.module.fortran
      pop: true

  class-definitions:
    - match: ^(?i){{firstOnLine}}\b(type)\b(?!\s*\(|\s*is\b)
      scope: keyword.declaration.class.fortran
      push: class-name
    - match: (?i)\b(procedure|generic|final)\b
      scope: keyword.declaration.function.fortran
      push: member-routine-declaration
    - match: (?i)\b(contains)\b
      scope: keyword.declaration.contains.fortran
    - match: '(?i)(end)\s+(type)\s+(\w+)'
      captures:
        1: keyword.declaration.class.fortran
        2: keyword.declaration.class.fortran
        3: entity.name.class.fortran
    - match: '(?i)(end)\s+(type)'
      captures:
        1: keyword.declaration.class.fortran
        2: keyword.declaration.class.fortran

  member-routine-declaration:
    - include: separators
    - include: attribute
    - include: pointer-symbol
    - match: (?=\b(end|procedure|final|generic)\b)
      pop: true
      # this pop makes sure we don't recognize the "end type" or the next routine declaration
      # as a function name when typing "procedure :: myProcedure &"
    - match: \w+
      scope: entity.name.function.fortran
    - match: \n
      pop: true
    - match: \&
      scope: punctuation.separator.continuation.fortran
      push: continuation-context
    - include: comment-pop
    - match: \n
      pop: true

  continuation-context: # continues until non-comment newline
    - include: comments
    - match: '^\s*(?!\!)'
      pop: true

  comment-pop: # in "include" statements, this code will pop off and push into comment context (via "set") if it encounters "!"
               # (useful when one needs to pop out of context at a newline, also in the case of an inline comment)
    - match: \!
      scope: punctuation.definition.comment.fortran
      set: # pop off and in
      - meta_scope: comment.line.fortran
      - match: \n
        pop: true

  class-name:
    - meta_scope: meta.class.declaration.fortran
    - include: newline-pop
    - include: comment-pop
    - match: \,
      scope: punctuation.separator.comma.fortran
      push: seek-class-modifiers
    - include: separators
    - match: (?i)(\w+) # simple type definition (type myType)
      scope: entity.name.class.fortran

  seek-class-modifiers:
    - include: eol-pop
    - match: (?i)\b(extends)\b\s*{{parenthesisStart}}\s*(\w*)\s*{{parenthesisEnd}}
      captures:
        1: keyword.control.extends.fortran
        2: entity.other.inherited-class.fortran
    - match: (?i)\b(abstract|public|private)\b
      scope: storage.modifier.fortran
    - match: (::)
      scope: punctuation.separator.double-colon.fortran
      pop: true
    - include: separators


  numbers:
    - match: (?i)((?:\b\d+(\.)\d*|(\.)\d+)(?:[de][-+]?\d+)?|\b\d+[de][-+]?\d+)(_\w+)?
      scope: meta.number.float.decimal.fortran
      captures:
        1: constant.numeric.value.fortran
        2: punctuation.separator.decimal.fortran
        3: punctuation.separator.decimal.fortran
        4: constant.numeric.suffix.fortran
    - match: \b(\d+)(_\w+)?
      scope: meta.number.integer.decimal.fortran
      captures:
        1: constant.numeric.value.fortran
        2: constant.numeric.suffix.fortran

  constants:
    - match: (?i)(\.true\.|\.false\.)
      scope: constant.language.fortran

  class-accessing:
    - match: '\w+(?=(?:\s*\[.*\])?(?:\s*\([^(]*\))?\s*\%)'
      scope: storage.type.class.fortran

  function-call:
    - match: '(\w*)\s*(?=\()'
      captures:
        1: variable.function.fortran

  interfaces:
    - match: (?i)(abstract)\b
      scope: storage.modifier.fortran
    - match: (?i)\b(interface)\b\s*(?:(\w+))?
      captures:
        1: keyword.declaration.interface.interface.fortran
        2: entity.name.interface.interface.fortran
    - match: (?i)\b(include)\b
      scope: keyword.control.import.fortran
    - match: (?i)\b(end)\b\s+(?=interface)
      scope: keyword.declaration.interface.interface.fortran

  acc:
    - match: '{{firstOnLine}}(?i)(\!\$acc)'
      scope: keyword.control.directive.fortran
      push: acc-line

  acc-line:
    - include: acc-continuation
    - include: acc-directives
    - include: acc-clauses
    - include: separators
    - include: operators
    - match: (?i)(default)
      scope: keyword.control.directive.fortran
      push: acc-default
    - include: match-variable
    - match: '\n'
      pop: true

  acc-directives:
    - match: (?i)({{accDirectives}})
      scope: keyword.control.directive.fortran

  acc-clauses:
    - include: acc-continuation
    - match: (?i)({{accClauses}})
      scope: keyword.control.directive.fortran

  acc-default:
    - include: acc-continuation
    - include: eol-pop
    - match: (?i)(none|present)
      scope: support.constant.acc
    - match: '{{parenthesisEnd}}'
      pop: true

  acc-continuation:
    - match: "&"
      push:
        - match: '{{firstOnLine}}(?i)(\!\$acc)(?:\s*(\&))?'
          captures:
            1: keyword.control.directive.fortran
            2: punctuation.separator.continuation.fortran
          pop: true

  omp:
    - match: '{{firstOnLine}}(?i)(\!\$omp)'
      scope: keyword.control.directive.fortran
      push: omp-line
    - match: '{{firstOnLine}}(\!\$)'
      scope: keyword.control.directive.fortran
      push: omp-line

  omp-line:
    - include: omp-continuation
    - include: omp-directives
    - include: omp-intrinsic
    - include: omp-clauses
    - include: separators
    - include: operators
    - match: (?i)(schedule)
      scope: keyword.control.directive.fortran
      push: omp-schedule
    - include: match-variable
    - match: '\n'
      pop: true

  omp-directives:
    - match: (?i)({{ompDirectives}})
      scope: keyword.control.directive.fortran

  omp-intrinsic:
    - match: (?i)({{ompIntrinsics}})
      scope: support.function.omp

  omp-clauses:
    - include: omp-continuation
    - match: (?i)({{ompClauses}})
      scope: keyword.control.directive.fortran

  omp-schedule:
    - include: omp-continuation
    - match: (?i)(static|dynamic|guided|auto)
      scope: support.constant.omp
    - match: '{{parenthesisEnd}}'
      pop: true


  omp-continuation:
    - match: "&"
      push:
        - match: '{{firstOnLine}}(?i)(\!\$omp)(?:\s*(\&))?'
          captures:
            1: keyword.control.directive.fortran
            2: punctuation.separator.continuation.fortran
          pop: true

  match-end:
    - match: (?i)\bend\b
      scope: keyword.control.fortran

  match-variable:
    - match: ({{variableMatch}})
      scope: variable.other.fortran

  preprocessing:
    - match: '(?i){{firstOnLine}}(\#{{fppCommands}})'
      captures:
        1: keyword.control.directive.fortran

  program:
    - match: (?i){{firstOnLine}}(program)(?:\s+(\w+))?\b
      scope: meta.program.declaration.fortran
      captures:
        1: keyword.declaration.program.fortran
        2: entity.name.program.fortran
    - match: (?i){{firstOnLine}}(end)\s+(program)(?:\s+(\w+))?\b
      captures:
        1: keyword.declaration.program.fortran
        2: keyword.declaration.program.fortran
        3: entity.name.program.fortran

  coarray:
    - match: (?i)\b(sync)\s+(all|images|memory)\b
      captures:
        1: keyword.control.fortran
        2: keyword.control.fortran
    - match: (?i)\b(lock|unlock)\b
      scope: keyword.control.fortran
    - match: (?i)(event)\s+(post|wait)\s*(?=\()
      captures:
        1: keyword.control.fortran
        2: keyword.control.fortran

  associate:
    - match: (?i)\b(associate)
      scope: keyword.control.fortran

  block:
    - match: (?i){{firstOnLine}}(\w+)\s*(\:)\s*(block)
      captures:
        1: entity.name.label.block.fortran
        2: punctuation.separator.single-colon.fortran
        3: keyword.control.fortran
    - match: (?i){{firstOnLine}}\b(block)
      scope: keyword.control.fortran
    - match: (?i){{firstOnLine}}(end)\s+(block)
      captures:
        1: keyword.control.fortran
        2: keyword.control.fortran
      push:
        - include: comment-pop
        - include: newline-pop
        - match: \b(\w+)
          scope: entity.name.label.block.fortran
          pop: true