File Coverage

blib/lib/PPR.pm

Criterion	Covered	Total	%
statement	46	49	93.8
branch	4	6	66.6
condition	11	14	78.5
subroutine	16	16	100.0
pod			n/a
total	77	85	90.5

package PPR;

use 5.010;
use if $] < 5.018004, re => 'eval';

BEGIN {
    if ($] >= 5.020 && $] <= 5.021) {
        say {STDERR} <<"        END_WARNING"
        Warning: This program is running under Perl $^V and uses the PPR module.
                 Due to an unresolved issue with compilation of large regexes
                 in this version of Perl, your code is likely to compile
                 extremely slowly (i.e. it may take more than a minute).
                 PPR is being loaded at ${\join ' line ', (caller 2)[1,2]}.
        END_WARNING
    }
}
use warnings;
our $VERSION = '0.000012';
use utf8;

# Class for $PPR::ERROR objects...
{ package PPR::ERROR;

  use overload q{""} => 'source', q{0+} => 'line', fallback => 1;

  sub new {
      my ($class, %obj) = @_;
      return bless \%obj, $class;
  }

  sub prefix { return shift->{prefix} }

  sub source { return shift->{source} }

  sub line   { my $self = shift;
               my $offset = $self->{line} // shift // 1;
               return $offset + $self->{prefix} =~ tr/\n//;
              }

  sub origin { my $self = shift;
               my $line = shift // 0;
               my $file = shift // "";
               return bless { %{$self}, line => $line, file => $file }, ref($self);
             }

  sub diagnostic { my $self = shift;
                   my $line = defined $self->{line}
                                    ? $self->{line} + $self->{prefix} =~ tr/\n//
                                    : 0;
                   my $file = $self->{file} // q{};
                   return q{} if eval "no strict;\n"
                                    . "#line $line $file\n"
                                    . "sub{ $self->{source} }";
                   my $diagnostic = $@;
                   $diagnostic =~ s{ \s*+ \bat \s++ \( eval \s++ \d++ \) \s++ line \s++ 0,
                                   | \s*+ \( eval \s++ \d++ \)
                                   | \s++ \Z
                                   }{}gx;
                   return $diagnostic;
                 }
}

