General Behaviour in List Contexts¶

In a list context, all the subroutines return a list, the first three elements of which are always:

[0]

The extracted string, including the specified delimiters. If the extraction fails "undef" is returned.

[1]

The remainder of the input string (i.e. the characters after the extracted string). On failure, the entire string is returned.

[2]

The skipped prefix (i.e. the characters before the extracted string). On failure, "undef" is returned.

Note that in a list context, the contents of the original input text (the first argument) are not modified in any way.

However, if the input text was passed in a variable, that variable's "pos" value is updated to point at the first character after the extracted text. That means that in a list context the various subroutines can be used much like regular expressions. For example:

    while ( $next = (extract_quotelike($text))[0] )
    {
        # process next quote-like (in $next)
    }

General Behaviour in Scalar and Void Contexts¶

In a scalar context, the extracted string is returned, having first been removed from the input text. Thus, the following code also processes each quote-like operation, but actually removes them from $text:

    while ( $next = extract_quotelike($text) )
    {
        # process next quote-like (in $next)
    }

Note that if the input text is a read-only string (i.e. a literal), no attempt is made to remove the extracted text.

In a void context the behaviour of the extraction subroutines is exactly the same as in a scalar context, except (of course) that the extracted substring is not returned.

A Note About Prefixes¶

Prefix patterns are matched without any trailing modifiers ("/gimsox" etc.) This can bite you if you're expecting a prefix specification like '.*?(?=<H1>)' to skip everything up to the first <H1> tag. Such a prefix pattern will only succeed if the <H1> tag is on the current line, since . normally doesn't match newlines.

To overcome this limitation, you need to turn on /s matching within the prefix pattern, using the "(?s)" directive: '(?s).*?(?=<H1>)'

Functions¶

"extract_delimited"

The "extract_delimited" function formalizes the common idiom of extracting a single-character-delimited substring from the start of a string. For example, to extract a single-quote delimited string, the following code is typically used:

    ($remainder = $text) =~ s/\A('(\\.|[^'])*')//s;
    $extracted = $1;
    

but with "extract_delimited" it can be simplified to:

    ($extracted,$remainder) = extract_delimited($text, "'");
    

"extract_delimited" takes up to four scalars (the input text, the delimiters, a prefix pattern to be skipped, and any escape characters) and extracts the initial substring of the text that is appropriately delimited. If the delimiter string has multiple characters, the first one encountered in the text is taken to delimit the substring. The third argument specifies a prefix pattern that is to be skipped (but must be present!) before the substring is extracted. The final argument specifies the escape character to be used for each delimiter.

