Recursive pairwise braces matching in Perl - regex

Question

Let's consider this piece of code which does not belong to any known language:
foo() {
bar() {
bar();
}
baz() {
// Content baz
qux() {
// Content qux
}
}
}
I would like to iteratively process each function by calling a subroutine which receives: the function name, the arguments, the indentation level and the content.
So far I have written this:
#!/usr/bin/env perl
use 5.010;
$_ = do {local $/; <>};
s/([{}])/$1.($1 eq '{'?++$i:$i--).$1/eg;
parse($_);
sub parse {
local $_ = shift;
while (/(?<name>\w+)\s*\((?<args>.*?)\)\s*\{(\d)\{(?<content>.*?)\}(?<level>\3)\}/gs) {
parse($+{content});
process($+{content}, $+{args}, $+{level}, $+{content});
}
}
sub process {
my ($name, $args, $level, $content) = #_;
#...
}
The tricky idea is to replace in-place each matched brace { with an indentation number. So this:
{
{
}
}
will become this:
{1{
{2{
}2}
}1}
It allows to easily write the parsing regex which simply become:
qr/
\w+ # name
\s* \(.*?\) # arguments
\s* \{(\d)\{ # opening brace
.*? # content
\s* \}\1\} # closing brace
/x
How can I rewrite this without this trick?
Note that the choice of {1{ could be anything else like {(1), {1-, {[1] or even {1✈

Answer 1

You could try using recursive regular expressions. For example:
/(\{(?:[^{}]++|(?1))*\})/
will match a group of balanced braces. For more information, see
Can I use Perl regular expressions to match balanced text? in perlfaq6,
Perl documentation "Extended patterns" in perlre, and
extract_bracketed in Text::Balanced.

Answer 2

You will have a hard time doing this with a recursive regex because you can only get the last value of each capturing group and will lose all of the intervening values. This task is more suited to a parser like Parse::RecDescent:
use strict;
use warnings;
use 5.010;
use Parse::RecDescent;
sub process {
my ($name, $args, $depth) = #_;
say "$depth - $name($args)";
}
my $grammar = q{
{ my $indent = 0; }
startrule : expression(s /;/)
expression : function_call
| function_def[$indent]
function_call : identifier '(' arglist ')' ';'
function_def : identifier '(' arglist ')' '{' expression[ $arg[0]++ ](s?) '}'
{ main::process( $item{identifier}, join(',', #$item{arglist}), $arg[0] ) }
arglist : identifier(s? /,/)
identifier : /\w+/
};
# Tell parser to ignore spaces and C99 one-line comments
my $skip_spaces_and_comments = qr{ (?: \s+ | // .*?$ )* }mxs;
$Parse::RecDescent::skip = $skip_spaces_and_comments;
my $parser = Parse::RecDescent->new($grammar) or die 'Bad grammar';
my $text = do { local $/; <DATA> };
defined $parser->startrule($text) or die 'Failed to parse';
__DATA__
foo() {
bar() {
bar();
}
baz() {
// Content baz
qux() {
// Content qux
}
}
}
Output:
2 - bar()
1 - qux()
2 - baz()
3 - foo()
Note that the depths are inverted (1 is the most nested) and this doesn't return the contents of the function definitions, but it should get you started.