How can I determine the number of vars defined in another regexp?

Question

For example, /(\w+) (?:\+) (\w)/ that regexp must return 2.

I must apologize for an incomplete question. Here's the problem: Input is XML-file (in fact it does not matter :), which sets rules for strings. At the moment it looks like this:

<string svars="3">(?:total ?|)(\d{1,2}(?:[\.,]\d{1,2}|))\/(\d{1,2}(?:[\.,]\d{1,2}|))\/(\d{1,2}(?:[\.,]\d{1,2}|))\s?sq\.\s?m\.?</string> 

Need to get rid of the variable svars, and count the number of substitution vars is in the regex programmatically.

Answer 1

This will find all capturing subexpressions in a regex represented as a string.

@matches = "/(\\w+) (?:+) (\\w)/" =~ /(\((?!\?).*?\))/g;
print @match # All matches
print scalar @match # Number of matches (2 in this case)

The regex uses negative lookahead ((?!...)) to make sure that the subexpression does not start with a ? as all non-capturing subexpressions do.

From KennyTM's comment I understand that this wont work if there are escaped parenthesis in the expression. To fix this we use negative lookbehind ((?<!...)). A new regex is born.

 /((?<!\\)\((?!\?).*?\))/g # It looks horrible.

Perl regular expressions reference and tutorial, always handy to have when working with regular expressions!

Answer 2

Just in case you are doing this to find out how many captures a given match returns, you can put the regex in list context and it will return all of the captures:

my @captures = $string =~ /(\w+) (?:\+) (\w)/;

You can then loop over them:

for my $capture (@captures) {
    print "$capture\n";
}

Answer 3

I think you are looking for YAPE::Regex:

#!/usr/bin/perl

use strict; use warnings;
use YAPE::Regex;

my $yape = YAPE::Regex->new( qr/(\w+) (?:\+) (\w)/ );
my $extor = $yape->extract;
my $captures;

$captures++ while $extor->();

print "Number of capture groups: $captures\n";

Answer 4

You admitted that you're working with XML. The regex stuff is probably the wrong answer to your problem. You have an XY problem where you're fixated on a solution instead of the problem.

---

What are you really trying to discover? It's practically impossible to give a good answer to a question such as this if you don't tell us what you are trying to do and why you are trying to do it.

There's a difference between the number of capture groups in the pattern and the number of captures a pattern will produce.

• The total number of literal capture groups in the regex.

This has one capture although there are literally three capture groups. The branch reset grouping renumbers the captures so that each alternation captures into the same variables:

 (?|(abc)|(def)|(ghi))

Do you want to count that as three capture groups or just one capture it will produce?

Even without the branch reset, how do you want to count this one?

 (abc)|(def)(ghi)|(jkl)

There are four capture groups, but at most only two of them will capture anything.

• The total number of captures that the regex will produce for a particular string.

Besides the previous examples, some capture groups might never capture anything. The number of captures depends on the string you match, as in these examples:

 (abc)? 
 (abc)*
 (abc){0,5}

• The maximum number of captures that a regex might produce. That is, for a string that triggers the most number of capture, what is that number?