All arguments are optional. If the escape characters are not specified, every delimiter is escaped with a backslash ("\"). If the prefix is not specified, the pattern '\s*' - optional whitespace - is used. If the delimiter set is also not specified, the set "/["'`]/" is used. If the text to be processed is not specified either, $_ is used.

In list context, "extract_delimited" returns a array of three elements, the extracted substring (including the surrounding delimiters), the remainder of the text, and the skipped prefix (if any). If a suitable delimited substring is not found, the first element of the array is the empty string, the second is the complete original text, and the prefix returned in the third element is an empty string.

In a scalar context, just the extracted substring is returned. In a void context, the extracted substring (and any prefix) are simply removed from the beginning of the first argument.

Examples:

    # Remove a single-quoted substring from the very beginning of $text:
        $substring = extract_delimited($text, "'", '');
    # Remove a single-quoted Pascalish substring (i.e. one in which
    # doubling the quote character escapes it) from the very
    # beginning of $text:
        $substring = extract_delimited($text, "'", '', "'");
    # Extract a single- or double- quoted substring from the
    # beginning of $text, optionally after some whitespace
    # (note the list context to protect $text from modification):
        ($substring) = extract_delimited $text, q{"'};
    # Delete the substring delimited by the first '/' in $text:
        $text = join '', (extract_delimited($text,'/','[^/]*')[2,1];
    

Note that this last example is not the same as deleting the first quote-like pattern. For instance, if $text contained the string:

    "if ('./cmd' =~ m/$UNIXCMD/s) { $cmd = $1; }"
    

then after the deletion it would contain:

    "if ('.$UNIXCMD/s) { $cmd = $1; }"
    

not:

    "if ('./cmd' =~ ms) { $cmd = $1; }"
    

See "extract_quotelike" for a (partial) solution to this problem.

"extract_bracketed"

Like "extract_delimited", the "extract_bracketed" function takes up to three optional scalar arguments: a string to extract from, a delimiter specifier, and a prefix pattern. As before, a missing prefix defaults to optional whitespace and a missing text defaults to $_. However, a missing delimiter specifier defaults to '{}()[]<>' (see below).

"extract_bracketed" extracts a balanced-bracket-delimited substring (using any one (or more) of the user-specified delimiter brackets: '(..)', '{..}', '[..]', or '<..>'). Optionally it will also respect quoted unbalanced brackets (see below).

A "delimiter bracket" is a bracket in list of delimiters passed as "extract_bracketed"'s second argument. Delimiter brackets are specified by giving either the left or right (or both!) versions of the required bracket(s). Note that the order in which two or more delimiter brackets are specified is not significant.

A "balanced-bracket-delimited substring" is a substring bounded by matched brackets, such that any other (left or right) delimiter bracket within the substring is also matched by an opposite (right or left) delimiter bracket at the same level of nesting. Any type of bracket not in the delimiter list is treated as an ordinary character.

In other words, each type of bracket specified as a delimiter must be balanced and correctly nested within the substring, and any other kind of ("non-delimiter") bracket in the substring is ignored.

For example, given the string:

    $text = "{ an '[irregularly :-(] {} parenthesized >:-)' string }";
    

then a call to "extract_bracketed" in a list context:

    @result = extract_bracketed( $text, '{}' );
    

would return:

    ( "{ an '[irregularly :-(] {} parenthesized >:-)' string }" , "" , "" )
    

since both sets of '{..}' brackets are properly nested and evenly balanced. (In a scalar context just the first element of the array would be returned. In a void context, $text would be replaced by an empty string.)

Likewise the call in:

    @result = extract_bracketed( $text, '{[' );
    

would return the same result, since all sets of both types of specified delimiter brackets are correctly nested and balanced.

However, the call in:

    @result = extract_bracketed( $text, '{([<' );
    

would fail, returning:

    ( undef , "{ an '[irregularly :-(] {} parenthesized >:-)' string }"  );
    

because the embedded pairs of '(..)'s and '[..]'s are "cross-nested" and the embedded '>' is unbalanced. (In a scalar context, this call would return an empty string. In a void context, $text would be unchanged.)

Note that the embedded single-quotes in the string don't help in this case, since they have not been specified as acceptable delimiters and are therefore treated as non-delimiter characters (and ignored).

However, if a particular species of quote character is included in the delimiter specification, then that type of quote will be correctly handled. for example, if $text is:

    $text = '<A HREF=">>>>">link</A>';
    

then

    @result = extract_bracketed( $text, '<">' );
    

returns:

    ( '<A HREF=">>>>">', 'link</A>', "" )
    

as expected. Without the specification of """ as an embedded quoter:

    @result = extract_bracketed( $text, '<>' );
    

the result would be:

    ( '<A HREF=">', '>>>">link</A>', "" )
    

In addition to the quote delimiters "'", """, and "`", full Perl quote-like quoting (i.e. q{string}, qq{string}, etc) can be specified by including the letter 'q' as a delimiter. Hence:

    @result = extract_bracketed( $text, '<q>' );
    

would correctly match something like this:

    $text = '<leftop: conj /and/ conj>';
    

See also: "extract_quotelike" and "extract_codeblock".

"extract_variable"

"extract_variable" extracts any valid Perl variable or variable-involved expression, including scalars, arrays, hashes, array accesses, hash look-ups, method calls through objects, subroutine calls through subroutine references, etc.

The subroutine takes up to two optional arguments:

"extract_tagged"

"extract_tagged" extracts and segments text between (balanced) specified tags.

The subroutine takes up to five optional arguments:

"gen_extract_tagged"

"gen_extract_tagged" generates a new anonymous subroutine which extracts text between (balanced) specified tags. In other words, it generates a function identical in function to "extract_tagged".

The difference between "extract_tagged" and the anonymous subroutines generated by "gen_extract_tagged", is that those generated subroutines:

        sub extract_tagged
        {
                my $text = shift;
                $extractor = gen_extract_tagged(@_);
                return $extractor->($text);
        }

"extract_quotelike"

"extract_quotelike" attempts to recognize, extract, and segment any one of the various Perl quotes and quotelike operators (see perlop(3)) Nested backslashed delimiters, embedded balanced bracket delimiters (for the quotelike operators), and trailing modifiers are all caught. For example, in:

        extract_quotelike 'q # an octothorpe: \# (not the end of the q!) #'
        extract_quotelike '  "You said, \"Use sed\"."  '
        extract_quotelike ' s{([A-Z]{1,8}\.[A-Z]{3})} /\L$1\E/; '
        extract_quotelike ' tr/\\\/\\\\/\\\//ds; '
    

the full Perl quotelike operations are all extracted correctly.

Note too that, when using the /x modifier on a regex, any comment containing the current pattern delimiter will cause the regex to be immediately terminated. In other words:

        'm /
                (?i)            # CASE INSENSITIVE
                [a-z_]          # LEADING ALPHABETIC/UNDERSCORE
                [a-z0-9]*       # FOLLOWED BY ANY NUMBER OF ALPHANUMERICS
           /x'
    

will be extracted as if it were:

        'm /
                (?i)            # CASE INSENSITIVE
                [a-z_]          # LEADING ALPHABETIC/'
    

This behaviour is identical to that of the actual compiler.

"extract_quotelike" takes two arguments: the text to be processed and a prefix to be matched at the very beginning of the text. If no prefix is specified, optional whitespace is the default. If no text is given, $_ is used.

In a list context, an array of 11 elements is returned. The elements are:

        # Remove the first quotelike literal that appears in text
                $quotelike = extract_quotelike($text,'.*?');
        # Replace one or more leading whitespace-separated quotelike
        # literals in $_ with "<QLL>"
                do { $_ = join '<QLL>', (extract_quotelike)[2,1] } until $@;
        # Isolate the search pattern in a quotelike operation from $text
                ($op,$pat) = (extract_quotelike $text)[3,5];
                if ($op =~ /[ms]/)
                {
                        print "search pattern: $pat\n";
                }
                else
                {
                        print "$op is not a pattern matching operation\n";
                }

"extract_quotelike"

"extract_quotelike" can successfully extract "here documents" from an input string, but with an important caveat in list contexts.

Unlike other types of quote-like literals, a here document is rarely a contiguous substring. For example, a typical piece of code using here document might look like this:

        <<'EOMSG' || die;
        This is the message.
        EOMSG
        exit;
    

Given this as an input string in a scalar context, "extract_quotelike" would correctly return the string "<<'EOMSG'\nThis is the message.\nEOMSG", leaving the string " || die;\nexit;" in the original variable. In other words, the two separate pieces of the here document are successfully extracted and concatenated.

In a list context, "extract_quotelike" would return the list

        <<'EOMSG'
        This is the message.
        EOMSG
        || die;
        exit;

        $quotelike = extract_quotelike("$var");

"extract_codeblock"

"extract_codeblock" attempts to recognize and extract a balanced bracket delimited substring that may contain unbalanced brackets inside Perl quotes or quotelike operations. That is, "extract_codeblock" is like a combination of "extract_bracketed" and "extract_quotelike".

"extract_codeblock" takes the same initial three parameters as "extract_bracketed": a text to process, a set of delimiter brackets to look for, and a prefix to match first. It also takes an optional fourth parameter, which allows the outermost delimiter brackets to be specified separately (see below), and a fifth parameter used only by Parse::RecDescent.

Omitting the first argument (input text) means process $_ instead. Omitting the second argument (delimiter brackets) indicates that only '{' is to be used. Omitting the third argument (prefix argument) implies optional whitespace at the start. Omitting the fourth argument (outermost delimiter brackets) indicates that the value of the second argument is to be used for the outermost delimiters.

Once the prefix and the outermost opening delimiter bracket have been recognized, code blocks are extracted by stepping through the input text and trying the following alternatives in sequence:

        # Find a while loop in the text
                if ($text =~ s/.*?while\s*\{/{/)
                {
                        $loop = "while " . extract_codeblock($text);
                }
        # Remove the first round-bracketed list (which may include
        # round- or curly-bracketed code blocks or quotelike operators)
                extract_codeblock $text, "(){}", '[^(]*';

        sentence: subject verb object
                        <defer: {$::theVerb = $item{verb}} >

                        <defer: {if ($count>10) {$count--}} >

                        <defer: {if ($count>

"extract_multiple"

The "extract_multiple" subroutine takes a string to be processed and a list of extractors (subroutines or regular expressions) to apply to that string.

In an array context "extract_multiple" returns an array of substrings of the original string, as extracted by the specified extractors. In a scalar context, "extract_multiple" returns the first substring successfully extracted from the original string. In both scalar and void contexts the original string has the first successfully extracted substring removed from it. In all contexts "extract_multiple" starts at the current "pos" of the string, and sets that "pos" appropriately after it matches.

Hence, the aim of a call to "extract_multiple" in a list context is to split the processed string into as many non-overlapping fields as possible, by repeatedly applying each of the specified extractors to the remainder of the string. Thus "extract_multiple" is a generalized form of Perl's "split" subroutine.

The subroutine takes up to four optional arguments:

        @fields = extract_multiple($text,
                                   [ sub { extract_variable($_[0]) } ],
                                   undef, 1);

        @fields = extract_multiple($text,
                   [
                        { Delim => sub { extract_delimited($_[0],q{'"}) } },
                        { Brack => sub { extract_bracketed($_[0],'{}') } },
                   ]);

        $quotelike = extract_multiple($text,
                                      [
                                        sub { extract_quotelike($_[0]) },
                                      ], undef, 1);

        $csv_text = "a,'x b',c";
        @fields = extract_multiple($csv_text,
                                  [
                                        sub { extract_delimited($_[0],q{'"}) },
                                        qr/([^,]+)/,
                                  ],
                                  undef,1);
        # @fields is now ('a', "'x b'", 'c')

"gen_delimited_pat"

The "gen_delimited_pat" subroutine takes a single (string) argument and builds a Friedl-style optimized regex that matches a string delimited by any one of the characters in the single argument. For example:

        gen_delimited_pat(q{'"})
    

returns the regex:

        (?:\"(?:\\\"|(?!\").)*\"|\'(?:\\\'|(?!\').)*\')
    

Note that the specified delimiters are automatically quotemeta'd.

A typical use of "gen_delimited_pat" would be to build special purpose tags for "extract_tagged". For example, to properly ignore "empty" XML elements (which might contain quoted strings):

        my $empty_tag = '<(' . gen_delimited_pat(q{'"}) . '|.)+/>';
        extract_tagged($text, undef, undef, undef, {ignore => [$empty_tag]} );
    

"gen_delimited_pat" may also be called with an optional second argument, which specifies the "escape" character(s) to be used for each delimiter. For example to match a Pascal-style string (where ' is the delimiter and '' is a literal ' within the string):

        gen_delimited_pat(q{'},q{'});
    

Different escape characters can be specified for different delimiters. For example, to specify that '/' is the escape for single quotes and '%' is the escape for double quotes:

        gen_delimited_pat(q{'"},q{/%});
    

If more delimiters than escape chars are specified, the last escape char is used for the remaining delimiters. If no escape char is specified for a given specified delimiter, '\' is used.

"delimited_pat"

Note that "gen_delimited_pat" was previously called "delimited_pat". That name may still be used, but is now deprecated.