# Define the grammar...
our $GRAMMAR = qr{
(?(DEFINE)
    (?
        \x{FEFF}?+      # Optional BOM marker
        (?>(?&PerlOWS))
        (?: (?>(?&PerlStatement)) (?&PerlOWS) )*+
    ) # End of rule

    (?
            (?: (?>(?&PerlPod))   (?&PerlOWS) )?+
        (?>
            (?: (?>(?&PerlLabel)) (?&PerlOWS) )?+
            (?: (?>(?&PerlPod))   (?&PerlOWS) )?+
            (?>
                (?&PerlKeyword)
            |
                # Inlined (?&PerlSubroutineDeclaration)...
                (?>
                    sub \b                             (?>(?&PerlOWS))
                    (?>(?&PerlOldQualifiedIdentifier))    (?&PerlOWS)
                |
                    AUTOLOAD                              (?&PerlOWS)
                |
                    DESTROY                               (?&PerlOWS)
                )
                (?:
                    (?>
                        (?&PerlParenthesesList)              # Parameter list
                    |
                        \( [^)]*+ \)                         # Prototype (
                    )                          (?&PerlOWS)
                )?+
                (?: (?>(?&PerlAttributes))     (?&PerlOWS)  )?+
                (?> ; | (?&PerlBlock) )
            |
                # Inlined (?&PerlUseStatement)...
                (?: use | no ) (?>(?&PerlNWS))
                (?>
                    (?&PerlVersionNumber)
                |
                    (?>(?&PerlQualifiedIdentifier))
                    (?: (?>(?&PerlNWS)) (?&PerlVersionNumber)
                        (?! (?>(?&PerlOWS)) (?> (?&PerlInfixBinaryOperator) | (?&PerlComma) | \? ) )
                    )?+
                    (?: (?>(?&PerlNWS)) (?&PerlPod) )?+
                    (?: (?>(?&PerlOWS)) (?&PerlExpression) )?+
                )
                (?>(?&PerlOWS)) (?> ; | (?= \} | \z ))
            |
                # Inlined (?&PerlPackageDeclaration)...
                package
                    (?>(?&PerlNWS)) (?>(?&PerlQualifiedIdentifier))
                (?: (?>(?&PerlNWS)) (?&PerlVersionNumber) )?+
                    (?>(?&PerlOWS)) (?> ; | (?&PerlBlock) | (?= \} | \z ))
            |
                (?&PerlControlBlock)
            |
                (?&PerlFormat)
            |
                (?>(?&PerlExpression))          (?>(?&PerlOWS))
                (?&PerlStatementModifier)?+     (?>(?&PerlOWS))
                (?> ; | (?= \} | \z ))
            |
                (?&PerlBlock)
            |
                ;
            )

        | # A yada-yada...
            \.\.\. (?>(?&PerlOWS))
            (?> ; | (?= \} | \z ))

        | # Just a Label...
            (?>(?&PerlLabel)) (?>(?&PerlOWS))
            (?> ; | (?= \} | \z ))

        | # Just an empty statement...
            (?>(?&PerlOWS)) ;

        | # An error (report it, if it's the first)...
            (?(?{ !defined $PPR::ERROR })
                (?> (?&PerlOWS) )
                (?! (?: \} | \z ) )
                (?{ pos() })
                ( (?&PerlExpression) (?&PerlOWS) [^\n]++ | [^;\}]++ )
                (?{ $PPR::ERROR //= PPR::ERROR->new(source => $^N, prefix => substr($_, 0, $^R) ) })
                (?!)
            )
        )
    ) # End of rule

    (?
       (?>
           sub \b                             (?>(?&PerlOWS))
           (?>(?&PerlOldQualifiedIdentifier))    (?&PerlOWS)
       |
           AUTOLOAD
       |
           DESTROY
       )
       (?:
           (?>
               (?&PerlParenthesesList)                   # Parameter list
           |
               \( [^)]*+ \)                         # Prototype (
           )                          (?&PerlOWS)
       )?+
       (?: (?>(?&PerlAttributes))     (?&PerlOWS)  )?+
       (?> ; | (?&PerlBlock) )
    ) # End of rule

    (?
       (?: use | no ) (?>(?&PerlNWS))
       (?>
           (?&PerlVersionNumber)
       |
           (?>(?&PerlQualifiedIdentifier))
           (?: (?>(?&PerlNWS)) (?&PerlVersionNumber)
               (?! (?>(?&PerlOWS)) (?> (?&PerlInfixBinaryOperator) | (?&PerlComma) | \? ) )
           )?+
           (?: (?>(?&PerlNWS)) (?&PerlPod) )?+
           (?: (?>(?&PerlOWS)) (?&PerlExpression) )?+
       )
       (?>(?&PerlOWS)) (?> ; | (?= \} | \z ))
    ) # End of rule

    (?
       return \b (?: (?>(?&PerlOWS)) (?&PerlExpression) )?+
       (?>(?&PerlOWS)) (?> ; | (?= \} | \z ))
    ) # End of rule

    (?
       package
           (?>(?&PerlNWS)) (?>(?&PerlQualifiedIdentifier))
       (?: (?>(?&PerlNWS)) (?&PerlVersionNumber) )?+
           (?>(?&PerlOWS)) (?> ; | (?&PerlBlock) | (?= \} | \z ))
    ) # End of rule

    (?
                            (?>(?&PerlLowPrecedenceNotExpression))
        (?: (?>(?&PerlOWS)) (?>(?&PerlLowPrecedenceInfixOperator))
            (?>(?&PerlOWS))    (?&PerlLowPrecedenceNotExpression)  )*+
    ) # End of rule


    (?
        (?: not \b (?&PerlOWS) )*+  (?&PerlCommaList)
    ) # End of rule

    (?
                (?>(?&PerlAssignment))  (?>(?&PerlOWS))
        (?:
            (?: (?>(?&PerlComma))          (?&PerlOWS)   )++
                (?>(?&PerlAssignment))  (?>(?&PerlOWS))
        )*+
            (?: (?>(?&PerlComma))          (?&PerlOWS)   )*+
    ) # End of rule

    (?
                            (?>(?&PerlConditionalExpression))
        (?:
            (?>(?&PerlOWS)) (?>(?&PerlAssignmentOperator))
            (?>(?&PerlOWS))    (?&PerlConditionalExpression)
        )*+
    ) # End of rule

    (?
    (?
        (?>(?&PerlBinaryExpression))
        (?:
            (?>(?&PerlOWS)) \? (?>(?&PerlOWS)) (?>(?&PerlAssignment))
            (?>(?&PerlOWS))  : (?>(?&PerlOWS))    (?&PerlConditionalExpression)
        )?+
    ) # End of rule
    ) # End of rule

    (?
                            (?>(?&PerlPrefixPostfixTerm))
        (?: (?>(?&PerlOWS)) (?>(?&PerlInfixBinaryOperator))
            (?>(?&PerlOWS))    (?&PerlPrefixPostfixTerm) )*+
    ) # End of rule

    (?
        (?: (?>(?&PerlPrefixUnaryOperator))  (?&PerlOWS) )*+
        (?>(?&PerlTerm))
        (?:
            (?>(?&PerlOWS)) -> (?>(?&PerlOWS))
            (?>
                (?> (?&PerlQualifiedIdentifier) | (?&PerlVariableScalar) )
                (?: (?>(?&PerlOWS)) (?&PerlParenthesesList) )?+

            |   (?&PerlParenthesesList)
            |   (?&PerlArrayIndexer)
            |   (?&PerlHashIndexer)
            )

            (?:
                (?>(?&PerlOWS))
                (?>
                    ->  (?>(?&PerlOWS))
                    (?> (?&PerlQualifiedIdentifier) | (?&PerlVariableScalar) )
                    (?: (?>(?&PerlOWS)) (?&PerlParenthesesList) )?+
                |
                    (?: -> (?&PerlOWS) )?+
                    (?> (?&PerlParenthesesList)
                    |   (?&PerlArrayIndexer)
                    |   (?&PerlHashIndexer)
                    )
                )
            )*+
            (?:
                (?>(?&PerlOWS)) -> (?>(?&PerlOWS)) [\@%]
                (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) )
            )?+
        )?+
        (?: (?>(?&PerlOWS)) (?&PerlPostfixUnaryOperator) )?+
    ) # End of rule

    (?
        (?>
            \\?+ [\$\@%] (?>(?&PerlOWS)) (?&PerlIdentifier)
        |
            \(                                                                     (?>(?&PerlOWS))
                (?> \\?+ [\$\@%] (?>(?&PerlOWS)) (?&PerlIdentifier) | undef )      (?>(?&PerlOWS))
                (?:
                    (?>(?&PerlComma))                                              (?>(?&PerlOWS))
                    (?> \\?+ [\$\@%] (?>(?&PerlOWS)) (?&PerlIdentifier) | undef )  (?>(?&PerlOWS))
                )*+
                (?: (?>(?&PerlComma)) (?&PerlOWS) )?+
            \)
        )
    ) # End of rule

    (?
        (?>
            # Inlined (?&PerlReturnStatement)...
            return \b (?>(?&PerlOWS)) (?&PerlExpression)
        |
            # Inlined (?&PerlVariableDeclaration)...
            (?> my | state | our ) \b           (?>(?&PerlOWS))
            (?: (?&PerlQualifiedIdentifier)        (?&PerlOWS)  )?+
            (?>(?&PerlLvalue))                  (?>(?&PerlOWS))
            (?&PerlAttributes)?+
        |
            (?&PerlAnonymousSubroutine)
        |
            (?&PerlVariable)
        |
            (?>(?&PerlNullaryBuiltinFunction))  (?! (?>(?&PerlOWS)) \( )
        |
            # Inlined (?&PerlDoBlock) and (?&PerlEvalBlock)...
            (?> do | eval ) (?>(?&PerlOWS)) (?&PerlBlock)
        |
            (?&PerlCall)
        |
            (?&PerlTypeglob)
        |
            (?>(?&PerlParenthesesList))
            (?: (?>(?&PerlOWS)) (?&PerlArrayIndexer) )?+
            (?:
                (?>(?&PerlOWS))
                (?>
                    (?&PerlArrayIndexer)
                |   (?&PerlHashIndexer)
                )
            )*+
        |
            (?&PerlAnonymousArray)
        |
            (?&PerlAnonymousHash)
        |
            (?&PerlDiamondOperator)
        |
            (?&PerlContextualMatch)
        |
            (?&PerlQuotelikeS)
        |
            (?&PerlQuotelikeTR)
        |
            (?&PerlQuotelikeQX)
        |
            (?&PerlLiteral)
        )
    ) # End of rule

    (?
        (?> # Conditionals...
            (?> if | unless ) \b            (?>(?&PerlOWS))
            (?>(?&PerlParenthesesList))          (?>(?&PerlOWS))
            (?>(?&PerlBlock))

            (?:
                                            (?>(?&PerlOWS))
                (?: (?>(?&PerlPod))            (?&PerlOWS)   )*+
                    elsif \b                (?>(?&PerlOWS))
                    (?>(?&PerlParenthesesList))  (?>(?&PerlOWS))
                    (?&PerlBlock)
            )*+

            (?:
                                            (?>(?&PerlOWS))
                (?: (?>(?&PerlPod))            (?&PerlOWS)  )*+
                    else \b                 (?>(?&PerlOWS))
                    (?&PerlBlock)
            )?+

        |   # Loops...
            (?>
                for(?:each)?+ \b
                (?>(?&PerlOWS))
                (?:
                    (?:
                        (?: \\ (?>(?&PerlOWS))      (?> my | our | state )?+
                        |   (?> my | our | state )  (?: (?>(?&PerlOWS)) \\ )?+
                        )?+
                        (?>(?&PerlOWS)) (?&PerlVariableScalar)
                    )?+
                    (?>(?&PerlOWS))
                    (?> (?&PerlParenthesesList) | (?&PerlQuotelikeQW) )
                |
                    (?&PPR_three_part_list)
                )
            |
                (?> while | until) \b (?>(?&PerlOWS))
                (?&PerlParenthesesList)
            )

            (?>(?&PerlOWS))
            (?>(?&PerlBlock))

            (?:
                (?>(?&PerlOWS))   continue
                (?>(?&PerlOWS))   (?&PerlBlock)
            )?+

        | # Phasers...
            (?> BEGIN | END | CHECK | INIT | UNITCHECK ) \b   (?>(?&PerlOWS))
            (?&PerlBlock)

        | # Switches...
            (?> given | when ) \b                             (?>(?&PerlOWS))
            (?>(?&PerlParenthesesList))                            (?>(?&PerlOWS))
            (?&PerlBlock)
        |
            default                                           (?>(?&PerlOWS))
            (?&PerlBlock)
        )
    ) # End of rule

    (?
        format
        (?: (?>(?&PerlNWS))  (?&PerlQualifiedIdentifier)  )?+
            (?>(?&PerlOWS))  = [^\n]*+
            (?&PPR_newline_and_heredoc)
        (?:
            (?! \. \n )
            [^\n\$\@]*+
            (?:
                (?>
                    (?= \$ (?! \s ) )  (?&PerlScalarAccessNoSpace)
                |
                    (?= \@ (?! \s ) )  (?&PerlArrayAccessNoSpace)
                )
                [^\n\$\@]*+
            )*+
            (?&PPR_newline_and_heredoc)
        )*+
        \. (?&PerlEndOfLine)
    ) # End of rule

    (?
        (?> if | for(?:each)?+ | while | unless | until | when )
        \b
        (?>(?&PerlOWS))
        (?&PerlExpression)
    ) # End of rule

    (?
        \{                             (?>(?&PerlOWS))
            (?: (?>(?&PerlStatement))     (?&PerlOWS)   )*+
            (?: (?>(?&PerlPod))           (?&PerlOWS)   )?+
        \}
    ) # End of rule

    (?
        (?>
            [&]                                    (?>(?&PerlOWS))
            (?> (?&PerlBlock)
            |   (?&PerlVariableScalar)
            |   (?&PerlQualifiedIdentifier)
            )                                      (?>(?&PerlOWS))
            (?:
                \(                                 (?>(?&PerlOWS))
                    (?: (?>(?&PerlExpression))        (?&PerlOWS)   )?+
                \)
            )?+
        |
            - (?>(?&PPR_filetest_name))            (?>(?&PerlOWS))
            (?&PerlPrefixPostfixTerm)?+
        |
            (?>(?&PerlBuiltinFunction))            (?>(?&PerlOWS))
            (?>
                \(                                 (?>(?&PerlOWS))
                    (?>
                        (?= (?>(?&PPR_non_reserved_identifier))
                            (?>(?&PerlOWS))
                            (?! \( | (?&PerlComma) )
                        )
                        (?&PerlCall)
                    |
                        (?>(?&PerlBlock))          (?>(?&PerlOWS))
                        (?&PerlExpression)?+
                    |
                        (?>(?&PPR_indirect_obj))   (?>(?&PerlNWS))
                        (?&PerlExpression)
                    |
                        (?&PerlExpression)?+
                    )                              (?>(?&PerlOWS))
                \)
            |
                    (?>
                        (?=
                            (?>(?&PPR_non_reserved_identifier))
                            (?>(?&PerlOWS))
                            (?! \( | (?&PerlComma) )
                        )
                        (?&PerlCall)
                    |
                        (?>(?&PerlBlock))          (?>(?&PerlOWS))
                        (?&PerlCommaList)?+
                    |
                        (?>(?&PPR_indirect_obj))   (?>(?&PerlNWS))
                        (?&PerlCommaList)
                    |
                        (?&PerlCommaList)?+
                    )
            )
        |
            (?>(?&PPR_non_reserved_identifier)) (?>(?&PerlOWS))
            (?>
                \(                              (?>(?&PerlOWS))
                    (?: (?>(?&PerlExpression))     (?&PerlOWS)  )?+
                \)
            |
                    (?>
                        (?=
                            (?>(?&PPR_non_reserved_identifier))
                            (?>(?&PerlOWS))
                            (?! \( | (?&PerlComma) )
                        )
                        (?&PerlCall)
                    |
                        (?>(?&PerlBlock))           (?>(?&PerlOWS))
                        (?&PerlCommaList)?+
                    |
                        (?>(?&PPR_indirect_obj))        (?&PerlNWS)
                        (?&PerlCommaList)
                    |
                        (?&PerlCommaList)?+
                    )
            )
        )
    ) # End of rule

    (?
        (?> my | state | our ) \b           (?>(?&PerlOWS))
        (?: (?&PerlQualifiedIdentifier)        (?&PerlOWS)  )?+
        (?>(?&PerlLvalue))                  (?>(?&PerlOWS))
        (?&PerlAttributes)?+
    ) # End of rule

    (?
        do (?>(?&PerlOWS)) (?&PerlBlock)
    ) # End of rule

    (?
        eval (?>(?&PerlOWS)) (?&PerlBlock)
    ) # End of rule

    (?
        :
        (?>(?&PerlOWS))
        (?>(?&PerlIdentifier))
        (?:
            (?= \( ) (?&PPR_quotelike_body)
        )?+

        (?:
            (?> (?>(?&PerlOWS)) : (?&PerlOWS) | (?&PerlNWS) )
            (?>(?&PerlIdentifier))
            (?:
                (?= \( ) (?&PPR_quotelike_body)
            )?+
        )*+
    ) # End of rule

    (?
        (?> (?&PerlParenthesesList) | (?&PerlCommaList) )
    ) # End of rule

    (?
        \(  (?>(?&PerlOWS))  (?: (?>(?&PerlExpression)) (?&PerlOWS) )?+  \)
    ) # End of rule

    (?
        \[  (?>(?&PerlOWS))  (?: (?>(?&PerlExpression)) (?&PerlOWS) )?+  \]
    ) # End of rule

    (?
        \{  (?>(?&PerlOWS))  (?: (?>(?&PerlExpression)) (?&PerlOWS) )?+ \}
    ) # End of rule

    (?
        \[                          (?>(?&PerlOWS))
            (?>(?&PerlExpression))  (?>(?&PerlOWS))
        \]
    ) # End of rule

    (?
        \{  (?>(?&PerlOWS))
            (?: -?+ (?&PerlIdentifier) | (?&PerlExpression) )  # (Note: MUST allow backtracking here)
            (?>(?&PerlOWS))
        \}
    ) # End of rule

    (?
        <<>>    # Perl 5.22 "double diamond"
      |
        < (?! < )
            (?>(?&PPR_balanced_angles))
        >
        (?=
            (?>(?&PerlOWS))
            (?> \z | [,;\}\])?] | => | : (?! :)        # (
            |   (?&PerlInfixBinaryOperator) | (?&PerlLowPrecedenceInfixOperator)
            |   (?= \w) (?> for(?:each)?+ | while | if | unless | until | when )
            )
        )
    ) # End of rule

    (?
        (?> , | => )
    ) # End of rule

    (?
        (?> [!\\+~] | \+\+  |  --  | - (?! (?&PPR_filetest_name) \b ) )
    ) # End of rule

    (?
        (?> \+\+  |  -- )
    ) # End of rule

    (?
        (?>  [=!][~=]
        |    cmp
        |    <= >?+
        |    >=
        |    [lg][te]
        |    eq
        |    ne
        |    [+]             (?! [+=] )
        |     -              (?! [-=] )
        |    [.]{2,3}+
        |    [.%x]           (?! [=]  )
        |    [&|^][.]        (?! [=]  )
        |    [<>*&|/]{1,2}+  (?! [=]  )
        |    \^              (?! [=]  )
        |    ~~
        )
    ) # End of rule

    (?
        (?:  [<>*&|/]{2}
          |  [-+.*/%x]
          |  [&|^][.]?+
        )?+
        =
        (?! > )
    ) # End of rule

    (?
        (?> or | and | xor )
    ) # End of rule

    (?
        sub \b
        (?>(?&PerlOWS))
        (?:
            (?>
                (?&PerlParenthesesList)    # Parameter list
            |
                \( [^)]*+ \)          # Prototype (
            )
            (?&PerlOWS)
        )?+
        (?: (?>(?&PerlAttributes))  (?&PerlOWS) )?+
        (?&PerlBlock)
    ) # End of rule

    (?
        (?= [\$\@%] )
        (?>
            (?&PerlScalarAccess)
        |   (?&PerlHashAccess)
        |   (?&PerlArrayAccess)
        )
    ) # End of rule

    (?
        \*
        (?>
            \d++
        |
            \^ [][A-Z^_?\\]
        |
            \{ \^ [A-Z_] \w*+ \}
        |
            (?>(?&PerlOldQualifiedIdentifier))  (?: :: )?+
        |
            (?&PerlVariableScalar)
        |
            [][!"#\$%&'()*+,./:;<=>?\@\^`|~-]
        |
            (?&PerlBlock)
        )
        (?:
            (?>(?&PerlOWS)) (?: -> (?&PerlOWS) )?+
            (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) | (?&PerlParenthesesList) )
        )*+
        (?:
            (?>(?&PerlOWS)) -> (?>(?&PerlOWS))
            [\@%]
            (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) )
        )?+
    ) # End of rule

    (?
        (?>(?&PerlVariableArray))
        (?:
            (?>(?&PerlOWS)) (?: -> (?&PerlOWS) )?+
            (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) | (?&PerlParenthesesList)  )
        )*+
        (?:
            (?>(?&PerlOWS)) -> (?>(?&PerlOWS))
            [\@%]
            (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) )
        )?+
    ) # End of rule

    (?
        (?>(?&PerlVariableArrayNoSpace))
        (?:
            (?: -> )?+
            (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) | (?&PerlParenthesesList)  )
        )*+
        (?:
            ->
            [\@%]
            (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) )
        )?+
    ) # End of rule

    (?
        (?>(?&PerlVariableArray))
        (?:
            (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) | (?&PerlParenthesesList)  )
        )*+
    ) # End of rule

    (?
        (?>(?&PerlVariableHash))
        (?:
            (?>(?&PerlOWS)) (?: -> (?&PerlOWS) )?+
            (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) | (?&PerlParenthesesList) )
        )*+
        (?:
            (?>(?&PerlOWS)) -> (?>(?&PerlOWS))
            [\@%]
            (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) )
        )?+
    ) # End of rule

    (?
        (?>(?&PerlVariableScalar))
        (?:
            (?>(?&PerlOWS))
            (?:
                (?:
                    (?>(?&PerlOWS))      -> (?>(?&PerlOWS))
                    (?&PerlParenthesesList)
                |
                    (?>(?&PerlOWS))  (?: ->    (?&PerlOWS)  )?+
                    (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) )
                )
                (?:
                    (?>(?&PerlOWS))  (?: ->    (?&PerlOWS)  )?+
                    (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) | (?&PerlParenthesesList) )
                )*+
            )?+
            (?:
                (?>(?&PerlOWS)) -> (?>(?&PerlOWS))
                [\@%]
                (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) )
            )?+
        )?+
    ) # End of rule

    (?
        (?>(?&PerlVariableScalarNoSpace))
        (?:
            (?:
                (?:
                    ->
                    (?&PerlParenthesesList)
                |
                    (?: -> )?+
                    (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) )
                )
                (?:
                    (?: -> )?+
                    (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) | (?&PerlParenthesesList) )
                )*+
            )?+
            (?:
                ->
                [\@%]
                (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) )
            )?+
        )?+
    ) # End of rule

    (?
        (?>(?&PerlVariableScalarNoSpace))
        (?:
            (?> (?&PerlArrayIndexer) | (?&PerlHashIndexer) | (?&PerlParenthesesList) )
        )*+
    ) # End of rule

    (?
        \$\$
        (?! [\$\{\w] )
    |
        (?:
            \$
            (?:
                [#]
                (?=  (?> [\$^\w\{:+] | - (?! > ) )  )
            )?+
            (?&PerlOWS)
        )++
        (?>
            \d++
        |
            \^ [][A-Z^_?\\]
        |
            \{ \^ [A-Z_] \w*+ \}
        |
            (?>(?&PerlOldQualifiedIdentifier)) (?: :: )?+
        |
            :: (?&PerlBlock)
        |
            [][!"#\$%&'()*+,.\\/:;<=>?\@\^`|~-]
        |
            \{ [!"#\$%&'()*+,.\\/:;<=>?\@\^`|~-] \}
        |
            \{ \w++ \}
        |
            (?&PerlBlock)
        )
    |
        \$\#
    ) # End of rule

    (?
        \$\$
        (?! [\$\{\w] )
    |
        (?:
            \$
            (?:
                [#]
                (?=  (?> [\$^\w\{:+] | - (?! > ) )  )
            )?+
        )++
        (?>
            \d++
        |
            \^ [][A-Z^_?\\]
        |
            \{ \^ [A-Z_] \w*+ \}
        |
            (?>(?&PerlOldQualifiedIdentifier)) (?: :: )?+
        |
            :: (?&PerlBlock)
        |
            [][!"#\$%&'()*+,.\\/:;<=>?\@\^`|~-]
        |
            \{ \w++ \}
        |
            (?&PerlBlock)
        )
    |
        \$\#
    ) # End of rule

    (?
        \@     (?>(?&PerlOWS))
        (?: \$    (?&PerlOWS)  )*+
        (?>
            \d++
        |
            \^ [][A-Z^_?\\]
        |
            \{ \^ [A-Z_] \w*+ \}
        |
            (?>(?&PerlOldQualifiedIdentifier)) (?: :: )?+
        |
            :: (?&PerlBlock)
        |
            [][!"#\$%&'()*+,.\\/:;<=>?\@\^`|~-]
        |
            (?&PerlBlock)
        )
    ) # End of rule

    (?
        \@
        (?: \$ )*+
        (?>
            \d++
        |
            \^ [][A-Z^_?\\]
        |
            \{ \^ [A-Z_] \w*+ \}
        |
            (?>(?&PerlOldQualifiedIdentifier)) (?: :: )?+
        |
            :: (?&PerlBlock)
        |
            [][!"#\$%&'()*+,.\\/:;<=>?\@\^`|~-]
        |
            (?&PerlBlock)
        )
    ) # End of rule

    (?
        %      (?>(?&PerlOWS))
        (?: \$    (?&PerlOWS)  )*+
        (?>
            \d++
        |
            \^ [][A-Z^_?\\]
        |
            \{ \^ [A-Z_] \w*+ \}
        |
            (?>(?&PerlOldQualifiedIdentifier)) (?: :: )?+
        |
            :: (?&PerlBlock)?+
        |
            [][!"#\$%&'()*+,.\\/:;<=>?\@\^`|~-]
        |
            (?&PerlBlock)
        )
    ) # End of rule

    (?
        (?! (?> [msy] | q[wrxq]?+ | tr ) \b )
        (?>(?&PerlIdentifier))
        : (?! : )
    ) # End of rule

    (?
        (?> (?&PerlString)
        |   (?&PerlQuotelikeQR)
        |   (?&PerlQuotelikeQW)
        |   (?&PerlNumber)
        |   (?&PerlBareword)
        )
    ) # End of rule

    (?
        (?>
            "  [^"\\]*+  (?: \\. [^"\\]*+ )*+ "
        |
            '  [^'\\]*+  (?: \\. [^'\\]*+ )*+ '
        |
            qq \b
            (?> (?= [#] ) | (?! (?>(?&PerlOWS)) => ) )
            (?&PPR_quotelike_body_interpolated)
        |
            q \b
            (?> (?= [#] ) | (?! (?>(?&PerlOWS)) => ) )
            (?&PPR_quotelike_body)
        |
            (?&PerlHeredoc)
        |
            (?&PerlVString)
        )
    ) # End of rule

    (?
        (?> (?&PerlString)
        |   (?&PerlQuotelikeQR)
        |   (?&PerlQuotelikeQW)
        |   (?&PerlQuotelikeQX)
        |   (?&PerlContextualMatch)
        |   (?&PerlQuotelikeS)
        |   (?&PerlQuotelikeTR)
    )
    ) # End of rule

    (?
        # Match the introducer...
        <<
        (?<_heredoc_indented> [~]?+ )

        # Match the terminator specification...
        (?>
            \\?+   (?<_heredoc_terminator>  (?&PerlIdentifier)              )
        |
            (?>(?&PerlOWS))
            (?>
                "  (?<_heredoc_terminator>  [^"\\]*+  (?: \\. [^"\\]*+ )*+  )  "
            |
                (? ' )
                   (?<_heredoc_terminator>  [^'\\]*+  (?: \\. [^'\\]*+ )*+  )  '
            |
                `  (?<_heredoc_terminator>  [^`\\]*+  (?: \\. [^`\\]*+ )*+  )  `
            )
        |
                   (?<_heredoc_terminator>                                  )
        )

        # Do we need to reset the heredoc cache???
        (?{
            if ( ($PPR::_heredoc_origin // q{}) ne $_ ) {
                %PPR::_heredoc_skip      = ();
                %PPR::_heredoc_parsed_to = ();
                $PPR::_heredoc_origin    = $_;
            }
        })

        # Do we need to cache content lookahead for this heredoc???
        (?(?{ my $need_to_lookahead = !$PPR::_heredoc_parsed_to{+pos()};
              $PPR::_heredoc_parsed_to{+pos()} = 1;
              $need_to_lookahead;
            })

            # Lookahead to detect and remember trailing contents of heredoc
            (?=
                [^\n]*+ \n                                   # Go to the end of the current line
                (?{ +pos() })                                # Remember the start of the contents
                (??{ $PPR::_heredoc_skip{+pos()} // q{} })   # Skip earlier heredoc contents
                (?>                                          # The heredoc contents consist of...
                    (?:
                        (?!
                            (?(?{ $+{_heredoc_indented} }) \h*+ )   # An indent (if it was a <<~)
                            \g{_heredoc_terminator}                 # The terminator
                            (?: \n | \z )                           # At an end-of-line
                        )
                        (?()
                            [^\n]*+ \n
                        |
                            [^\n\$\@]*+
                            (?:
                                (?>
                                    (?{ local $PPR::_heredoc_EOL_start = $^R })
                                    (?= \$ (?! \s ) )  (?&PerlScalarAccessNoSpace)
                                    (?{ $PPR::_heredoc_EOL_start })
                                |
                                    (?{ local $PPR::_heredoc_EOL_start = $^R })
                                    (?= \@ (?! \s ) )  (?&PerlArrayAccessNoSpace)
                                    (?{ $PPR::_heredoc_EOL_start })
                                )
                                [^\n\$\@]*+
                            )*+
                            \n (??{ $PPR::_heredoc_skip{+pos()} // q{} })
                        )
                    )*+

                    (?(?{ $+{_heredoc_indented} }) \h*+ )            # An indent (if it was a <<~)
                    \g{_heredoc_terminator}                          # The specified terminator
                    (?: \n | \z )                                    # Followed by EOL
                )

                # Then memoize the skip for when it's subsequently needed by PerlOWS or PerlNWS...
                (?{
                    $PPR::_heredoc_skip{$^R} = "(?s:.\{" . (pos() - $^R) . "\})";
                })
            )
        )

    ) # End of rule

    (?
        (?>
            '  [^'\\]*+  (?: \\. [^'\\]*+ )*+ '
        |
            q \b
            (?> (?= [#] ) | (?! (?>(?&PerlOWS)) => ) )
            (?&PPR_quotelike_body)
        )
    ) # End of rule

    (?
        (?>
            "  [^"\\]*+  (?: \\. [^"\\]*+ )*+ "
        |
            qq \b
            (?> (?= [#] ) | (?! (?>(?&PerlOWS)) => ) )
            (?&PPR_quotelike_body_interpolated)
        )
    ) # End of rule

    (?
        (?>
            qw \b
            (?> (?= [#] ) | (?! (?>(?&PerlOWS)) => ) )
            (?&PPR_quotelike_body)
        )
    ) # End of rule

    (?
        (?>
            `  [^`]*+  (?: \\. [^`]*+ )*+  `
        |
            qx
                (?:
                    (?&PerlOWS) ' (?&PPR_quotelike_body)
                |
                    \b (?> (?= [#] ) | (?! (?>(?&PerlOWS)) => ) )
                    (?&PPR_quotelike_body_interpolated)
                )
        )
    ) # End of rule

    (?
    (?
        s \b
        (?> (?= [#] ) | (?! (?>(?&PerlOWS)) => ) )
        (?>
            # Hashed syntax...
            (?= [#] )
            (?>(?&PPR_quotelike_body_interpolated_unclosed))
               (?&PPR_quotelike_s_e_check)
            (?>(?&PPR_quotelike_body_interpolated))
        |
            # Bracketed syntax...
            (?= (?>(?&PerlOWS)) [\[(<\{] )      # )
            (?>(?&PPR_quotelike_body_interpolated))
            (?>(?&PerlOWS))
               (?&PPR_quotelike_s_e_check)
            (?>(?&PPR_quotelike_body_interpolated))
        |
            # Delimited syntax...
            (?>(?&PPR_quotelike_body_interpolated_unclosed))
               (?&PPR_quotelike_s_e_check)
            (?>(?&PPR_quotelike_body_interpolated))
        )
        [msixpodualgcern]*+
    ) # End of rule
    ) # End of rule

    (?
    (?
        (?> tr | y ) \b
        (?! (?>(?&PerlOWS)) => )
        (?>
            # Hashed syntax...
            (?= [#] )
            (?>(?&PPR_quotelike_body_interpolated_unclosed))
               (?&PPR_quotelike_body_interpolated)
        |
            # Bracketed syntax...
            (?= (?>(?&PerlOWS)) [\[(<\{] )      # )
            (?>(?&PPR_quotelike_body_interpolated))
            (?>(?&PerlOWS))
               (?&PPR_quotelike_body_interpolated)
        |
            # Delimited syntax...
            (?>(?&PPR_quotelike_body_interpolated_unclosed))
               (?&PPR_quotelike_body_interpolated)
        )
        [cdsr]*+
    ) # End of rule
    ) # End of rule

    (?
    (?
        (?
        (?
            (?>
                \/\/
            |
                (?>
                    m (?= [#] )
                |
                    m \b
                    (?! (?>(?&PerlOWS)) => )
                |
                    (?= \/ [^/] )
                )
                (?&PPR_quotelike_body_interpolated)
            )
            [msixpodualgcn]*+
        ) # End of rule
        ) # End of rule
        (?=
            (?>(?&PerlOWS))
            (?> \z | [,;\}\])?] | => | : (?! :)
            |   (?&PerlInfixBinaryOperator) | (?&PerlLowPrecedenceInfixOperator)
            |   (?= \w) (?> for(?:each)?+ | while | if | unless | until | when )
            )
        )
    ) # End of rule
    ) # End of rule

    (?
        qr \b
        (?> (?= [#] ) | (?! (?>(?&PerlOWS)) => ) )
        (?>(?&PPR_quotelike_body_interpolated))
        [msixpodualn]*+
    ) # End of rule

    (?
        (?>
            (?&PerlMatch)
        |
            (?&PerlQuotelikeQR)
        )
    ) # End of rule

    (?
        (?>
            (?&PerlContextualMatch)
        |
            (?&PerlQuotelikeQR)
        )
    ) # End of rule


    (?
        # Optimized to match any Perl builtin name, without backtracking...
        (?=[^\W\d]) # Skip if possible
        (?>
             s(?>e(?>t(?>(?>(?>(?>hos|ne)t|gr)en|s(?>erven|ockop))t|p(?>r(?>iority|otoent)|went|grp))|m(?>ctl|get|op)|ek(?>dir)?|lect|nd)|y(?>s(?>write|call|open|read|seek|tem)|mlink)|h(?>m(?>write|read|ctl|get)|utdown|ift)|o(?>cket(?>pair)?|rt)|p(?>li(?>ce|t)|rintf)|(?>cala|ubst)r|t(?>ate?|udy)|leep|rand|qrt|ay|in)
            | g(?>et(?>p(?>r(?>oto(?>byn(?>umber|ame)|ent)|iority)|w(?>ent|nam|uid)|eername|grp|pid)|s(?>erv(?>by(?>name|port)|ent)|ock(?>name|opt))|host(?>by(?>addr|name)|ent)|net(?>by(?>addr|name)|ent)|gr(?>ent|gid|nam)|login|c)|mtime|lob|oto|rep)
            | r(?>e(?>ad(?>lin[ek]|pipe|dir)?|(?>quir|vers|nam)e|winddir|turn|set|cv|do|f)|index|mdir|and)
            | c(?>h(?>o(?>m?p|wn)|r(?>oot)?|dir|mod)|o(?>n(?>tinue|nect)|s)|lose(?>dir)?|aller|rypt)
            | e(?>nd(?>(?>hos|ne)t|p(?>roto|w)|serv|gr)ent|x(?>i(?>sts|t)|ec|p)|ach|val(?>bytes)?+|of)
            | l(?>o(?>c(?>al(?>time)?|k)|g)|i(?>sten|nk)|(?>sta|as)t|c(?>first)?|ength)
            | u(?>n(?>(?>lin|pac)k|shift|def|tie)|c(?>first)?|mask|time)
            | p(?>r(?>ototype|intf?)|ack(?>age)?|o[ps]|ipe|ush)
            | d(?>bm(?>close|open)|e(?>fined|lete)|ump|ie|o)
            | f(?>or(?>m(?>line|at)|k)|ileno|cntl|c|lock)
            | t(?>i(?>mes?|ed?)|ell(?>dir)?|runcate)
            | w(?>a(?>it(?>pid)?|ntarray|rn)|rite)
            | m(?>sg(?>ctl|get|rcv|snd)|kdir|ap)
            | b(?>in(?>mode|d)|less|reak)
            | i(?>n(?>dex|t)|mport|octl)
            | a(?>ccept|larm|tan2|bs)
            | o(?>pen(?>dir)?|ct|rd)
            | v(?>alues|ec)
            | k(?>eys|ill)
            | quotemeta
            | join
            | next
            | hex
            | _
        )
        \b
    ) # End of rule

    (?
        # Optimized to match any Perl builtin name, without backtracking...
        (?= [^\W\d] )  # Skip if possible
        (?>
              get(?:(?:(?:hos|ne)t|serv|gr)ent|p(?:(?:roto|w)ent|pid)|login)
            | end(?:(?:hos|ne)t|p(?:roto|w)|serv|gr)ent
            | wa(?:ntarray|it)
            | times?
            | fork
            | _
        )
        \b
    ) # End of rule

    (?
        (?>
            (?&PerlVString)
        |
            (?>(?&PPR_digit_seq))
            (?: \. (?&PPR_digit_seq)?+ )*+
        )
    ) # End of rule

    (?
        v  (?>(?&PPR_digit_seq))  (?: \. (?&PPR_digit_seq) )*+
    ) # End of rule

    (?
        [+-]?+
        (?>
            0  (?>  x (?&PPR_x_digit_seq)
               |    b (?&PPR_b_digit_seq)
               |      (?&PPR_o_digit_seq)
               )
        |
            (?>
                    (?>(?&PPR_digit_seq))
                (?: \. (?&PPR_digit_seq)?+ )?+
            |
                    \. (?&PPR_digit_seq)
            )
            (?: [eE] [+-]?+ (?&PPR_digit_seq) )?+
        )
    ) # End of rule

    (?
        (?> (?> :: | ' ) \w++  |  [^\W\d]\w*+ )  (?: (?> :: | ' )  \w++ )*+
    ) # End of rule

    (?
        (?>     ::       \w++  |  [^\W\d]\w*+ )  (?: (?> :: | ' )  \w++ )*+
    ) # End of rule

    (?
                                  [^\W\d]\w*+
    ) # End of rule

    (?
        (?! (?> (?= \w )
                (?> for(?:each)?+ | while | if | unless | until | use | no | given | when | sub | return )
            |   (?&PPR_named_op)
            |   __ (?> END | DATA ) __ (?&PerlEndOfLine)
            ) \b
            (?! (?>(?&PerlOWS)) => )
        )
        (?! (?> q[qwrx]?+ | [mys] | tr ) \b
            (?> (?= [#] ) | (?! (?>(?&PerlOWS)) => ) )
        )
        (?: :: )?+
        [^\W\d]\w*+
        (?: (?: :: | ' )  [^\W\d]\w*+  )*+
        (?: :: )?+
        (?! \( )    # )
    |
        :: (?! \w | \{ )
    ) # End of rule

    (?
        (?!)    # None, by default, but can be overridden in a composing regex
    ) # End of rule

    (?
        ^ = [^\W\d]\w*+          # A line starting with =
        .*?                      # Up to the first...
        ^ = cut \b [^\n]*+ $     # ...line starting with =cut
    ) # End of rule


    ##### Whitespace matching (part of API) #################################

    (?
        (?:
            \h++
        |
            (?&PPR_newline_and_heredoc)
        |
            [#] [^\n]*+
        |
            __ (?> END | DATA ) __ \b .*+ \z
        )*+
    ) # End of rule

    (?
        (?:
            \h++
        |
            (?&PPR_newline_and_heredoc)
        |
            [#] [^\n]*+
        |
            __ (?> END | DATA ) __ \b .*+ \z
        )++
    ) # End of rule

    (?
        \n
    ) # End of rule


    ###### Internal components (not part of API) ##########################

    (?
        (?> cmp
        |   [lg][te]
        |   eq
        |   ne
        |   and
        |   or
        |   xor
        )
    )

    (?
        (?! (?>
               for(?:each)?+ | while | if | unless | until | given | when | default
            |  sub | format | use | no
            |  (?&PPR_named_op)
            |  [msy] | q[wrxq]?+ | tr
            |   __ (?> END | DATA ) __ \n
            )
            \b
        )
        (?>(?&PerlQualifiedIdentifier))
        (?! :: )
    )

    (?
        \(  (?>(?&PerlOWS)) (?: (?>(?&PerlExpression)) (?&PerlOWS) )??
         ;  (?>(?&PerlOWS)) (?: (?>(?&PerlExpression)) (?&PerlOWS) )??
         ;  (?>(?&PerlOWS)) (?: (?>(?&PerlExpression)) (?&PerlOWS) )??
        \)
    )

    (?
        (?&PerlBareword)
    |
        (?>(?&PerlVariableScalar))
        (?! (?>(?&PerlOWS)) (?> [<\[\{] | -> ) )
    )

    (?
        (?>(?&PPR_quotelike_body_unclosed))
        \S   # (Note: Don't have to test that this matches; the preceding subrule already did that)
    )

    (?
        [^)(\\\n]*+
        (?:
            (?>
                \\.
            |
                \(  (?>(?&PPR_balanced_parens))  \)
            |
                (?&PPR_newline_and_heredoc)
            )
            [^)(\\\n]*+
        )*+
    )

    (?
        [^\}\{\\\n]*+
        (?:
            (?>
                \\.
            |
                \{  (?>(?&PPR_balanced_curlies))  \}
            |
                (?&PPR_newline_and_heredoc)
            )
            [^\}\{\\\n]*+
        )*+
    )

    (?
        [^][\\\n]*+
        (?:
            (?>
                \\.
            |
                \[  (?>(?&PPR_balanced_squares))  \]
            |
                (?&PPR_newline_and_heredoc)
            )
            [^][\\\n]*+
        )*+
    )

    (?
        [^><\\\n]*+
        (?:
            (?>
                \\.
            |
                <  (?>(?&PPR_balanced_angles))  >
            |
                (?&PPR_newline_and_heredoc)
            )
            [^><\\\n]*+
        )*+
    )

    (?
        (?>
               [#]
               [^#\\\n]*+
               (?:
                   (?: \\. | (?&PPR_newline_and_heredoc) )
                   [^#\\\n]*+
               )*+
               (?= [#] )
        |
            (?>(?&PerlOWS))
            (?>
                \{  (?>(?&PPR_balanced_curlies))    (?= \} )
            |
                \[  (?>(?&PPR_balanced_squares))    (?= \] )
            |
                \(  (?>(?&PPR_balanced_parens))     (?= \) )
            |
                 <  (?>(?&PPR_balanced_angles))     (?=  > )
            |
                \\
                    [^\\\n]*+
                    (
                        (?&PPR_newline_and_heredoc)
                        [^\\\n]*+
                    )*+
                (?= \\ )
            |
                 /
                     [^\\/\n]*+
                 (?:
                     (?: \\. | (?&PPR_newline_and_heredoc) )
                     [^\\/\n]*+
                 )*+
                 (?=  / )
            |
                (? \S )
                    (?:
                        \\.
                    |
                        (?&PPR_newline_and_heredoc)
                    |
                        (?! \g{PPR_qldel} ) .
                    )*+
                (?= \g{PPR_qldel} )
            )
        )
    )

    (?
        (?>(?&PPR_quotelike_body_interpolated_unclosed))
        \S   # (Note: Don't have to test that this matches; the preceding subrule already did that)
    )

    (?
        [^)(\\\n\$\@]*+
        (?:
            (?>
                \\.
            |
                \(  (?>(?&PPR_balanced_parens_interpolated))  \)
            |
                (?&PPR_newline_and_heredoc)
            |
                (?= \$ (?! [\s\)] ) )  (?&PerlScalarAccessNoSpace)
            |
                (?= \@ (?! [\s\)] ) )  (?&PerlArrayAccessNoSpace)
            |
                [\$\@]
            )
            [^)(\\\n\$\@]*+
        )*+
    )

    (?
        [^\}\{\\\n\$\@]*+
        (?:
            (?>
                \\.
            |
                \{  (?>(?&PPR_balanced_curlies_interpolated))  \}
            |
                (?&PPR_newline_and_heredoc)
            |
                (?= \$ (?! [\s\}] ) )  (?&PerlScalarAccessNoSpace)
            |
                (?= \@ (?! [\s\}] ) )  (?&PerlArrayAccessNoSpace)
            |
                [\$\@]
            )
            [^\}\{\\\n\$\@]*+
        )*+
    )

    (?
        [^][\\\n\$\@]*+
        (?:
            (?>
                \\.
            |
                \[  (?>(?&PPR_balanced_squares_interpolated))  \]
            |
                (?&PPR_newline_and_heredoc)
            |
                (?= \$ (?! [\s\]] ) )  (?&PerlScalarAccessNoSpace)
            |
                (?= \@ (?! [\s\]] ) )  (?&PerlArrayAccessNoSpace)
            |
                [\$\@]
            )
            [^][\\\n\$\@]*+
        )*+
    )

    (?
        [^><\\\n\$\@]*+
        (?:
            (?>
                \\.
            |
                <  (?>(?&PPR_balanced_angles_interpolated))  >
            |
                (?&PPR_newline_and_heredoc)
            |
                (?= \$ (?! [\s>] ) )  (?&PerlScalarAccessNoSpace)
            |
                (?= \@ (?! [\s>] ) )  (?&PerlArrayAccessNoSpace)
            |
                [\$\@]
            )
            [^><\\\n\$\@]*+
        )*+
    )

    (?
        # Start by working out where it actually ends (ignoring interpolations)...
        (?=
            (?>
                [#]
                [^#\\\n\$\@]*+
                (?:
                    (?>
                        \\.
                    |
                        (?&PPR_newline_and_heredoc)
                    |
                        (?= \$ (?! [\s#] ) )  (?&PerlScalarAccessNoSpace)
                    |
                        (?= \@ (?! [\s#] ) )  (?&PerlArrayAccessNoSpace)
                    |
                        [\$\@]
                    )
                    [^#\\\n\$\@]*+
                )*+
                (?= [#] )
            |
                (?>(?&PerlOWS))
                (?>
                    \{  (?>(?&PPR_balanced_curlies_interpolated))    (?= \} )
                |
                    \[  (?>(?&PPR_balanced_squares_interpolated))    (?= \] )
                |
                    \(  (?>(?&PPR_balanced_parens_interpolated))     (?= \) )
                |
                    <  (?>(?&PPR_balanced_angles_interpolated))     (?=  > )
                |
                    \\
                        [^\\\n\$\@]*+
                        (?:
                            (?>
                                (?&PPR_newline_and_heredoc)
                            |
                                (?= \$ (?! [\s\\] ) )  (?&PerlScalarAccessNoSpace)
                            |
                                (?= \@ (?! [\s\\] ) )  (?&PerlArrayAccessNoSpace)
                            |
                                [\$\@]
                            )
                            [^\\\n\$\@]*+
                        )*+
                    (?= \\ )
                |
                    /
                        [^\\/\n\$\@]*+
                        (?:
                            (?>
                                \\.
                            |
                                (?&PPR_newline_and_heredoc)
                            |
                                (?= \$ (?! [\s/] ) )  (?&PerlScalarAccessNoSpace)
                            |
                                (?= \@ (?! [\s/] ) )  (?&PerlArrayAccessNoSpace)
                            |
                                [\$\@]
                            )
                            [^\\/\n\$\@]*+
                        )*+
                    (?= / )
                |
                    -
                        (?:
                            \\.
                        |
                            (?&PPR_newline_and_heredoc)
                        |
                            (?:
                                (?= \$ (?! [\s-] ) )  (?&PerlScalarAccessNoSpaceNoArrow)
                            |
                                (?= \@ (?! [\s-] ) )  (?&PerlArrayAccessNoSpaceNoArrow)
                            |
                                [^-]
                            )
                        )*+
                    (?= - )
                |
                    (? \S )
                        (?:
                            \\.
                        |
                            (?&PPR_newline_and_heredoc)
                        |
                            (?! \g{PPR_qldel} )
                            (?:
                                (?= \$ (?! \g{PPR_qldel} | \s ) )  (?&PerlScalarAccessNoSpace)
                            |
                                (?= \@ (?! \g{PPR_qldel} | \s ) )  (?&PerlArrayAccessNoSpace)
                            |
                                .
                            )
                        )*+
                    (?= \g{PPR_qldel} )
                )
            )
        )

        (?&PPR_quotelike_body_unclosed)
    )

    (?
        (??{ local $PPR::_quotelike_s_end = -1; '' })
        (?:
            (?=
                (?&PPR_quotelike_body_interpolated)
                (??{ $PPR::_quotelike_s_end = +pos(); '' })
                [msixpodualgcrn]*+ e [msixpodualgcern]*+
            )
            (?=
                (?(?{ $PPR::_quotelike_s_end >= 0 })
                    (?>
                        (??{ +pos() && +pos() < $PPR::_quotelike_s_end ? '' : '(?!)' })
                        (?>
                            (?&PerlVariable)
                        |
                            (?&PerlQuotelike)
                        |
                            \\?+ .
                        )
                    )*+
                )
            )
        )?+
    )

    (?   [ABCMORSTWXbcdefgkloprstuwxz]          )

    (?               \d++ (?: _?+         \d++ )*+  )
    (?     [\da-fA-F]++ (?: _?+ [\da-fA-F]++ )*+  )
    (?          [0-7]++ (?: _?+      [0-7]++ )*+  )
    (?          [0-1]++ (?: _?+      [0-1]++ )*+  )

    (?
        \n (??{ ($PPR::_heredoc_origin // q{}) eq ($_//q{}) ? ($PPR::_heredoc_skip{+pos()} // q{}) : q{} })
    )
)
}xms;

1; # Magic true value required at end of module

__END__