Perl.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: Perl
file_extensions:
  - pl
  - pm
  - pod
  - t
  - PL
first_line_match: ^#!.*\bperl\b
scope: source.perl

variables:
  break: (?!\w| *::)
  identifier: '\b[_[:alpha:]]\w*{{break}}'
  module: '\b[_[:upper:]]\w*\b'
  member: '\b[_[:lower:]]\w*\b'
  pod: '={{identifier}}'
  regexp_delim: '[^\w\s\)\]\}\>]'
  regexp_flags: '[msixpodualngcer]+\b'

contexts:
  main:
    - include: comment-pod
    - include: declarations
    - include: expressions

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

  immediately-pop:
    - match: ''
      pop: true

  else-pop:
    - match: $|(?=\S)
      pop: true

  eol-pop:
    - match: $|(?=[;#])
      pop: true

  term-pop:
    - match: (?=;)
      pop: true

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

  comment-line:
    - match: \#+
      scope: punctuation.definition.comment.begin.perl
      push:
        - meta_scope: comment.line.number-sign.perl
        - match: $
          pop: true

  comment-pod:
    # SEE: http://perldoc.perl.org/perlpod.html
    - match: ^{{pod}}
      scope: entity.name.tag.pod.perl
      push:
        - meta_scope: comment.block.documentation.perl
        - meta_content_scope: string.unquoted.perl
        - match: $\n?
          set: comment-pod-body
        - include: comment-pod-formatting

  comment-pod-body:
    - meta_content_scope: comment.block.documentation.perl
    - match: ^=cut\b
      scope: comment.block.documentation.perl entity.name.tag.pod.perl
      pop: true
    - include: comment-pod-embedded
    - include: comment-pod-keyword
    - include: comment-pod-formatting
    - match: \t+
      scope: invalid.deprecated.perl

  comment-pod-embedded:
    - match: ^=begin\s+
      scope: entity.name.tag.pod.perl
      push:
        # end embedded section
        - match: ^=end\b
          scope: entity.name.tag.pod.perl
          pop: true
        # embedded css
        - match: \bcss\b
          scope: string.unquoted.perl
          embed: scope:source.css
          embed_scope: source.css.embedded.perl
          escape: (?=^{{pod}})
        # embedded html
        - match: \bhtml\b
          scope: string.unquoted.perl
          embed: scope:text.html.basic
          embed_scope: text.html.embedded.perl
          escape: (?=^{{pod}})
        # embedded javascript
        - match: \b(?:js|javascript)\b
          scope: string.unquoted.perl
          embed: scope:source.js
          embed_scope: source.js.embedded.perl
          escape: (?=^{{pod}})
        # embedded json
        - match: \bjson\b
          scope: string.unquoted.perl
          embed: scope:source.json
          embed_scope: source.json.embedded.perl
          escape: (?=^{{pod}})
        # embedded sql
        - match: \bsql\b
          scope: string.unquoted.perl
          embed: scope:source.sql
          embed_scope: source.sql.embedded.perl
          escape: (?=^{{pod}})
        # embedded xml
        - match: \bxml\b
          scope: string.unquoted.perl
          embed: scope:text.xml
          embed_scope: text.xml.embedded.perl
          escape: (?=^{{pod}})
        # unexpected pod command
        - match: ^{{pod}}
          scope: invalid.illegal.end-expected.perl
          pop: true
        - include: else-pop

  comment-pod-keyword:
    - match: ^{{pod}}
      scope: entity.name.tag.pod.perl
      push:
        - meta_content_scope: markup.heading.perl
        - include: eol-pop
        - include: comment-pod-formatting

  comment-pod-formatting:
    # non-breaking spaces : S<content>
    - match: (B)(<)
      captures:
        1: entity.name.tag.bold.perl
        2: punctuation.definition.tag.begin.perl
      push:
        - meta_content_scope: markup.bold.perl
        - include: comment-pod-format-body
    # inline code : C<code>
    - match: (C)(<)
      captures:
        1: entity.name.tag.code.perl
        2: punctuation.definition.tag.begin.perl
      push:
        - meta_content_scope: markup.quote.perl
        - include: comment-pod-format-body
    # escaped character : E<escaped>
    - match: (E)(<)
      captures:
        1: entity.name.tag.escaped.perl
        2: punctuation.definition.tag.begin.perl
      push:
        - meta_content_scope: constant.character.escape.perl
        - include: comment-pod-format-body
    # italic text : I<italic>
    - match: (I)(<)
      captures:
        1: entity.name.tag.italic.perl
        2: punctuation.definition.tag.begin.perl
      push:
        - meta_content_scope: markup.italic.perl
        - include: comment-pod-format-body
    # filename : F<filename>
    - match: (F)(<)
      captures:
        1: entity.name.tag.filename.perl
        2: punctuation.definition.tag.begin.perl
      push:
        - meta_content_scope: string.unquoted.perl
        - include: comment-pod-format-body
    # hyperlink : L<label|url>
    - match: (L)(<)
      captures:
        1: entity.name.tag.link.perl
        2: punctuation.definition.tag.begin.perl
      push:
        - meta_content_scope: markup.underline.link.perl
        - include: comment-pod-format-body
    # non-breaking spaces : S<content>
    - match: (S)(<)
      captures:
        1: entity.name.tag.none-braeking.perl
        2: punctuation.definition.tag.begin.perl
      push:
        - include: comment-pod-format-body
    # index entry : X<title>
    - match: (X)(<)
      captures:
        1: entity.name.tag.index.perl
        2: punctuation.definition.tag.begin.perl
      push:
        - meta_content_scope: entity.name.label.perl
        - include: comment-pod-format-body

  comment-pod-format-body:
    - match: \>
      scope: punctuation.definition.tag.end.perl
      pop: true
    - include: comment-pod-formatting
    - include: literal-ltgt-nested

### [ DECLARATIONS ]##########################################################

  declarations:
      # KEYWORD package
      - match: \bpackage{{break}}
        scope: keyword.declaration.package.perl
      # KEYWORD 'my' and its friends
      - match: \b(?:local|my|our|state){{break}}
        scope: keyword.declaration.variable.perl
      # KEYWORD no
      - match: \bno{{break}}
        scope: keyword.declaration.no.perl
        push:
          - meta_scope: meta.no.perl
          - include: eol-pop
          - include: pragma
          - include: expressions
      # KEYWORD use
      - match: \buse{{break}}
        scope: keyword.control.import.use.perl
        push:
          - meta_scope: meta.use.perl
          - include: eol-pop
          - include: pragma
          - include: expressions
      # KEYWORD require
      - match: \brequire{{break}}
        scope: keyword.control.import.require.perl
        push:
          - meta_scope: meta.import.require.perl
          - include: eol-pop
          - include: expressions

  pragma:
    # SEE: http://perldoc.perl.org/index-pragmas.html
    #      http://perldoc.perl.org/perlmodlib.html#Pragmatic-Modules
    - match: |-
        \b(?x)
        (?:attributes|autodie(?:::(?:exception(?:::system)|hints|skip))?|autouse
          |base|bigint|bignum|bigrat|blib|bytes
          |charnames|constant
          |diagnostics
          |encoding
          |feature|fields|filetest
          |if|integer
          |less|lib|locale
          |mro
          |ok|open|ops|overload|overloading
          |parent
          |re
          |sigtrap|sort|strict|subs
          |threads|threads::shared
          |utf8
          |vars|vmsish
          |warnings|warnings::register){{break}}
      scope: storage.modifier.perl

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

  expressions:
    - include: blocks
    - include: groups
    - include: constants
    - include: class
    - include: operators
    - include: quoted-like
    - include: control
    - include: sub
    - include: variables
    - include: functions
    - include: comment-line
    # /<find>/<flags> statement at line start
    - match: ^ *(?=/.*[^\\]/)
      push: regexp-pop

### [ BLOCKS AND GROUPS ]#####################################################

  blocks:
    # can't push into scope due to HEREDOCs!
    - match: \{
      scope: punctuation.section.block.begin.perl
      push: regexp-pop
    - match: \}
      scope: punctuation.section.block.end.perl

  blocks-nested:
    - match: \{
      scope: punctuation.section.block.begin.perl
      push: [blocks-nested-body, regexp-pop]

  blocks-nested-body:
    - match: \}
      scope: punctuation.section.block.end.perl
      pop: true
    - include: expressions

  groups:
    # can't push into scope due to HEREDOCs!
    - match: \(
      scope: punctuation.section.group.begin.perl
      push: regexp-pop
    - match: \)
      scope: punctuation.section.group.end.perl

  groups-nested:
    - match: \{
      scope: punctuation.section.group.begin.perl
      push: [groups-nested-body, regexp-pop]

  groups-nested-body:
    - match: \}
      scope: punctuation.section.group.end.perl
      pop: true
    - include: expressions

### [ CONSTANTS ]#############################################################

  constants:
    - include: constants-numbers
    - include: constants-language
    - include: string
    - match: \b\w+\s*(?==>)
      scope: constant.other.key.perl

  constants-numbers:
    # SEE: http://perldoc.perl.org/perlnumber.html
    - match: 0b[01]+(?![\.\w+])
      scope: constant.numeric.binary.perl
    - match: 0x[\h_]+(?![\.\w+])
      scope: constant.numeric.hex.perl
    - include: constants-numbers-float
    - include: constants-numbers-integer

  constants-numbers-float:
    - match: (")([-+]?\d+\.\d+(?:e[-+]?\d+)?)(")
      scope: string.quoted.double.perl
      captures:
        1: punctuation.definition.string.begin.perl
        2: constant.numeric.float.perl
        3: punctuation.definition.string.end.perl
    - match: (')([-+]?\d+\.\d+(?:e[-+]?\d+)?)(')
      scope: string.quoted.single.perl
      captures:
        1: punctuation.definition.string.begin.perl
        2: constant.numeric.float.perl
        3: punctuation.definition.string.end.perl
    - match: (?:[-+]|\b)\d+\.\d+(?:e[-+]?\d+)?(?![\.\w+])
      scope: constant.numeric.float.perl

  constants-numbers-integer:
    - match: (")([-+]?\d+)(")
      scope: string.quoted.double.perl
      captures:
        1: punctuation.definition.string.begin.perl
        2: constant.numeric.integer.perl
        3: punctuation.definition.string.end.perl
    - match: (')([-+]?\d+)(')
      scope: string.quoted.single.perl
      captures:
        1: punctuation.definition.string.begin.perl
        2: constant.numeric.integer.perl
        3: punctuation.definition.string.end.perl
    - match: (?:[-+]|\b)\d+(?![\.\w+])
      scope: constant.numeric.integer.perl

  constants-language:
    - match: \b__(?:END|DATA|FILE|LINE|PACKAGE|SUB)__\b
      scope: constant.language.perl
    - match: \b(?:ARGV|ARGVOUT|STDERR|STDIN|STDOUT|DATA|IN|OUT){{break}}
      scope: constant.language.filehandle.perl
    - match: \b[A-Z0-9_]+{{break}}
      scope: constant.other.perl

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

  string:
    - include: string-quoted-backtick
    - include: string-quoted-double
    - include: string-quoted-single
    - include: string-format
    - include: string-heredoc

  string-quoted-backtick:
    - match: \`
      scope: punctuation.definition.string.begin.perl
      push:
        - meta_scope: string.quoted.backtick.perl
        - match: \`
          scope: punctuation.definition.string.end.perl
          pop: true
        - include: character-escape

  string-quoted-double:
    - match: \"
      scope: punctuation.definition.string.begin.perl
      push:
        - meta_scope: string.quoted.double.perl
        - match: \"
          scope: punctuation.definition.string.end.perl
          pop: true
        - include: character-escape

  string-quoted-single:
    - match: \'
      scope: punctuation.definition.string.begin.perl
      push:
        - meta_scope: string.quoted.single.perl
        - match: \'
          scope: punctuation.definition.string.end.perl
          pop: true
        - include: character-escape

  string-format:
    # SEE: http://perldoc.perl.org/perlform.html
    - match: ^\s*(format)\s+(\w+)\s*(=)\s*$
      captures:
        1: storage.type.format.perl
        2: variable.other.perl
        3: keyword.operator.assignment.perl
      push:
        - meta_scope: meta.block.format.perl
        - meta_content_scope: string.unquoted.format.perl
        - match: ^\.(?=\s*$)
          scope: punctuation.terminator.format.perl
          pop: true
        - match: \.{3}
          scope: constant.character.escape.perl
        - match: ~{1,2}(?!~)
          scope: constant.character.escape.perl
        - match: '[@\^]\*'
          scope: variable.parameter.multiline-width.perl
        - match: (\@)[0#\.|<>]+
          scope: variable.parameter.regular-field.perl
          captures:
            1: punctuation.definition.placeholder.begin.perl
        - match: (\^)[0#\.|<>]+
          scope: variable.parameter.special-field.perl
          captures:
            1: punctuation.definition.placeholder.begin.perl
        - include: variables

  string-heredoc:
    # SEE: http://www.perlmeme.org/howtos/syntax/here_document.html
    - match: (<<) *(?=['"]? *{{identifier}})
      captures:
        1: keyword.operator.heredoc.perl
      push: [string-heredoc-meta, string-heredoc-body]

  string-heredoc-meta:
    - meta_scope: meta.heredoc.perl
    - include: immediately-pop

  string-heredoc-body:
    # embedded css
    - match: ((['"]?)( *CSS)(\2))
      captures:
        1: string.other.heredoc.perl
        2: punctuation.definition.string.begin.perl
        3: constant.language.heredoc.css.perl
        4: punctuation.definition.string.end.perl
      set: [string-heredoc-css, string-heredoc-expr]
    # embedded html
    - match: ((['"]?)( *HTML)(\2))
      captures:
        1: string.other.heredoc.perl
        2: punctuation.definition.string.begin.perl
        3: constant.language.heredoc.html.perl
        4: punctuation.definition.string.end.perl
      set: [string-heredoc-html, string-heredoc-expr]
    # embedded javascript
    - match: ((['"]?)( *JAVASCRIPT)(\2))
      captures:
        1: string.other.heredoc.perl
        2: punctuation.definition.string.begin.perl
        3: constant.language.heredoc.js.perl
        4: punctuation.definition.string.end.perl
      set: [string-heredoc-javascript, string-heredoc-expr]
    # embedded json
    - match: ((['"]?)( *JSON)(\2))
      captures:
        1: string.other.heredoc.perl
        2: punctuation.definition.string.begin.perl
        3: constant.language.heredoc.json.perl
        4: punctuation.definition.string.end.perl
      set: [string-heredoc-json, string-heredoc-expr]
    # embedded sql
    - match: ((['"]?)( *SQL)(\2))
      captures:
        1: string.other.heredoc.perl
        2: punctuation.definition.string.begin.perl
        3: constant.language.heredoc.sql.perl
        4: punctuation.definition.string.end.perl
      set: [string-heredoc-sql, string-heredoc-expr]
    # embedded xml
    - match: ((['"]?)( *XML)(\2))
      captures:
        1: string.other.heredoc.perl
        2: punctuation.definition.string.begin.perl
        3: constant.language.heredoc.xml.perl
        4: punctuation.definition.string.end.perl
      set: [string-heredoc-xml, string-heredoc-expr]
    # any other tag like (EOD, EOT, FOO, ...) is handled as string
    - match: ((['"]?)( *{{identifier}})(\2))
      captures:
        1: string.other.heredoc.perl
        2: punctuation.definition.string.begin.perl
        3: constant.language.heredoc.plain.perl
        4: punctuation.definition.string.end.perl
      set: [string-heredoc-other, string-heredoc-expr]
    - include: else-pop

  string-heredoc-expr:
    # The rest of the line right after the heredoc tag needs to be handled
    # as ordinary perl. The embedded syntax starts at the next line.
    - clear_scopes: 1 # remove 'string.quoted'
    - match: $
      pop: true
    - include: expressions

  string-heredoc-css:
    - meta_content_scope: source.css.embedded.perl
    # pop off only, if keyword is indented correctly
    - match: ^\3$
      scope: constant.language.heredoc.css.perl
      pop: true
    - match: ''
      embed: scope:source.css
      escape: (?=^ *CSS$)

  string-heredoc-html:
    - meta_content_scope: text.html.embedded.perl
    - match: ^\3$
      scope: constant.language.heredoc.html.perl
      pop: true
    - match: ''
      embed: scope:text.html.basic
      escape: (?=^ *HTML$)

  string-heredoc-javascript:
    - meta_content_scope: source.js.embedded.perl
    - match: ^\3$
      scope: constant.language.heredoc.js.perl
      pop: true
    - match: ''
      embed: scope:source.js
      escape: (?=^ *JAVASCRIPT$)

  string-heredoc-json:
    - meta_content_scope: source.json.embedded.perl
    - match: ^\3$
      scope: constant.language.heredoc.json.perl
      pop: true
    - match: ''
      embed: scope:source.json
      escape: (?=^ *JSON$)

  string-heredoc-sql:
    - meta_content_scope: source.sql.embedded.perl
    - match: ^\3$
      scope: constant.language.heredoc.sql.perl
      pop: true
    - match: ''
      embed: scope:source.sql
      escape: (?=^ *SQL$)

  string-heredoc-xml:
    - meta_content_scope: text.xml.embedded.perl
    - match: ^\3$
      scope: constant.language.heredoc.xml.perl
      pop: true
    - match: ''
      embed: scope:text.xml
      escape: (?=^ *XML$)

  string-heredoc-other:
    - meta_content_scope: string.quoted.other.perl
    - match: ^\3$
      scope: constant.language.heredoc.plain.perl
      pop: true

### [ CLASSES ]################################################################

  class:
    - match: '{{module}}(?= *(?:::|[#;]|$))'
      scope: support.class.perl
      push: members-pop

  members-pop:
    - match: ' *(::) *({{module}})'
      captures:
        1: punctuation.accessor.double-colon.perl
        2: support.class.perl
    - match: ' *(::) *({{identifier}})'
      captures:
        1: punctuation.accessor.double-colon.perl
        2: variable.other.member.perl
    - include: else-pop

### [ CONTROL KEYWORDS ]#######################################################

  control:
    - match: \b(?:default|else|elsif|given|if|unless|when){{break}}
      scope: keyword.control.conditional.perl
      push: regexp-pop
    - match: \b(?:break|caller|continue|die|dump|exit|goto|last|next|redo|return|wait){{break}}
      scope: keyword.other.flow.perl
      push: regexp-pop
    - match: \b(?:do|for|foreach|until|while){{break}}
      scope: keyword.control.flow.perl
      push: regexp-pop
    - include: label

  label:
    - match: ({{identifier}})(:)(?!:)
      captures:
        1: entity.name.label.perl
        2: punctuation.separator.perl
      push: regexp-pop

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

  operators:
    # SEE: https://www.tutorialspoint.com/perl/perl_operators.htm
    - match: ','
      scope: punctuation.separator.sequence.perl
      push: regexp-pop
    - match: ;
      scope: punctuation.terminator.statement.perl
      push: regexp-pop
    - match: -[rwx0RWXOezsfdlpSbctugkTBMAC]\b
      scope: keyword.operator.filetest.perl
      push: regexp-pop
    - match: '->'
      scope: keyword.operator.arrow.perl
      push: regexp-pop
    - match: '[!~=]~'
      scope: keyword.operator.binary.perl
      push: regexp-pop
    - match: <=>|//|\&\&|\|\||==|!=|>=|<=|[<>:!?]
      scope: keyword.operator.logical.perl
      push: regexp-pop
    - match: '\*\*=|[-+*/%]='
      scope: keyword.operator.assignment.perl
      push: regexp-pop
    - match: '[-+*]{1,2}|/'
      scope: keyword.operator.arithmetic.perl
      push: regexp-pop
    - match: '[&|^~]'
      scope: keyword.operator.bitwise.perl
      push: regexp-pop
    - match: =>?
      scope: keyword.operator.assignment.perl
      push: regexp-pop
    - match: \.\.
      scope: keyword.operator.range.perl
      push: regexp-pop
    # string concat
    - match: \.=?
      scope: keyword.operator.concat.perl
      push: regexp-pop
    # string concation
    #  "string" x 10
    - match: \bx\b
      scope: keyword.operator.arithmetic.perl
      push: regexp-pop
    - match: \b(and|or|xor|as|cmp|eq|gt|ge|lg|le|ne|not){{break}}
      scope: keyword.operator.logical.perl
      push: regexp-pop

### [ QUOTED LIKE ]###########################################################

  quoted-like:
    # SEE: http://perldoc.perl.org/perlop.html#Regexp-Quote-Like-Operators
    - include: quoted-like-match
    - include: quoted-like-replace

  quoted-like-match:
    - match: \bq[qwx]?\b
      scope: support.function.perl
      push:
        - quoted-like-meta
        - quoted-like-args-find-literal
    - match: \b(m|qr)(?=\s*[\(\[\{<])
      scope: support.function.perl
      push:
        - quoted-like-meta
        - quoted-like-flags
        - quoted-like-args-find-rexexp
    - match: \b(m|qr)({{regexp_delim}})
      captures:
        0: meta.function-call.perl
        1: support.function.perl
        2: punctuation.section.generic.begin.perl
      embed_scope: meta.function-call.perl string.regexp.perl
      embed: scope:source.regexp
      escape: (?<!(?<!\\)\\)(\2)({{regexp_flags}})?
      escape_captures:
        0: meta.function-call.perl
        1: punctuation.section.generic.end.perl
        2: constant.language.flags.regexp.perl

  quoted-like-replace:
    - match: \b(s|ty|y)(?=\s*[\(\[\{<])
      scope: support.function.perl
      push:
        - quoted-like-meta
        - quoted-like-flags
        - quoted-like-args-replace
        - quoted-like-args-find-rexexp
    - match: \b(s|tr|y)({{regexp_delim}})
      captures:
        0: meta.function-call.perl
        1: support.function.perl
        2: punctuation.section.generic.begin.perl
      embed_scope: meta.function-call.perl string.regexp.perl
      embed: scope:source.regexp
      escape: ((?<!(?<!\\)\\)\2)(.*?)((?<!(?<!\\)\\)\2)({{regexp_flags}})?
      escape_captures:
        0: meta.function-call.perl
        1: punctuation.separator.sequence.perl
        2: string.unquoted.perl
        3: punctuation.section.generic.end.perl
        4: constant.language.flags.regexp.perl

  quoted-like-meta:
    - meta_scope: meta.function-call.perl
    - include: immediately-pop

  quoted-like-flags:
    - match: '{{regexp_flags}}'
      scope: constant.language.flags.regexp.perl
      pop: true
    - include: else-pop

  quoted-like-args-find-rexexp:
    - match: \{
      scope: punctuation.section.braces.begin.perl
      set:
        - meta_scope: meta.braces.perl
        - meta_content_scope: string.regexp.perl
        - match: \}
          scope: punctuation.section.braces.end.perl
          pop: true
        - include: scope:source.regexp#base-literal-extended
    - match: \[
      scope: punctuation.section.brackets.begin.perl
      set:
        - meta_scope: meta.brackets.perl
        - meta_content_scope: string.regexp.perl
        - match: \]
          scope: punctuation.section.brackets.end.perl
          pop: true
        - include: scope:source.regexp#base-literal-extended
    - match: \<
      scope: punctuation.section.generic.begin.perl
      set:
        - meta_scope: meta.generic.perl
        - meta_content_scope: string.regexp.perl
        - match: \>
          scope: punctuation.section.generic.end.perl
          pop: true
        - include: scope:source.regexp#base-literal-extended
    - match: \(
      scope: punctuation.section.parens.begin.perl
      set:
        - meta_scope: meta.parens.perl
        - meta_content_scope: string.regexp.perl
        - match: \)
          scope: punctuation.section.parens.end.perl
          pop: true
        - include: scope:source.regexp#base-literal-extended
    - include: else-pop

  quoted-like-args-find-literal:
    - include: literal-braces-pop
    - include: literal-brackets-pop
    - include: literal-ltgt-pop
    - include: literal-parens-pop
    - include: literal-generic-pop
    - include: else-pop

  quoted-like-args-replace:
    - include: literal-braces-pop
    - include: literal-brackets-pop
    - include: literal-ltgt-pop
    - include: literal-parens-pop
    - include: else-pop

  literal-braces-pop:
    - match: \{
      scope: punctuation.section.braces.begin.perl
      set:
        - meta_scope: meta.braces.perl
        - meta_content_scope: string.unquoted.perl
        - match: \}
          scope: punctuation.section.braces.end.perl
          pop: true
        - include: literal-braces-nested
        - include: character-escape

  literal-braces-nested:
    - match: \{
      push:
        - match: \}
          pop: true
        - include: literal-braces-nested
        - include: character-escape

  literal-brackets-pop:
    - match: \[
      scope: punctuation.section.brackets.begin.perl
      set:
        - meta_scope: meta.brackets.perl
        - meta_content_scope: string.unquoted.perl
        - match: \]
          scope: punctuation.section.brackets.end.perl
          pop: true
        - include: literal-brackets-nested
        - include: character-escape

  literal-brackets-nested:
    - match: \[
      push:
        - match: \]
          pop: true
        - include: literal-brackets-nested
        - include: character-escape

  literal-ltgt-pop:
    - match: \<
      scope: punctuation.section.generic.begin.perl
      set:
        - meta_scope: meta.generic.perl
        - meta_content_scope: string.unquoted.perl
        - match: \>
          scope: punctuation.section.generic.end.perl
          pop: true
        - include: literal-ltgt-nested
        - include: character-escape

  literal-ltgt-nested:
    - match: \<
      push:
        - match: \>
          pop: true
        - include: literal-ltgt-nested
        - include: character-escape

  literal-parens-pop:
    - match: \(
      scope: punctuation.section.parens.begin.perl
      set:
        - meta_scope: meta.parens.perl
        - meta_content_scope: string.unquoted.perl
        - match: \)
          scope: punctuation.section.parens.end.perl
          pop: true
        - include: literal-parens-nested
        - include: character-escape

  literal-parens-nested:
    - match: \(
      push:
        - match: \)
          pop: true
        - include: literal-parens-nested
        - include: character-escape

  literal-generic-pop:
    - match: ({{regexp_delim}})
      scope: punctuation.section.generic.begin.perl
      set:
        - meta_scope: meta.generic.perl
        - meta_content_scope: string.unquoted.perl
        - match: \1
          scope: punctuation.section.generic.end.perl
          pop: true
        - include: character-escape

  character-escape:
    - match: \\.
      scope: constant.character.escape.perl

### [ REGEXP ] ###############################################################

  regexp-pop:
    # /<pattern>/<flags>
    - match: /
      scope: punctuation.section.generic.begin.perl
      embed_scope: string.regexp.perl
      embed: scope:source.regexp
      escape: (?<!(?<!\\)\\)(/)({{regexp_flags}})?
      escape_captures:
        1: punctuation.section.generic.end.perl
        2: constant.language.flags.regexp.perl
    - include: else-pop

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

  functions:
    - match: |-
        \b(?x:
           abs|accept|alarm|atan2|bind|binmode|bless|chdir|chmod
          |chomp|chop|chown|chr|chroot|close|closedir|connect|cos|crypt
          |dbmclose|dbmopen|defined|delete|each|endgrent|endhostent
          |endnetent|endprotoent|endpwent|endservent|eof|eval|evalbytes|exec
          |exists|exp|fc|fcntl|fileno|flock|fork|formline|getc
          |getgrent|getgrgid|getgrnam|gethostbyaddr|gethostbyname|gethostent
          |getlogin|getnetbyaddr|getnetbyname|getnetent|getpeername|getpgrp
          |getppid|getpriority|getprotobyname|getprotobynumber|getprotoent
          |getpwent|getpwnam|getpwuid|getservbyname|getservbyport|getservent
          |getsockname|getsockopt|glob|gmtime|grep|hex|index|int|ioctl|join
          |keys|kill|lc|lcfirst|length|link|listen|localtime|lock|log
          |lstat|map|mkdir|msgctl|msgget|msgrcv|msgsnd|oct|open|opendir|ord
          |pack|pipe|pop|pos|print|printf|prototype|push|quotemeta
          |rand|read|readdir|readline|readlink|readpipe|recv|ref|rename
          |reset|reverse|rewinddir|rindex|rmdir|say|scalar|seek|seekdir|select
          |semctl|semget|semop|send|setgrent|sethostent|setnetent|setpgrp
          |setpriority|setprotoent|setpwent|setservent|setsockopt|shift|shmctl
          |shmget|shmread|shmwrite|shutdown|sin|sleep|socket|socketpair|sort
          |splice|split|sprintf|sqrt|srand|stat|study|substr|symlink|syscall
          |sysopen|sysread|sysseek|system|syswrite|tell|telldir|tie|tied|time
          |times|truncate|uc|ucfirst|umask|undef|unlink|unpack|unshift|untie
          |utime|values|vec|wait|waitpid|wantarray|warn|write
        ){{break}}
      scope: support.function.perl
      push: regexp-pop
    - match: ^\s*(AUTOLOAD|BEGIN|CHECK|DESTROY|END|INIT|UNITCHECK){{break}}
      scope: meta.function.perl
      captures:
        1: entity.name.function.perl
    - match: \b{{member}}{{break}}
      scope: variable.function.perl
      push: regexp-pop

### [ SUB ]###################################################################

  sub:
    - match: \bsub\b
      scope: keyword.control.sub.perl
      push: sub-name

  sub-name:
    - meta_scope: meta.function.perl
    - match: '{{identifier}}'
      scope: entity.name.function.perl
      set: sub-expect-parameters
    - include: sub-expect-block

  sub-expect-parameters:
    - meta_content_scope: meta.function.perl
    - match: (?=\()
      set: sub-parameters
    - include: sub-expect-block
    - match: \S
      scope: invalid.illegal.function-name.perl

  sub-parameters:
    - match: \(
      scope: punctuation.section.group.begin.perl
      set:
        - meta_scope: meta.function.parameters.perl
        - match: \)
          scope: punctuation.section.group.end.perl
          set: sub-expect-block
        - match: '[\$\@\*;][^\s,\)]*'
          scope: variable.parameter.perl
        - include: expressions

  sub-expect-block:
    - meta_content_scope: meta.function.perl
    - include: term-pop
    - match: $|(?=\{)
      set:
        - match: \{
          scope: punctuation.section.block.begin.perl
          set: [sub-block-body, regexp-pop]
        - include: comment-line
        - include: comment-pod
        - match: (?=\S)
          pop: true

  sub-block-body:
    - meta_scope: meta.function.perl meta.block.perl
    - match: \}
      scope: punctuation.section.block.end.perl
      pop: true
    - include: main

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

  variables:
    # SEE: http://perldoc.perl.org/perlvar.html
    - match: (\$)&(?!\w)
      scope: variable.other.regexp.match.perl
      captures:
        1: punctuation.definition.variable.perl
    - match: (\$)`(?!\w)
      scope: variable.other.regexp.pre-match.perl
      captures:
        1: punctuation.definition.variable.perl
    - match: (\$)\'(?!\w)
      scope: variable.other.regexp.post-match.perl
      captures:
        1: punctuation.definition.variable.perl
    - match: (\$)\+(?!\w)
      scope: variable.other.regexp.last-paren-match.perl
      captures:
        1: punctuation.definition.variable.perl
    - match: (\$)\"(?!\w)
      scope: variable.other.readwrite.list-separator.perl
      captures:
        1: punctuation.definition.variable.perl
    - match: (\$)0\b
      scope: variable.other.predefined.program-name.perl
      captures:
        1: punctuation.definition.variable.perl
    - match: (\$)[0-9]+\b
      scope: variable.other.subpattern.perl
      captures:
        1: punctuation.definition.variable.perl
    # $Module::SubModule::member
    # $::SubModule::member
    - match: ([\$\@\%]#?)({{module}})?(?= *::)
      captures:
        1: punctuation.definition.variable.perl
        2: support.class.perl
      push:
        - meta_scope: variable.other.readwrite.global.perl
        - include: members-pop
    - match: (\$)(\^[A-Z]|[_ab\*\.\/\|,\\;#%=\-~^:?!\$<>\(\)\[\]@])(?!\w)
      scope: variable.other.predefined.perl
      captures:
        1: punctuation.definition.variable.perl
    - match: ([\$\@\%]#?)(\w+)\b
      scope: variable.other.readwrite.global.perl
      captures:
        1: punctuation.definition.variable.perl
    - match: ([\$\@\%])(\{)
      scope: punctuation.definition.variable.begin.perl
      push:
        - meta_scope: meta.braces.perl variable.other.readwrite.global.perl
        - match: \}
          scope: punctuation.definition.variable.end.perl
          pop: true
        - include: blocks-nested
        - include: expressions