If the file is simple enough, Text::Balanced could work, as could a well-tuned set of REs (but then again, Text::Balanced is easier to use). If you have strings that contain unbalanced parentheses, then problems could ensue (or rather, you have to do more work).

perl -MHTTP::Daemon -MHTTP::Response -MLWP::Simple -e ' ;    # The  
$d = new HTTP::Daemon and fork and getprint $d->url and exit;#spider
($c = $d->accept())->get_request(); $c->send_response( new   #in the
HTTP::Response(200,$_,$_,qq(Just another Perl hacker\n))); ' #  web
[download]

If the format is more complex than what parsing with Text::Balanced will allow, another option on the path to a solution may be to investigate the Parse::RecDescent module (also by Damian Conway). As those who have used this module are aware, this module very much represents *the* way to perform complex parsing and pattern extraction - However, as with all powerful tools, there is a learning curve, particularly if you are not used to writing formal grammars.

Some useful sources of information for reference when learning to use Parse::RecDescent include Parse::RecDescent::FAQ and this article from The Perl Journal (Google cache).

Using this module I have recently been able to translate complex proprietary format files supplied from an external source into an internal format for print processing with only a few hours work by writing a formal grammar and making use of Parse::RecDescent - A process solution which has previously taken days, and in some cases weeks, for dedicated parsing code to be written, tested and deployed.

 

perl -le 'print+unpack("N",pack("B32","00000000000000000000001000111110"))'

I also have a few columns as examples.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

Thus my question: what is the easiest way to handle it?

use Regexp::Common;

my $str = <<CODE;
env {
  foo { bar {} }
}
CODE

print $str =~ /($RE{balanced}{-parens => '{}'})/;

__output__

{
  foo { bar {} }
}
[download]

_________
broquaint

--hsm

If the snippet you show indicates that the bit you wish to remove is the outermost level, and it is not embedded within, or alongside other structures, this is one occasion when the greediness of dot-star comes into its own.

#!perl -slw
use strict;

my $body = $1 if join('',<DATA>) =~ m[env\s*{(.*)}$]s;
print $body;

__DATA__
env
{
    "{";
    F
    {
        "'{\"\{"
    }
    g
    {
        '}';
    }
}
[download]

Output

C:\test>244329

        "{";
        F
        {
                "'{\"\{"
        }
        g
        {
                '}';
        }

C:\test>
[download]

Of course, I can imagine any number of scenarios in which this would not work, but in the absence of further info, attempting to compensate for them would simply be guesswork. If you have a better description of the application, I would relish the opportunity to practice my regex skills on real data.

As effective as Parser::RecDescent is for complex grammers, it seems overkill for this application as described. What's the point in having the much vaunted Perl 5 regex engine, if noone is going to learn to use it?

The regex notation is a mini-language of its own. Like any language, it takes time to learn. Like any language it takes practice to master.

This will work as long as the brace that closes the env block is the last one. To wit:

env {
   anything you want here
}
not-env {
   other stuff
}
[download]

is not going to work.

Now, it's possible that his input might look as simple as your example...but then he (hopefully) would have figured out a solution for that case already; something brain-dead like cat input | awk '{if (first == 1) {print l; l = $0;} else {first=1} }' for instance.

A poster above said it already -- if it nests, don't use regexes. Even if you do get it to work, you'll wish you hadn't.

---
"I hate it when I think myself into a corner."
Matt Mitchell

#!/usr/bin/perl
use strict;
use warnings;

my $verbose = 0;

my @lines = <DATA>;

my @items = split /(env\n\s*\{|\{|\})/, join '', @lines;

for (@items) {
    print "###$_###" if $verbose;
}

my $depth = 0;
my $inenv = 0;
my @envblocks;
my @envblock;
for (@items) {
    print ">>>$inenv.$depth---$_\n" if $verbose;
    ++$inenv if ($depth == 0 && /env\n\s*\{/); 
    ++$depth if (/\{/); 

    if ($inenv){
        push @envblock, $_;
        if ($depth == 1 && /\}/) {
            push @envblocks, join '', @envblock;
            @envblock = ();
            --$inenv;
        }
    }
    --$depth if (/\}/); 
    print "<<<$inenv.$depth---$_\n" if $verbose;
}

for (@envblocks) {
    print "===\n$_\n===\n";
}

__DATA__
somestuff
morestuff
env
{
    111
    env
    {
        333
    }
}
and more stuff
and things
zut
{
    222
    env
    {
        444
    }
}
env
{
    777
    env
    {
        555
    }
}
finally a few more things
[download]

===
env
{
    111
    env
    {
        333
    }
}
===
===
env
{
    777
    env
    {
        555
    }
}
===
[download]

$_=qq{
env 
{
{}{}
{{}}
}
};
(my $re=$_)=~s/((\{)|(\})|.)/${[')','']}[!$3]\Q$1\E${['(','']}[!$2]/gs
+;
$re = join'|',map{quotemeta}eval{/$re/};
die $@ if $@;
print +(/env\s*\{($re)\}/)[0];
[download]