In this case I think that an XML::Parser call wrapped in an eval is your best bet. Something like this:

foreach (@list_of_20_000_files) {
  my $p = XML::Parser->new;
  eval { $p->parsefile($_) };
  if ($@) {
    print "$_ is bad\n";
  } else {
    print "$_ is good\n";
  }
}
[download]

The one thing that worries me tho' is that you talk about 'snippets' of well-formed XML. If those snippets don't have one enclosing element, then they won't be well-formed.

"Perl makes the fun jobs fun
and the boring jobs bearable" - me

I will be wapping the string in a dummy tag.

--
Brother Marvell

Contrary to popular belief, wrapping a call to XML:Parser in an eval, provided it's a block eval, is completely kosher and does not inflict a huge (or actually any) performance penalty. In any case the actual parsing takes much longer than eval-ing a short string even if you choose to use the string version of eval. You can have a look at the review for a way to do this.

Now if you are trying to check tons of files you might want to use James Clarke sp. James Clarke is the guy who wrote the expat library on which XML::Parser is based. He also wrote part of XML-the-spec, groff and way to many things for me to list here... The interesting part is that sp is an SGML parser, which means that you will have to set a couple of environment variables to get it to parse XML (quite easy to do) but also that it will not stop at the first error in the file an try its best to find other errors. It will also probably be faster than using XML::Parser.

--ZZamboni

Its documentation states:

setHandlers(TYPE, HANDLER [, TYPE, HANDLER ...])

This method registers handlers for the various events. If no handlers are registered, then a call to parsestring or parsefile will only determine if the corresponding XML document is well formed (by returning without error.) This may be called from within a handler, after the parse has started.

It is hard to imagine Larry Wall, who wrote version 1.0 of XML::Parser::Expat in order to provide "lowlevel access to James Clark's expat XML parser," bloating his code. Borrowing Davorg's suggested solution, the test would then be:

$parser = new XML::Parser::Expat;
$parser->setHandlers();
open(FOO, 'info.xml') or die "Couldn't open";
eval { $parser->parse(*FOO) };
  if ($@) {
    print "$_ is bad\n";
  } else {
    print "$_ is good\n";
  }
close(FOO);
[download]

XML::Parser::Expat is just the lower level interface to Expat used by XML::Parser. It is no more venerable than XML::Parser.

XML::Parser is an object factory. Every time an XML::Parser object calls its parse or parsefile method, it calls XML::Parser::Expat to create a new parser object. So it does just what you do. And if you don't need any handler there is no need to call setHandlers, there will be no handler set by default.

As XML::Parser is kinda the official interface to XML::Parser::Expat, and although your code might be marginally faster, I would prefer a slightly improved version of davorg's code, where the creation of the XML object is pulled out of the loop:

  my $p = XML::Parser->new;           # needs to be done only once
  foreach (@list_of_20_000_files) {
    eval { $p->parsefile($_) };       # creates a new XML::Parser::Exp
+at object
    if ($@) {
      print "$_ is bad\n";
    } else {
      print "$_ is good\n";
    }
  }
[download]