$var =~ /(["'])[^\1]*?\1/;
[download]

$var =~ /(["'])[^(??{"$1"})]*?\1/; which worked unless $1 contained a special character (forgot the character, but it wasn't a quote),

I don't quite understand this? How could $1 contain anything other than ["']?

I'm just a beginner

As am I.

This is my attempt at capturing simple quoted elements - Ie. those without embedded quotes

# Doesn't handle embedded like-quotes
my $re_simpleQuoted = qr[
    ( ["'] )
    (
        (??{ "[^\1]+?" })
    )
    \1
]x;
[download]

In order to handle embedded quotes you need to go a stage further. The code below seems to handle most cases I have tried of either or both embedded quotes like this "...""..." or '...''....''....', which IMO is the rational way to do it outside of perl source code, and also done this way, "...\"..." and '...\'...'.

It doesn't handle basket cases where an escaped quote is immediately preceded by an escaped escape. Eg. "...\\\"...\"...". This could be addressed, but I think sufficiently rare that I wouldn't bother unless I had specific knowledge that it would arise. There are probably others that it would fail on too.

Code

Read more... (3 kB)

Output

Read more... (3 kB)

The PITA of using capturing parens to establish which quote to look for is that it limits the use when combining regexes together as you never know which $n var you captured into.

The 5.8 addition of the $^N variable has made this easier and the use of the experimental features more useful.

The logical extension (IMO) to this would be to extend the non-capturing group syntax to allow capturing to a user defined variable (our vars make sense I think).

Something like

(?: ... :$captured)

The other extension that I would like to see is a way of specifying a variable length match-anything-except-this construct. Like [^"] but longer

(?>>stop when you encounter this)*

Essentially, a non-zero length positive look ahead assertion! :)

Makes sense to me, but then I have no idea of the costs/difficulties these would impose on the regex engine.

T'would be nice though.

---

Examine what is said, not who speaks.
1) When a distinguished but elderly scientist states that something is possible, he is almost certainly right. When he states that something is impossible, he is very probably wrong.
2) The only way of discovering the limits of the possible is to venture a little way past them into the impossible
3) Any sufficiently advanced technology is indistinguishable from magic.
Arthur C. Clarke.

With a bit of thought, it is quite possible to write an unbreakable regex de-quoter:

#!/usr/bin/perl -wnl
use strict;
print;
print join ' / ', map qq["$_"], m[\G (
        ' (?: \\ . | '' | [^'] ) + '
        |
        " (?: \\ . | "" | [^"] ) + "
        |
        (?: \\ . | [^'"] ) + 
) ]gx;
print "";
[download]

It will handle even the edge cases yours breaks on. Using the (?{}) stuff to remove the redundancy is a nice idea, but for this case isn't the best solution.

sub make_dequote_rx {
    my @char = map quotemeta, @_;
    my $chars = join '', @char;
    my $rx = join(
        ' | ',
        map(qq[$_ (?: \\\\ . | $_$_ | [^$_] ) + $_], @char),
        qq[(?: \\\\ . | [^$chars] ) +],
    );
    return qr/\G ( $rx )/x;
}

my $dequote = make_dequote_rx qw(' ");
[download]

Update: Doubled the backslashes in the second piece of code.

Makeshifts last the longest.

$var =~ /(["'])[^(??{"$1"})]*?\1/; which worked unless $1 contained a 
+special character (forgot the character, but it wasn't a quote),
[download]

I don't quite understand this? How could $1 contain anything other than ["']?




I guess $1 had to be a quote, but in the error message, $1 was replaced with the string of matched characters, which were all non-quotes since I negated $1 in the regex. I don't recall the entire [^(??{"$1"})] being replaced, which makes it seem like the string of non-quotes in the error message was made of characters from only $1.

Anyway, it appears as though the characters matching ^$1 in my regex were interpolated, causing errors, and quoting them in the regex would have quoted the square brackets, the ^, the (??{", etc. and prevented the very character that I really wanted to quote from being matched.

My simple .*? between the quotes works for me, and my other idea is overkill for my current project anyway. I'll analyze the solutions from this thread when I have a chance. I'm sure they solve the problem.