Attachment 17766 Details for Bug 32164 – file.shar

file.shar

file.shar (text/plain), 122.62 KB, created by skv on 2001-11-21 10:30:01 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: skv

Created: 2001-11-21 10:30:01 UTC

Size: 122.62 KB

patch

obsolete

># This is a shell archive.  Save it in a file, remove anything before
># this line, and then unpack it by entering "sh file".  Note, it may
># create directories; files and directories will be owned by you and
># have default permissions.
>#
># This archive contains:
>#
>#	p5-XML-SAX-Simple
>#	p5-XML-SAX-Simple/pkg-comment
>#	p5-XML-SAX-Simple/Makefile
>#	p5-XML-SAX-Simple/distinfo
>#	p5-XML-SAX-Simple/pkg-descr
>#	p5-XML-SAX-Simple/pkg-plist
>#	p5-XML-SAX-Simple/work
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Changes
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile.PL
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/MANIFEST
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/README
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Simple.pm
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.t
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.xml
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/2_XMLout.t
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/3_Storable.t
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/4_MemShare.t
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/5_MemCopy.t
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/6_ObjIntf.t
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/desertnet.src
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/srt.xml
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir/test2.xml
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/test1.xml
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/.exists
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/Simple.pm
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple/.exists
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple/.exists
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/.exists
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/XML::SAX::Simple.3
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile
>#	p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/pm_to_blib
>#	p5-XML-SAX-Simple/work/.extract_done.p5-XML-SAX-Simple-0.01
>#	p5-XML-SAX-Simple/work/.patch_done.p5-XML-SAX-Simple-0.01
>#	p5-XML-SAX-Simple/work/.configure_done.p5-XML-SAX-Simple-0.01
>#	p5-XML-SAX-Simple/work/.build_done.p5-XML-SAX-Simple-0.01
>#	p5-XML-SAX-Simple/work/.PLIST.mktmp
>#	p5-XML-SAX-Simple/work/.install_done.p5-XML-SAX-Simple-0.01
>#	p5-XML-SAX-Simple/work/.PLIST.setuid
>#	p5-XML-SAX-Simple/work/.PLIST.startup
>#	p5-XML-SAX-Simple/work/.package_done.p5-XML-SAX-Simple-0.01
>#
>echo c - p5-XML-SAX-Simple
>mkdir -p p5-XML-SAX-Simple > /dev/null 2>&1
>echo x - p5-XML-SAX-Simple/pkg-comment
>sed 's/^X//' >p5-XML-SAX-Simple/pkg-comment << 'END-of-p5-XML-SAX-Simple/pkg-comment'
>XSAX version of XML::Simple
>END-of-p5-XML-SAX-Simple/pkg-comment
>echo x - p5-XML-SAX-Simple/Makefile
>sed 's/^X//' >p5-XML-SAX-Simple/Makefile << 'END-of-p5-XML-SAX-Simple/Makefile'
>X# New ports collection makefile for:	XML::SAX::Simple
>X# Date created:		21 Nov 2001
>X# Whom:			Sergey Skvortsov <skv@protey.ru>
>X#
>X# $FreeBSD$
>X#
>X
>XPORTNAME=	XML-SAX-Simple
>XPORTVERSION=	0.01
>XCATEGORIES=	textproc perl5
>XMASTER_SITES=	${MASTER_SITE_PERL_CPAN}
>XMASTER_SITE_SUBDIR=	XML
>XPKGNAMEPREFIX=	p5-
>X
>XMAINTAINER=	skv@protey.ru
>X
>XRUN_DEPENDS=	${LOCALBASE}/lib/perl5/site_perl/${PERL_VER}/XML/SAX.pm:${PORTSDIR}/textproc/p5-XML-SAX \
>X		${LOCALBASE}/lib/perl5/site_perl/${PERL_VER}/XML/Simple.pm:${PORTSDIR}/textproc/p5-XML-Simple
>XBUILD_DEPENDS=	${RUN_DEPENDS}
>X
>XPERL_CONFIGURE=	yes
>X
>XMAN3=		XML::SAX::Simple.3
>X
>XMANPREFIX=	${PREFIX}/lib/perl5/${PERL_VERSION}
>X
>X.include <bsd.port.mk>
>END-of-p5-XML-SAX-Simple/Makefile
>echo x - p5-XML-SAX-Simple/distinfo
>sed 's/^X//' >p5-XML-SAX-Simple/distinfo << 'END-of-p5-XML-SAX-Simple/distinfo'
>XMD5 (XML-SAX-Simple-0.01.tar.gz) = 8aebd4f3b3d5b5692d9d4ea21953d4cc
>END-of-p5-XML-SAX-Simple/distinfo
>echo x - p5-XML-SAX-Simple/pkg-descr
>sed 's/^X//' >p5-XML-SAX-Simple/pkg-descr << 'END-of-p5-XML-SAX-Simple/pkg-descr'
>XXML::SAX::Simple is a very simple version of XML::Simple but for
>XSAX. It can be used as a complete drop-in replacement for XML::Simple.
>X
>XWWW: http://search.cpan.org/search?dist=XML-SAX-Simple
>X
>X-- Sergey Skvortsov
>Xskv@protey.ru
>END-of-p5-XML-SAX-Simple/pkg-descr
>echo x - p5-XML-SAX-Simple/pkg-plist
>sed 's/^X//' >p5-XML-SAX-Simple/pkg-plist << 'END-of-p5-XML-SAX-Simple/pkg-plist'
>Xlib/perl5/site_perl/%%PERL_VER%%/%%PERL_ARCH%%/auto/XML/SAX/Simple/.packlist
>Xlib/perl5/site_perl/%%PERL_VER%%/XML/SAX/Simple.pm
>X@dirrm lib/perl5/site_perl/%%PERL_VER%%/%%PERL_ARCH%%/auto/XML/SAX/Simple
>X@unexec rmdir %D/lib/perl5/site_perl/%%PERL_VER%%/XML/SAX 2>/dev/null || true
>X@unexec rmdir %D/lib/perl5/site_perl/%%PERL_VER%%/XML 2>/dev/null || true
>X@unexec rmdir %D/lib/perl5/site_perl/%%PERL_VER%%/%%PERL_ARCH%%/auto/XML/SAX 2>/dev/null || true
>X@unexec rmdir %D/lib/perl5/site_perl/%%PERL_VER%%/%%PERL_ARCH%%/auto/XML 2>/dev/null || true
>END-of-p5-XML-SAX-Simple/pkg-plist
>echo c - p5-XML-SAX-Simple/work
>mkdir -p p5-XML-SAX-Simple/work > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01 > /dev/null 2>&1
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Changes
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Changes << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Changes'
>XRevision history for Perl extension XML::SAX::Simple.
>X
>X0.01  Wed Oct 31 15:52:17 2001
>X	- original version; created by h2xs 1.21 with options
>X		-A -X -n XML::SAX::Simple
>X
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Changes
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile.PL
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile.PL << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile.PL'
>Xuse ExtUtils::MakeMaker;
>X# See lib/ExtUtils/MakeMaker.pm for details of how to influence
>X# the contents of the Makefile that is written.
>XWriteMakefile(
>X    'NAME'		=> 'XML::SAX::Simple',
>X    'VERSION_FROM'	=> 'Simple.pm', # finds $VERSION
>X    'PREREQ_PM'		=> { 'XML::Simple' => 1.06, 
>X			     'XML::SAX' => 0.02,
>X                             'XML::Handler::Trees' => 0.02,
>X                           },
>X    ($] >= 5.005 ?    ## Add these new keywords supported since 5.005
>X      (ABSTRACT_FROM => 'Simple.pm', # retrieve abstract from module
>X      AUTHOR     => 'Matt Sergeant, <matt@sergeant.org>') : ()),
>X);
>X
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile.PL
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/MANIFEST
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/MANIFEST << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/MANIFEST'
>XChanges
>XMANIFEST
>XMakefile.PL
>XREADME
>XSimple.pm
>Xt/1_XMLin.t
>Xt/1_XMLin.xml
>Xt/2_XMLout.t
>Xt/3_Storable.t
>Xt/4_MemShare.t
>Xt/5_MemCopy.t
>Xt/6_ObjIntf.t
>Xt/desertnet.src
>Xt/subdir/test2.xml
>Xt/srt.xml
>Xt/test1.xml
>X
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/MANIFEST
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/README
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/README << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/README'
>XXML/SAX/Simple
>X==============
>X
>XThis is a SAX version of XML::Simple. It works exactly the same
>Xas XML::Simple, so see the documentation of that module for details.
>XThe benefit of using this over XML::Simple is that XML::SAX::Simple
>Xwill use any Perl SAX2 parser installed on your system (via XML::SAX),
>Xrather than being hard coded to use XML::Parser.
>X
>XINSTALLATION
>X
>XTo install this module type the following:
>X
>X   perl Makefile.PL
>X   make
>X   make test
>X   make install
>X
>XDEPENDENCIES
>X
>XThis module requires these other modules and libraries:
>X
>X  XML::Simple, XML::SAX, XML::Handler::Trees
>X
>XCOPYRIGHT AND LICENCE
>X
>XThis is free software. You may use it and distribute it under the
>Xsame terms as Perl itself.
>X
>XCopyright (C) 2001 Matt Sergeant, matt@sergeant.org
>X
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/README
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Simple.pm
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Simple.pm << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Simple.pm'
>X# $Id: Simple.pm,v 1.1.1.1 2001/11/13 14:07:40 matt Exp $
>X
>Xpackage XML::SAX::Simple;
>X
>Xuse strict;
>Xuse vars qw($VERSION @ISA @EXPORT);
>Xuse XML::Simple ();
>Xuse XML::SAX;
>Xuse XML::Handler::Trees;
>X@ISA = ('XML::Simple');
>X
>X$VERSION = '0.01';
>X
>X@EXPORT = qw(XMLin XMLout);
>X
>Xsub XMLin {
>X    my $self;
>X    if($_[0]  and  UNIVERSAL::isa($_[0], 'XML::Simple')) {
>X        $self = shift;
>X    }
>X    else {
>X        $self = new XML::SAX::Simple();
>X    }
>X    $self->SUPER::XMLin(@_);
>X}
>X
>Xsub XMLout {
>X    my $self;
>X    if($_[0]  and  UNIVERSAL::isa($_[0], 'XML::Simple')) {
>X        $self = shift;
>X    }
>X    else {
>X        $self = new XML::SAX::Simple();
>X    }
>X    $self->SUPER::XMLout(@_);
>X}
>X
>Xsub build_tree {
>X    my $self = shift;
>X    my ($filename, $string) = @_;
>X    
>X    if($filename  and  $filename eq '-') {
>X        local($/);
>X        $string = <STDIN>;
>X        $filename = undef;
>X    }
>X    
>X    my $handler = XML::Handler::Tree->new();
>X    my $parser = XML::SAX::ParserFactory->parser(Handler => $handler);
>X    my $tree;
>X    if($filename) {
>X        $tree = $parser->parse_uri($filename);
>X    }
>X    else {
>X        if (ref($string)) {
>X            $tree = $parser->parse_file($string);
>X        }
>X        else {
>X            $tree = $parser->parse_string($string);
>X        }
>X    }
>X
>X    # use Data::Dumper;
>X    # warn("returning ", Dumper($tree), "\n");
>X    return($tree);
>X}
>X
>X1;
>X__END__
>X
>X=head1 NAME
>X
>XXML::SAX::Simple - SAX version of XML::Simple
>X
>X=head1 SYNOPSIS
>X
>X  use XML::SAX::Simple qw(XMLin XMLout);
>X  my $hash = XMLin("foo.xml");
>X
>X=head1 DESCRIPTION
>X
>XXML::SAX::Simple is a very simple version of XML::Simple but for
>XSAX. It can be used as a complete drop-in replacement for XML::Simple.
>X
>XSee the documentation for XML::Simple (which is required for this module
>Xto work) for details.
>X
>X=head1 AUTHOR
>X
>XMatt Sergeant, matt@sergeant.org
>X
>X=head1 SEE ALSO
>X
>XL<XML::Simple>, L<XML::SAX>.
>X
>X=cut
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Simple.pm
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t > /dev/null 2>&1
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.t
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.t'
>Xuse strict;
>Xuse IO::File;
>Xuse File::Spec;
>X
>X$|++;
>X
>X# Initialise filenames and check they're there
>X
>Xmy $XMLFile = File::Spec->catfile('t', 'test1.xml');  # t/test1.xml
>X
>Xunless(-e $XMLFile) {
>X  print STDERR "test data missing...";
>X  print "1..0\n";
>X  exit 0;
>X}
>X
>X
>Xprint "1..65\n";
>X
>Xmy $t = 1;
>X
>X##############################################################################
>X#                   S U P P O R T   R O U T I N E S
>X##############################################################################
>X
>X##############################################################################
>X# Print out 'n ok' or 'n not ok' as expected by test harness.
>X# First arg is test number (n).  If only one following arg, it is interpreted
>X# as true/false value.  If two args, equality = true.
>X#
>X
>Xsub ok {
>X  my($n, $x, $y) = @_;
>X  die "Sequence error got $n expected $t" if($n != $t);
>X  $x = 0 if(@_ > 2  and  $x ne $y);
>X  print(($x ? '' : 'not '), 'ok ', $t++, "\n");
>X}
>X
>X
>X##############################################################################
>X# Take two scalar values (may be references) and compare them (recursively
>X# if necessary) returning 1 if same, 0 if different.
>X#
>X
>Xsub DataCompare {
>X  my($x, $y) = @_;
>X
>X  my($i);
>X
>X  if(!defined($x)) {
>X    return(1) if(!defined($y));
>X    print STDERR "$t:DataCompare: undef != $y\n";
>X    return(0);
>X  }
>X
>X
>X  if(!ref($x)) {
>X    return(1) if($x eq $y);
>X    print STDERR "$t:DataCompare: $x != $y\n";
>X    return(0);
>X  }
>X
>X  if(ref($x) eq 'ARRAY') {
>X    unless(ref($y) eq 'ARRAY') {
>X      print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(@$x) != scalar(@$y)) {
>X      print STDERR "$t:DataCompare: expected ", scalar(@$x),
>X                   " element(s), got: ", scalar(@$y), "\n";
>X      return(0);
>X    }
>X    for($i = 0; $i < scalar(@$x); $i++) {
>X      DataCompare($x->[$i], $y->[$i]) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  if(ref($x) eq 'HASH') {
>X    unless(ref($y) eq 'HASH') {
>X      print STDERR "$t:DataCompare: expected hashref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(keys(%$x)) != scalar(keys(%$y))) {
>X      print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
>X                   " key(s), (", join(', ', keys(%$x)),
>X		   ") got: ",  scalar(keys(%$y)), " (", join(', ', keys(%$y)),
>X		   ")\n";
>X      return(0);
>X    }
>X    foreach $i (keys(%$x)) {
>X      unless(exists($y->{$i})) {
>X	print STDERR "$t:DataCompare: missing hash key - {$i}\n";
>X	return(0);
>X      }
>X      DataCompare($x->{$i}, $y->{$i}) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  print STDERR "Don't know how to compare: " . ref($x) . "\n";
>X  return(0);
>X}
>X
>X
>X##############################################################################
>X#                      T E S T   R O U T I N E S
>X##############################################################################
>X
>Xeval "use XML::SAX::Simple;";
>Xok(1, !$@);                       # Module compiled OK
>X
>X# Start by parsing an extremely simple piece of XML
>X
>Xmy $opt = XMLin(q(<opt name1="value1" name2="value2"></opt>));
>X
>Xmy $expected = {
>X		 name1 => 'value1',
>X		 name2 => 'value2',
>X	       };
>X
>Xok(2, 1);                         # XMLin() didn't crash 
>Xok(3, defined($opt));             # and it returned a value
>Xok(4, ref($opt) eq 'HASH');       # and a hasref at that
>Xok(5, DataCompare($opt, $expected));
>X
>X
>X# Now try a slightly more complex one that returns the same value
>X
>X$opt = XMLin(q(
>X  <opt> 
>X    <name1>value1</name1>
>X    <name2>value2</name2>
>X  </opt>
>X));
>Xok(6, DataCompare($opt, $expected));
>X
>X
>X# And something else that returns the same (line break included to pick up
>X# missing /s bug)
>X
>X$opt = XMLin(q(<opt name1="value1"
>X                    name2="value2" />));
>Xok(7, DataCompare($opt, $expected));
>X
>X
>X# Try something with two lists of nested values 
>X
>X$opt = XMLin(q(
>X  <opt> 
>X    <name1>value1.1</name1>
>X    <name1>value1.2</name1>
>X    <name1>value1.3</name1>
>X    <name2>value2.1</name2>
>X    <name2>value2.2</name2>
>X    <name2>value2.3</name2>
>X  </opt>)
>X);
>X
>Xok(8, DataCompare($opt, {
>X  name1 => [ 'value1.1', 'value1.2', 'value1.3' ],
>X  name2 => [ 'value2.1', 'value2.2', 'value2.3' ],
>X}));
>X
>X
>X# Now a simple nested hash
>X
>X$opt = XMLin(q(
>X  <opt> 
>X    <item name1="value1" name2="value2" />
>X  </opt>)
>X);
>X
>Xok(9, DataCompare($opt, {
>X  item => { name1 => 'value1', name2 => 'value2' }
>X}));
>X
>X
>X# Now a list of nested hashes
>X
>X$opt = XMLin(q(
>X  <opt> 
>X    <item name1="value1" name2="value2" />
>X    <item name1="value3" name2="value4" />
>X  </opt>)
>X);
>Xok(10, DataCompare($opt, {
>X  item => [
>X            { name1 => 'value1', name2 => 'value2' },
>X            { name1 => 'value3', name2 => 'value4' }
>X	  ]
>X}));
>X
>X
>X# Now a list of nested hashes transformed into a hash using default key names
>X
>Xmy $string = q(
>X  <opt> 
>X    <item name="item1" attr1="value1" attr2="value2" />
>X    <item name="item2" attr1="value3" attr2="value4" />
>X  </opt>
>X);
>Xmy $target = {
>X  item => {
>X            item1 => { attr1 => 'value1', attr2 => 'value2' },
>X            item2 => { attr1 => 'value3', attr2 => 'value4' }
>X	  }
>X};
>X$opt = XMLin($string);
>Xok(11, DataCompare($opt, $target));
>X
>X
>X# Same thing left as an array by suppressing default key names
>X
>X$target = {
>X  item => [
>X            {name => 'item1', attr1 => 'value1', attr2 => 'value2' },
>X            {name => 'item2', attr1 => 'value3', attr2 => 'value4' }
>X	  ]
>X};
>X$opt = XMLin($string, keyattr => [] );
>Xok(12, DataCompare($opt, $target));
>X
>X
>X# Same again with alternative key suppression
>X
>X$opt = XMLin($string, keyattr => {} );
>Xok(13, DataCompare($opt, $target));
>X
>X
>X# Try the other two default key attribute names
>X
>X$opt = XMLin(q(
>X  <opt> 
>X    <item key="item1" attr1="value1" attr2="value2" />
>X    <item key="item2" attr1="value3" attr2="value4" />
>X  </opt>
>X));
>Xok(14, DataCompare($opt, {
>X  item => {
>X            item1 => { attr1 => 'value1', attr2 => 'value2' },
>X            item2 => { attr1 => 'value3', attr2 => 'value4' }
>X	  }
>X}));
>X
>X
>X$opt = XMLin(q(
>X  <opt> 
>X    <item id="item1" attr1="value1" attr2="value2" />
>X    <item id="item2" attr1="value3" attr2="value4" />
>X  </opt>
>X));
>Xok(15, DataCompare($opt, {
>X  item => {
>X            item1 => { attr1 => 'value1', attr2 => 'value2' },
>X            item2 => { attr1 => 'value3', attr2 => 'value4' }
>X	  }
>X}));
>X
>X
>X# Similar thing using non-standard key names
>X
>Xmy $xml = q(
>X  <opt> 
>X    <item xname="item1" attr1="value1" attr2="value2" />
>X    <item xname="item2" attr1="value3" attr2="value4" />
>X  </opt>);
>X
>X$target = {
>X  item => {
>X            item1 => { attr1 => 'value1', attr2 => 'value2' },
>X            item2 => { attr1 => 'value3', attr2 => 'value4' }
>X	  }
>X};
>X
>X$opt = XMLin($xml, keyattr => [qw(xname)]);
>Xok(16, DataCompare($opt, $target));
>X
>X
>X# And with precise element/key specification
>X
>X$opt = XMLin($xml, keyattr => { 'item' => 'xname' });
>Xok(17, DataCompare($opt, $target));
>X
>X
>X# Same again but with key field further down the list
>X
>X$opt = XMLin($xml, keyattr => [qw(wibble xname)]);
>Xok(18, DataCompare($opt, $target));
>X
>X
>X# Same again but with key field supplied as scalar
>X
>X$opt = XMLin($xml, keyattr => qw(xname));
>Xok(19, DataCompare($opt, $target));
>X
>X
>X# Weird variation, not exactly what we wanted but it is what we expected 
>X# given the current implementation and we don't want to break it accidently
>X
>X$xml = q(
>X<opt>
>X  <item id="one" value="1" name="a" />
>X  <item id="two" value="2" />
>X  <item id="three" value="3" />
>X</opt>
>X);
>X
>X$target = { item => {
>X    'three' => { 'value' => 3 },
>X    'a'     => { 'value' => 1, 'id' => 'one' },
>X    'two'   => { 'value' => 2 }
>X  }
>X};
>X
>X$opt = XMLin($xml);
>Xok(20, DataCompare($opt, $target));
>X
>X
>X# Or somewhat more as one might expect
>X
>X$target = { item => {
>X    'one'   => { 'value' => '1', 'name' => 'a' },
>X    'two'   => { 'value' => '2' },
>X    'three' => { 'value' => '3' },
>X  }
>X};
>X$opt = XMLin($xml, keyattr => { 'item' => 'id' });
>Xok(21, DataCompare($opt, $target));
>X
>X
>X# Now a somewhat more complex test of targetting folding
>X
>X$xml = q(
>X<opt>
>X  <car license="SH6673" make="Ford" id="1">
>X    <option key="1" pn="6389733317-12" desc="Electric Windows"/>
>X    <option key="2" pn="3735498158-01" desc="Leather Seats"/>
>X    <option key="3" pn="5776155953-25" desc="Sun Roof"/>
>X  </car>
>X  <car license="LW1804" make="GM"   id="2">
>X    <option key="1" pn="9926543-1167" desc="Steering Wheel"/>
>X  </car>
>X</opt>
>X);
>X
>X$target = {
>X  'car' => {
>X    'LW1804' => {
>X      'id' => 2,
>X      'make' => 'GM',
>X      'option' => {
>X	  '9926543-1167' => { 'key' => 1, 'desc' => 'Steering Wheel' }
>X      }
>X    },
>X    'SH6673' => {
>X      'id' => 1,
>X      'make' => 'Ford',
>X      'option' => {
>X	  '6389733317-12' => { 'key' => 1, 'desc' => 'Electric Windows' },
>X	  '3735498158-01' => { 'key' => 2, 'desc' => 'Leather Seats' },
>X	  '5776155953-25' => { 'key' => 3, 'desc' => 'Sun Roof' }
>X      }
>X    }
>X  }
>X};
>X
>X$opt = XMLin($xml, forcearray => 1, keyattr => { 'car' => 'license', 'option' => 'pn' });
>Xok(22, DataCompare($opt, $target));
>X
>X
>X# Now try leaving the keys in place
>X
>X$target = {
>X  'car' => {
>X    'LW1804' => {
>X      'id' => 2,
>X      'make' => 'GM',
>X      'option' => {
>X	  '9926543-1167' => { 'key' => 1, 'desc' => 'Steering Wheel',
>X	                      '-pn' => '9926543-1167' }
>X      },
>X      license => 'LW1804'
>X    },
>X    'SH6673' => {
>X      'id' => 1,
>X      'make' => 'Ford',
>X      'option' => {
>X	  '6389733317-12' => { 'key' => 1, 'desc' => 'Electric Windows',
>X	                       '-pn' => '6389733317-12' },
>X	  '3735498158-01' => { 'key' => 2, 'desc' => 'Leather Seats',
>X	                       '-pn' => '3735498158-01' },
>X	  '5776155953-25' => { 'key' => 3, 'desc' => 'Sun Roof',
>X	                       '-pn' => '5776155953-25' }
>X      },
>X      license => 'SH6673'
>X    }
>X  }
>X};
>X$opt = XMLin($xml, forcearray => 1, keyattr => { 'car' => '+license', 'option' => '-pn' });
>Xok(23, DataCompare($opt, $target));
>X
>X
>X# Make sure that the root element name is preserved if we ask for it
>X
>X$target = XMLin("<opt>$xml</opt>", forcearray => 1,
>X                keyattr => { 'car' => '+license', 'option' => '-pn' });
>X
>X$opt    = XMLin(      $xml,        forcearray => 1, keeproot => 1,
>X                keyattr => { 'car' => '+license', 'option' => '-pn' });
>X
>Xok(24, DataCompare($opt, $target));
>X
>X
>X# confirm that CDATA sections parse correctly
>X
>X$xml = q{<opt><cdata><![CDATA[<greeting>Hello, world!</greeting>]]></cdata></opt>};
>X$opt = XMLin($xml);
>Xok(25, DataCompare($opt, {
>X  'cdata' => '<greeting>Hello, world!</greeting>'
>X}));
>X
>X$xml = q{<opt><x><![CDATA[<y>one</y>]]><![CDATA[<y>two</y>]]></x></opt>};
>X$opt = XMLin($xml);
>Xok(26, DataCompare($opt, {
>X  'x' => '<y>one</y><y>two</y>'
>X}));
>X
>X
>X# Try parsing a named external file
>X
>X$opt = eval{ XMLin($XMLFile); };
>Xok(27, !$@);                                  # XMLin didn't die
>Xprint STDERR $@ if($@);
>Xok(28, DataCompare($opt, {
>X  location => 't/test1.xml'
>X}));
>X
>X
>X# Try parsing default external file (scriptname.xml in script directory)
>X
>X$opt = eval { XMLin(); };
>Xprint STDERR $@ if($@);
>Xok(29, !$@);                                  # XMLin didn't die
>Xok(30, DataCompare($opt, {
>X  location => 't/1_XMLin.xml'
>X}));
>X
>X
>X# Try parsing named file in a directory in the searchpath
>X
>X$opt = eval {
>X  XMLin('test2.xml', searchpath => [
>X    'dir1', 'dir2', File::Spec->catdir('t', 'subdir')
>X  ] );
>X
>X};
>Xprint STDERR $@ if($@);
>Xok(31, !$@);                                  # XMLin didn't die
>Xok(32, DataCompare($opt, { location => 't/subdir/test2.xml' }));
>X
>X
>X# Ensure we get expected result if file does not exist
>X
>X$opt = eval {
>X  XMLin('bogusfile.xml', searchpath => [qw(. ./t)] ); # should 'die'
>X};
>Xok(33, !defined($opt));                          # XMLin failed
>Xok(34, $@ =~ /Could not find bogusfile.xml in/); # with the expected message
>X
>X
>X# Try parsing from an IO::Handle 
>X
>Xmy $fh = new IO::File;
>X$XMLFile = File::Spec->catfile('t', '1_XMLin.xml');  # t/1_XMLin.xml
>X$fh->open($XMLFile) || die "$!";
>X$opt = XMLin($fh);
>Xok(35, 1);                                      # XMLin didn't die
>Xok(36, $opt->{location}, 't/1_XMLin.xml');      # and it parsed the right file
>X
>X
>X# Try parsing from STDIN
>X
>Xclose(STDIN);
>Xopen(STDIN, $XMLFile) || die "$!";
>X$opt = XMLin('-');
>Xok(37, $opt->{location}, 't/1_XMLin.xml');      # parsed the right file
>X
>X
>X# Confirm anonymous array folding works in general
>X
>X$opt = XMLin(q(
>X  <opt>
>X    <row>
>X      <anon>0.0</anon><anon>0.1</anon><anon>0.2</anon>
>X    </row>
>X    <row>
>X      <anon>1.0</anon><anon>1.1</anon><anon>1.2</anon>
>X    </row>
>X    <row>
>X      <anon>2.0</anon><anon>2.1</anon><anon>2.2</anon>
>X    </row>
>X  </opt>
>X));
>Xok(38, DataCompare($opt, {
>X  row => [
>X	   [ '0.0', '0.1', '0.2' ],
>X	   [ '1.0', '1.1', '1.2' ],
>X	   [ '2.0', '2.1', '2.2' ]
>X         ]
>X}));
>X
>X
>X# Confirm anonymous array folding works in special top level case
>X
>X$opt = XMLin(q{
>X  <opt>
>X    <anon>one</anon>
>X    <anon>two</anon>
>X    <anon>three</anon>
>X  </opt>
>X});
>Xok(39, DataCompare($opt, [
>X  qw(one two three)
>X]));
>X
>X
>X$opt = XMLin(q(
>X  <opt>
>X    <anon>1</anon>
>X    <anon>
>X      <anon>2.1</anon>
>X      <anon>
>X	<anon>2.2.1</anon>
>X	<anon>2.2.2</anon>
>X      </anon>
>X    </anon>
>X  </opt>
>X));
>Xok(40, DataCompare($opt, [
>X  1,
>X  [
>X   '2.1', [ '2.2.1', '2.2.2']
>X  ]
>X]));
>X
>X
>X# Check for the dreaded 'content' attribute
>X
>X$xml = q(
>X  <opt>
>X    <item attr="value">text</item>
>X  </opt>
>X);
>X
>X$opt = XMLin($xml);
>Xok(41, DataCompare($opt, {
>X  item => {
>X	    content => 'text',
>X	    attr    => 'value' 
>X          }
>X}));
>X
>X
>X# And check that we can change its name if required
>X
>X$opt = XMLin($xml, contentkey => 'text_content');
>Xok(42, DataCompare($opt, {
>X  item => {
>X	    text_content => 'text',
>X	    attr         => 'value'
>X          }
>X}));
>X
>X
>X# Check that it doesn't get screwed up by forcearray option
>X
>X$xml = q(<opt attr="value">text content</opt>);
>X
>X$opt = XMLin($xml, forcearray => 1);
>Xok(43, DataCompare($opt, {
>X  'attr'   => 'value',
>X  'content' => 'text content'
>X}));
>X
>X
>X# Test that we can force all text content to parse to hash values
>X
>X$xml = q(<opt><x>text1</x><y a="2">text2</y></opt>);
>X$opt = XMLin($xml, forcecontent => 1);
>Xok(44, DataCompare($opt, {
>X    'x' => {           'content' => 'text1' },
>X    'y' => { 'a' => 2, 'content' => 'text2' }
>X}));
>X
>X
>X# And that this is compatible with changing the key name
>X
>X$opt = XMLin($xml, forcecontent => 1, contentkey => '0');
>Xok(45, DataCompare($opt, {
>X    'x' => {           0 => 'text1' },
>X    'y' => { 'a' => 2, 0 => 'text2' }
>X}));
>X
>X
>X# Check that mixed content parses in the weird way we expect
>X
>X$xml = q(<p class="mixed">Text with a <b>bold</b> word</p>);
>X
>Xok(46, DataCompare(XMLin($xml), {
>X  'class'   => 'mixed',
>X  'content' => [ 'Text with a ', ' word' ],
>X  'b'       => 'bold'
>X}));
>X
>X
>X# Confirm single nested element rolls up into a scalar attribute value
>X
>X$string = q(
>X  <opt>
>X    <name>value</name>
>X  </opt>
>X);
>X$opt = XMLin($string);
>Xok(47, DataCompare($opt, {
>X  name => 'value'
>X}));
>X
>X
>X# Unless 'forcearray' option is specified
>X
>X$opt = XMLin($string, forcearray => 1);
>Xok(48, DataCompare($opt, {
>X  name => [ 'value' ]
>X}));
>X
>X
>X# Confirm array folding of single nested hash
>X
>X$string = q(<opt>
>X  <inner name="one" value="1" />
>X</opt>);
>X
>X$opt = XMLin($string, forcearray => 1);
>Xok(49, DataCompare($opt, {
>X  'inner' => { 'one' => { 'value' => 1 } }
>X}));
>X
>X
>X# But not without forcearray option specified
>X
>X$opt = XMLin($string, forcearray => 0);
>Xok(50, DataCompare($opt, {
>X  'inner' => { 'name' => 'one', 'value' => 1 } 
>X}));
>X
>X
>X# Test advanced features of forcearray
>X
>X$xml = q(<opt zero="0">
>X  <one>i</one>
>X  <two>ii</two>
>X  <three>iii</three>
>X  <three>3</three>
>X  <three>c</three>
>X</opt>
>X);
>X
>X$opt = XMLin($xml, forcearray => [ 'two' ]);
>Xok(51, DataCompare($opt, {
>X  'zero' => '0',
>X  'one' => 'i',
>X  'two' => [ 'ii' ],
>X  'three' => [ 'iii', 3, 'c' ]
>X}));
>X
>X
>X# Test 'noattr' option
>X
>X$xml = q(<opt name="user" password="foobar">
>X  <nest attr="value">text</nest>
>X</opt>
>X);
>X
>X$opt = XMLin($xml, noattr => 1);
>Xok(52, DataCompare($opt, { nest => 'text' }));
>X
>X
>X# And make sure it doesn't screw up array folding 
>X
>X$xml = q{<opt>
>X  <item><key>a</key><value>alpha</value></item>
>X  <item><key>b</key><value>beta</value></item>
>X  <item><key>g</key><value>gamma</value></item>
>X</opt>
>X};
>X
>X
>X$opt = XMLin($xml, noattr => 1);
>Xok(53, DataCompare($opt, {
>X 'item' => {
>X    'a' => { 'value' => 'alpha' },
>X    'b' => { 'value' => 'beta' },
>X    'g' => { 'value' => 'gamma' }
>X  }
>X}));
>X
>X
>X# Confirm empty elements parse to empty hashrefs
>X
>X$xml = q(<body>
>X  <name>bob</name>
>X  <outer attr="value">
>X    <inner1 />
>X    <inner2></inner2>
>X  </outer>
>X</body>);
>X
>X$opt = XMLin($xml, noattr => 1);
>Xok(54, DataCompare($opt, {
>X  'name' => 'bob',
>X  'outer' => {
>X    'inner1' => {},
>X    'inner2' => {}
>X  }
>X}));
>X
>X
>X# Unless 'suppressempty' is enabled
>X
>X$opt = XMLin($xml, noattr => 1, suppressempty => 1);
>Xok(55, DataCompare($opt, { 'name' => 'bob', }));
>X
>X
>X# Check behaviour when 'suppressempty' is set to to undef;
>X
>X$opt = XMLin($xml, noattr => 1, suppressempty => undef);
>Xok(56, DataCompare($opt, {
>X  'name' => 'bob',
>X  'outer' => {
>X    'inner1' => undef,
>X    'inner2' => undef
>X  }
>X}));
>X
>X# Check behaviour when 'suppressempty' is set to to empty string;
>X
>X$opt = XMLin($xml, noattr => 1, suppressempty => '');
>Xok(57, DataCompare($opt, {
>X  'name' => 'bob',
>X  'outer' => {
>X    'inner1' => '',
>X    'inner2' => ''
>X  }
>X}));
>X
>X# Confirm completely empty XML parses to undef with 'suppressempty'
>X
>X$xml = q(<body>
>X  <outer attr="value">
>X    <inner1 />
>X    <inner2></inner2>
>X  </outer>
>X</body>);
>X
>X$opt = XMLin($xml, noattr => 1, suppressempty => 1);
>Xok(58, DataCompare($opt, undef));
>X
>X
>X# Test that nothing unusual happens with namespaces by default
>X
>X$xml = q(<opt xmlns="urn:accounts" xmlns:eng="urn:engineering">
>X  <invoice_num>12345678</invoice_num>
>X  <eng:partnum>8001-22374-001</eng:partnum>
>X</opt>);
>X
>X$opt = XMLin($xml);
>Xok(59, DataCompare($opt, {
>X  'xmlns' => 'urn:accounts',
>X  '{urn:accounts}invoice_num' => '12345678',
>X  '{urn:engineering}partnum' => '8001-22374-001',
>X  '{http://www.w3.org/2000/xmlns/}eng' => 'urn:engineering',
>X}));
>X
>X
>X# Test that we can pass an option in to turn on XML::Parser's namespace mode
>X
>X# Skip for now since I haven't added this feature to XML::SAX::PurePerl yet!
>Xok(60, 1);
>X# $opt = XMLin($xml, parseropts => [ Namespaces => 1 ]);
>X# ok(60, DataCompare($opt, {
>X#  'invoice_num' => 12345678,
>X#  'partnum' => '8001-22374-001'
>X# }));
>X
>X
>X# Test option error handling
>X
>X$_ = eval { XMLin('<x y="z" />', rootname => 'fred') }; # not valid for XMLin()
>Xok(61, !defined($_));
>Xok(62, $@ =~ /Unrecognised option:/);
>X
>X$_ = eval { XMLin('<x y="z" />', 'searchpath') };
>Xok(63, !defined($_));
>Xok(64, $@ =~ /Options must be name=>value pairs .odd number supplied./);
>X
>X
>X# Now for a 'real world' test, try slurping in an SRT config file
>X
>X$opt = XMLin(File::Spec->catfile('t', 'srt.xml'), forcearray => 1);
>X$target = {
>X  'global' => [
>X    {
>X      'proxypswd' => 'bar',
>X      'proxyuser' => 'foo',
>X      'exclude' => [
>X        '/_vt',
>X        '/save\\b',
>X        '\\.bak$',
>X        '\\.\\$\\$\\$$'
>X      ],
>X      'httpproxy' => 'http://10.1.1.5:8080/',
>X      'tempdir' => 'C:/Temp'
>X    }
>X  ],
>X  'pubpath' => {
>X    'test1' => {
>X      'source' => [
>X        {
>X          'label' => 'web_source',
>X          'root' => 'C:/webshare/web_source'
>X        }
>X      ],
>X      'title' => 'web_source -> web_target1',
>X      'package' => {
>X        'images' => { 'dir' => 'wwwroot/images' }
>X      },
>X      'target' => [
>X        {
>X          'label' => 'web_target1',
>X          'root' => 'C:/webshare/web_target1',
>X          'temp' => 'C:/webshare/web_target1/temp'
>X        }
>X      ],
>X      'dir' => [ 'wwwroot' ]
>X    },
>X    'test2' => {
>X      'source' => [
>X        {
>X          'label' => 'web_source',
>X          'root' => 'C:/webshare/web_source'
>X        }
>X      ],
>X      'title' => 'web_source -> web_target1 & web_target2',
>X      'package' => {
>X        'bios' => { 'dir' => 'wwwroot/staff/bios' },
>X        'images' => { 'dir' => 'wwwroot/images' },
>X        'templates' => { 'dir' => 'wwwroot/templates' }
>X      },
>X      'target' => [
>X        {
>X          'label' => 'web_target1',
>X          'root' => 'C:/webshare/web_target1',
>X          'temp' => 'C:/webshare/web_target1/temp'
>X        },
>X        {
>X          'label' => 'web_target2',
>X          'root' => 'C:/webshare/web_target2',
>X          'temp' => 'C:/webshare/web_target2/temp'
>X        }
>X      ],
>X      'dir' => [ 'wwwroot' ]
>X    },
>X    'test3' => {
>X      'source' => [
>X        {
>X          'label' => 'web_source',
>X          'root' => 'C:/webshare/web_source'
>X        }
>X      ],
>X      'title' => 'web_source -> web_target1 via HTTP',
>X      'addexclude' => [ '\\.pdf$' ],
>X      'target' => [
>X        {
>X          'label' => 'web_target1',
>X          'root' => 'http://127.0.0.1/cgi-bin/srt_slave.plx',
>X          'noproxy' => 1
>X        }
>X      ],
>X      'dir' => [ 'wwwroot' ]
>X    }
>X  }
>X};
>Xok(65, DataCompare($target, $opt));
>X
>X
>Xexit(0);
>X
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.t
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.xml
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.xml << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.xml'
>X<opt location="t/1_XMLin.xml" />
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.xml
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/2_XMLout.t
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/2_XMLout.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/2_XMLout.t'
>Xuse strict;
>Xuse IO::File;
>X
>X$|++;
>X
>XBEGIN { print "1..189\n"; }
>X
>Xmy $t = 1;
>X
>X##############################################################################
>X#                   S U P P O R T   R O U T I N E S
>X##############################################################################
>X
>X##############################################################################
>X# Print out 'n ok' or 'n not ok' as expected by test harness.
>X# First arg is test number (n).  If only one following arg, it is interpreted
>X# as true/false value.  If two args, equality = true.
>X#
>X
>Xsub ok {
>X  my($n, $x, $y) = @_;
>X  die "Sequence error got $n expected $t" if($n != $t);
>X    $x = 0 if(@_ > 2  and  $x ne $y);
>X  print(($x ? '' : 'not '), 'ok ', $t++, "\n");
>X}
>X
>X##############################################################################
>X# Take two scalar values (may be references) and compare them (recursively
>X# if necessary) returning 1 if same, 0 if different.
>X#
>X
>Xsub DataCompare {
>X  my($x, $y) = @_;
>X
>X  my($i);
>X
>X  if(!ref($x)) {
>X    return(1) if($x eq $y);
>X    print STDERR "$t:DataCompare: $x != $y\n";
>X    return(0);
>X  }
>X
>X  if(ref($x) eq 'ARRAY') {
>X    unless(ref($y) eq 'ARRAY') {
>X      print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(@$x) != scalar(@$y)) {
>X      print STDERR "$t:DataCompare: expected ", scalar(@$x),
>X                   " element(s), got: ", scalar(@$y), "\n";
>X      return(0);
>X    }
>X    for($i = 0; $i < scalar(@$x); $i++) {
>X      DataCompare($x->[$i], $y->[$i]) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  if(ref($x) eq 'HASH') {
>X    unless(ref($y) eq 'HASH') {
>X      print STDERR "$t:DataCompare: expected hashref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(keys(%$x)) != scalar(keys(%$y))) {
>X      print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
>X                   " key(s) (", join(', ', keys(%$x)),
>X		   "), got: ",  scalar(keys(%$y)), " (", join(', ', keys(%$y)),
>X		   ")\n";
>X      return(0);
>X    }
>X    foreach $i (keys(%$x)) {
>X      unless(exists($y->{$i})) {
>X	print STDERR "$t:DataCompare: missing hash key - {$i}\n";
>X	return(0);
>X      }
>X      DataCompare($x->{$i}, $y->{$i}) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  print STDERR "Don't know how to compare: " . ref($x) . "\n";
>X  return(0);
>X}
>X
>X
>X##############################################################################
>X# Read file and return contents as a scalar.
>X#
>X
>Xsub ReadFile {
>X  local($/) = undef;
>X
>X  open(_READ_FILE_, $_[0]) || die "open($_[0]): $!";
>X  my $data = <_READ_FILE_>;
>X  close(_READ_FILE_);
>X  return($data);
>X}
>X
>Xuse XML::SAX::Simple;
>X
>X# Try encoding a scalar value
>X
>Xmy $xml = XMLout("scalar");
>Xok(1, 1);                             # XMLout did not crash 
>Xok(2, defined($xml));                 # and it returned an XML string
>Xok(3, XMLin($xml), 'scalar');         # which parses back OK
>X
>X
>X# Next try encoding a hash
>X
>Xmy $hashref1 = { one => 1, two => 'II', three => '...' };
>Xmy $hashref2 = { one => 1, two => 'II', three => '...' };
>X
>X# Expect:
>X# <opt one="1" two="II" three="..." />
>X
>X$_ = XMLout($hashref1);               # Encode to $_ for convenience
>X                                      # Confirm it parses back OK
>Xok(4, DataCompare($hashref1, XMLin($_)));
>Xok(5, s/one="1"//);                   # first key encoded OK
>Xok(6, s/two="II"//);                  # second key encoded OK
>Xok(7, s/three="..."//);               # third key encoded OK
>Xok(8, /^<\w+\s+\/>/);                 # no other attributes encoded
>X
>X
>X# Now try encoding a hash with a nested array
>X
>Xmy $ref = {array => [qw(one two three)]};
>X# Expect:
>X# <opt>
>X#   <array>one</array>
>X#   <array>two</array>
>X#   <array>three</array>
>X# </opt>
>X
>X$_ = XMLout($ref);                    # Encode to $_ for convenience
>Xok(9, DataCompare($ref, XMLin($_)));
>Xok(10, s{<array>one</array>\s*
>X         <array>two</array>\s*
>X         <array>three</array>}{}sx);  # array elements encoded in correct order
>Xok(11, /^<(\w+)\s*>\s*<\/\1>\s*$/s);  # no other spurious encodings
>X
>X
>X# Now try encoding a nested hash
>X
>X$ref = { value => '555 1234',
>X         hash1 => { one => 1 },
>X         hash2 => { two => 2 } };
>X# Expect:
>X# <opt value="555 1234">
>X#   <hash1 one="1" />
>X#   <hash2 two="2" />
>X# </opt>
>X
>X$_ = XMLout($ref);
>Xok(12, DataCompare($ref, XMLin($_))); # Parses back OK
>X
>Xok(13, s{<hash1 one="1" />\s*}{}s);
>Xok(14, s{<hash2 two="2" />\s*}{}s);
>Xok(15, m{^<(\w+)\s+value="555 1234"\s*>\s*</\1>\s*$}s);
>X
>X
>X# Now try encoding an anonymous array
>X
>X$ref = [ qw(1 two III) ];
>X# Expect:
>X# <opt>
>X#   <anon>1</anon>
>X#   <anon>two</anon>
>X#   <anon>III</anon>
>X# </opt>
>X
>X$_ = XMLout($ref);
>Xok(16, DataCompare($ref, XMLin($_))); # Parses back OK
>X
>Xok(17, s{<anon>1</anon>\s*}{}s);
>Xok(18, s{<anon>two</anon>\s*}{}s);
>Xok(19, s{<anon>III</anon>\s*}{}s);
>Xok(20, m{^<(\w+)\s*>\s*</\1>\s*$}s);
>X
>X
>X# Now try encoding a nested anonymous array
>X
>X$ref = [ [ qw(1.1 1.2) ], [ qw(2.1 2.2) ] ];
>X# Expect:
>X# <opt>
>X#   <anon>
>X#     <anon>1.1</anon>
>X#     <anon>1.2</anon>
>X#   </anon>
>X#   <anon>
>X#     <anon>2.1</anon>
>X#     <anon>2.2</anon>
>X#   </anon>
>X# </opt>
>X
>X$_ = XMLout($ref);
>Xok(21, DataCompare($ref, XMLin($_))); # Parses back OK
>X
>Xok(22, s{<anon>1\.1</anon>\s*}{row}s);
>Xok(23, s{<anon>1\.2</anon>\s*}{ one}s);
>Xok(24, s{<anon>2\.1</anon>\s*}{row}s);
>Xok(25, s{<anon>2\.2</anon>\s*}{ two}s);
>Xok(26, s{<anon>\s*row one\s*</anon>\s*}{}s);
>Xok(27, s{<anon>\s*row two\s*</anon>\s*}{}s);
>Xok(28, m{^<(\w+)\s*>\s*</\1>\s*$}s);
>X
>X
>X# Now try encoding a hash of hashes with key folding disabled
>X
>X$ref = { country => {
>X		      England => { capital => 'London' },
>X		      France  => { capital => 'Paris' },
>X		      Turkey  => { capital => 'Istanbul' },
>X                    }
>X       };
>X# Expect:
>X# <opt>
>X#   <country>
>X#     <England capital="London" />
>X#     <France capital="Paris" />
>X#     <Turkey capital="Istanbul" />
>X#   </country>
>X# </opt>
>X
>X$_ = XMLout($ref, keyattr => []);
>Xok(29, DataCompare($ref, XMLin($_))); # Parses back OK
>Xok(30, s{<England\s+capital="London"\s*/>\s*}{}s);
>Xok(31, s{<France\s+capital="Paris"\s*/>\s*}{}s);
>Xok(32, s{<Turkey\s+capital="Istanbul"\s*/>\s*}{}s);
>Xok(33, s{<country\s*>\s*</country>}{}s);
>Xok(34, s{^<(\w+)\s*>\s*</\1>$}{}s);
>X
>X
>X# Try encoding same again with key folding set to non-standard value
>X
>X# Expect:
>X# <opt>
>X#   <country fullname="England" capital="London" />
>X#   <country fullname="France" capital="Paris" />
>X#   <country fullname="Turkey" capital="Istanbul" />
>X# </opt>
>X
>X$_ = XMLout($ref, keyattr => ['fullname']);
>X$xml = $_;
>Xok(35, DataCompare($ref,
>X                   XMLin($_, keyattr => ['fullname']))); # Parses back OK
>Xok(36, s{\s*fullname="England"}{uk}s);
>Xok(37, s{\s*capital="London"}{uk}s);
>Xok(38, s{\s*fullname="France"}{fr}s);
>Xok(39, s{\s*capital="Paris"}{fr}s);
>Xok(40, s{\s*fullname="Turkey"}{tk}s);
>Xok(41, s{\s*capital="Istanbul"}{tk}s);
>Xok(42, s{<countryukuk\s*/>\s*}{}s);
>Xok(43, s{<countryfrfr\s*/>\s*}{}s);
>Xok(44, s{<countrytktk\s*/>\s*}{}s);
>Xok(45, s{^<(\w+)\s*>\s*</\1>$}{}s);
>X
>X# Same again but specify name as scalar rather than array
>X
>X$_ = XMLout($ref, keyattr => 'fullname');
>Xok(46, $_ eq $xml);                            # Same result as last time
>X
>X
>X# Same again but specify keyattr as hash rather than array
>X
>X$_ = XMLout($ref, keyattr => { country => 'fullname' });
>Xok(47, $_ eq $xml);                            # Same result as last time
>X
>X
>X# Same again but add leading '+'
>X
>X$_ = XMLout($ref, keyattr => { country => '+fullname' });
>Xok(48, $_ eq $xml);                            # Same result as last time
>X
>X
>X# and leading '-'
>X
>X$_ = XMLout($ref, keyattr => { country => '-fullname' });
>Xok(49, $_ eq $xml);                            # Same result as last time
>X
>X
>X# One more time but with default key folding values
>X
>X# Expect:
>X# <opt>
>X#   <country name="England" capital="London" />
>X#   <country name="France" capital="Paris" />
>X#   <country name="Turkey" capital="Istanbul" />
>X# </opt>
>X
>X$_ = XMLout($ref);
>Xok(50, DataCompare($ref, XMLin($_))); # Parses back OK
>Xok(51, s{\s*name="England"}{uk}s);
>Xok(52, s{\s*capital="London"}{uk}s);
>Xok(53, s{\s*name="France"}{fr}s);
>Xok(54, s{\s*capital="Paris"}{fr}s);
>Xok(55, s{\s*name="Turkey"}{tk}s);
>Xok(56, s{\s*capital="Istanbul"}{tk}s);
>Xok(57, s{<countryukuk\s*/>\s*}{}s);
>Xok(58, s{<countryfrfr\s*/>\s*}{}s);
>Xok(59, s{<countrytktk\s*/>\s*}{}s);
>Xok(60, s{^<(\w+)\s*>\s*</\1>$}{}s);
>X
>X
>X# Finally, confirm folding still works with only one nested hash
>X
>X# Expect:
>X# <opt>
>X#   <country name="England" capital="London" />
>X# </opt>
>X
>X$ref = { country => { England => { capital => 'London' } } };
>X$_ = XMLout($ref);
>Xok(61, DataCompare($ref, XMLin($_, forcearray => 1))); # Parses back OK
>Xok(62, s{\s*name="England"}{uk}s);
>Xok(63, s{\s*capital="London"}{uk}s);
>Xok(64, s{<countryukuk\s*/>\s*}{}s);
>X#print STDERR "\n$_\n";
>Xok(65, s{^<(\w+)\s*>\s*</\1>$}{}s);
>X
>X
>X# Check that default XML declaration works
>X#
>X# Expect:
>X# <?xml version='1' standalone='yes'?>
>X# <opt one="1" />
>X
>X$ref = { one => 1 };
>X
>X$_ = XMLout($ref, xmldecl => 1);
>Xok(66, DataCompare($ref, XMLin($_))); # Parses back OK
>Xok(67, s{^\Q<?xml version='1.0' standalone='yes'?>\E}{}s);
>Xok(68, s{<opt one="1" />}{}s);
>Xok(69, m{^\s*$}s);
>X
>X
>X# Check that custom XML declaration works
>X#
>X# Expect:
>X# <?xml version='1' encoding='ISO-8859-1'?>
>X# <opt one="1" />
>X
>X$_ = XMLout($ref, xmldecl => "<?xml version='1.0' encoding='ASCII'?>");
>Xok(70, DataCompare($ref, XMLin($_))); # Parses back OK
>Xok(71, s{^\Q<?xml version='1.0' encoding='ASCII'?>\E}{}s);
>Xok(72, s{<opt one="1" />}{}s);
>Xok(73, m{^\s*$}s);
>X
>X
>X# Check that special characters do get escaped
>X
>X$ref = { a => '<A>', b => '"B"', c => '&C&' };
>X$_ = XMLout($ref);
>Xok(74, DataCompare($ref, XMLin($_))); # Parses back OK
>Xok(75, s{a="&lt;A&gt;"}{}s);
>Xok(76, s{b="&quot;B&quot;"}{}s);
>Xok(77, s{c="&amp;C&amp;"}{}s);
>Xok(78, s{^<(\w+)\s*/>$}{}s);
>X
>X
>X# unless we turn escaping off
>X
>X$_ = XMLout($ref, noescape => 1);
>Xok(79, s{a="<A>"}{}s);
>Xok(80, s{b=""B""}{}s);
>Xok(81, s{c="&C&"}{}s);
>Xok(82, s{^<(\w+)\s*/>$}{}s);
>X
>X
>X# Try encoding a recursive data structure and confirm that it fails
>X
>X$_ = eval {
>X  my $ref = { a => '1' };
>X  $ref->{b} = $ref;
>X  XMLout($ref);
>X};
>Xok(83, !defined($_));
>Xok(84, $@ =~ /recursive data structures not supported/);
>X
>X
>X# Try encoding a blessed reference and confirm that it fails
>X
>X$_ = eval { my $ref = new IO::File; XMLout($ref) };
>Xok(85, !defined($_));
>Xok(86, $@ =~ /Can't encode a value of type: /);
>X
>X
>X# Repeat some of the above tests with named root element
>X
>X# Try encoding a scalar value
>X
>X$xml = XMLout("scalar", rootname => 'TOM');
>Xok(87, defined($xml));                 # and it returned an XML string
>Xok(88, XMLin($xml), 'scalar');         # which parses back OK
>X                                       # and contains the expected data
>Xok(89, $xml =~ /^\s*<TOM>scalar<\/TOM>\s*$/si);
>X
>X
>X# Next try encoding a hash
>X
>X# Expect:
>X# <DICK one="1" two="II" three="..." />
>X
>X$_ = XMLout($hashref1, rootname => 'DICK');
>X                                      # Confirm it parses back OK
>Xok(90, DataCompare($hashref1, XMLin($_)));
>Xok(91, s/one="1"//);                  # first key encoded OK
>Xok(92, s/two="II"//);                 # second key encoded OK
>Xok(93, s/three="..."//);              # third key encoded OK
>Xok(94, /^<DICK\s+\/>/);               # only expected root element left
>X
>X
>X# Now try encoding a hash with a nested array
>X
>X$ref = {array => [qw(one two three)]};
>X# Expect:
>X# <LARRY>
>X#   <array>one</array>
>X#   <array>two</array>
>X#   <array>three</array>
>X# </LARRY>
>X
>X$_ = XMLout($ref, rootname => 'LARRY'); # Encode to $_ for convenience
>Xok(95, DataCompare($ref, XMLin($_)));
>Xok(96, s{<array>one</array>\s*
>X         <array>two</array>\s*
>X         <array>three</array>}{}sx);    # array encoded in correct order
>Xok(97, /^<(LARRY)\s*>\s*<\/\1>\s*$/s);  # only expected root element left
>X
>X
>X# Now try encoding a nested hash
>X
>X$ref = { value => '555 1234',
>X         hash1 => { one => 1 },
>X         hash2 => { two => 2 } };
>X# Expect:
>X# <CURLY value="555 1234">
>X#   <hash1 one="1" />
>X#   <hash2 two="2" />
>X# </CURLY>
>X
>X$_ = XMLout($ref, rootname => 'CURLY');
>Xok(98, DataCompare($ref, XMLin($_))); # Parses back OK
>X
>Xok(99, s{<hash1 one="1" />\s*}{}s);
>Xok(100, s{<hash2 two="2" />\s*}{}s);
>Xok(101, m{^<(CURLY)\s+value="555 1234"\s*>\s*</\1>\s*$}s);
>X
>X
>X# Now try encoding an anonymous array
>X
>X$ref = [ qw(1 two III) ];
>X# Expect:
>X# <MOE>
>X#   <anon>1</anon>
>X#   <anon>two</anon>
>X#   <anon>III</anon>
>X# </MOE>
>X
>X$_ = XMLout($ref, rootname => 'MOE');
>Xok(102, DataCompare($ref, XMLin($_))); # Parses back OK
>X
>Xok(103, s{<anon>1</anon>\s*}{}s);
>Xok(104, s{<anon>two</anon>\s*}{}s);
>Xok(105, s{<anon>III</anon>\s*}{}s);
>Xok(106, m{^<(MOE)\s*>\s*</\1>\s*$}s);
>X
>X
>X# Test again, this time with no root element
>X
>X# Try encoding a scalar value
>X
>Xok(107, XMLout("scalar", rootname => '')    =~ /scalar\s+/s);
>Xok(108, XMLout("scalar", rootname => undef) =~ /scalar\s+/s);
>X
>X
>X# Next try encoding a hash
>X
>X# Expect:
>X#   <one>1</one>
>X#   <two>II</two>
>X#   <three>...</three>
>X
>X$_ = XMLout($hashref1, rootname => '');
>X                                      # Confirm it parses back OK
>Xok(109, DataCompare($hashref1, XMLin("<opt>$_</opt>")));
>Xok(110, s/<one>1<\/one>//);            # first key encoded OK
>Xok(111, s/<two>II<\/two>//);           # second key encoded OK
>Xok(112, s/<three>...<\/three>//);      # third key encoded OK
>Xok(113, /^\s*$/);                      # nothing else left
>X
>X
>X# Now try encoding a nested hash
>X
>X$ref = { value => '555 1234',
>X         hash1 => { one => 1 },
>X         hash2 => { two => 2 } };
>X# Expect:
>X#   <value>555 1234</value>
>X#   <hash1 one="1" />
>X#   <hash2 two="2" />
>X
>X$_ = XMLout($ref, rootname => '');
>Xok(114, DataCompare($ref, XMLin("<opt>$_</opt>"))); # Parses back OK
>Xok(115, s{<value>555 1234<\/value>\s*}{}s);
>Xok(116, s{<hash1 one="1" />\s*}{}s);
>Xok(117, s{<hash2 two="2" />\s*}{}s);
>Xok(118, m{^\s*$}s);
>X
>X
>X# Now try encoding an anonymous array
>X
>X$ref = [ qw(1 two III) ];
>X# Expect:
>X#   <anon>1</anon>
>X#   <anon>two</anon>
>X#   <anon>III</anon>
>X
>X$_ = XMLout($ref, rootname => '');
>Xok(119, DataCompare($ref, XMLin("<opt>$_</opt>"))); # Parses back OK
>X
>Xok(120, s{<anon>1</anon>\s*}{}s);
>Xok(121, s{<anon>two</anon>\s*}{}s);
>Xok(122, s{<anon>III</anon>\s*}{}s);
>Xok(123, m{^\s*$}s);
>X
>X
>X# Test option error handling
>X
>X$_ = eval { XMLout($hashref1, searchpath => []) }; # only valid for XMLin()
>Xok(124, !defined($_));
>Xok(125, $@ =~ /Unrecognised option:/);
>X
>X$_ = eval { XMLout($hashref1, 'bogus') };
>Xok(126, !defined($_));
>Xok(127, $@ =~ /Options must be name=>value pairs .odd number supplied./);
>X
>X
>X# Test output to file
>X
>Xmy $TestFile = 'testoutput.xml';
>Xunlink($TestFile);
>Xok(128, !-e $TestFile);
>X
>X$xml = XMLout($hashref1);
>XXMLout($hashref1, outputfile => $TestFile);
>Xok(129, -e $TestFile);
>Xok(130, ReadFile($TestFile) eq $xml);
>Xunlink($TestFile);
>X
>X
>X# Test output to an IO handle
>X
>Xok(131, !-e $TestFile);
>Xmy $fh = new IO::File;
>X$fh->open(">$TestFile") || die "$!";
>XXMLout($hashref1, outputfile => $TestFile);
>X$fh->close();
>Xok(132, -e $TestFile);
>Xok(133, ReadFile($TestFile) eq $xml);
>Xunlink($TestFile);
>X
>X# After all that, confirm that the original hashref we supplied has not
>X# been corrupted.
>X
>Xok(134, DataCompare($hashref1, $hashref2));
>X
>X
>X# Confirm that hash keys with leading '-' are skipped
>X
>X$ref = {
>X  'a'  => 'one',
>X  '-b' => 'two',
>X  '-c' => {
>X	    'one' => 1,
>X	    'two' => 2
>X          }
>X};
>X
>X$_ = XMLout($ref, rootname => 'opt');
>Xok(135, m{^\s*<opt\s+a="one"\s*/>\s*$}s);
>X
>X
>X# Try a more complex unfolding with key attributes named in a hash
>X
>X$ref = {
>X  'car' => {
>X    'LW1804' => {
>X      'option' => {
>X        '9926543-1167' => { 'key' => 1, 'desc' => 'Steering Wheel' }
>X      },
>X      'id' => 2,
>X      'make' => 'GM'
>X    },
>X    'SH6673' => {
>X      'option' => {
>X        '6389733317-12' => { 'key' => 2, 'desc' => 'Electric Windows' },
>X        '3735498158-01' => { 'key' => 3, 'desc' => 'Leather Seats' },
>X        '5776155953-25' => { 'key' => 4, 'desc' => 'Sun Roof' },
>X      },
>X      'id' => 1,
>X      'make' => 'Ford'
>X    }
>X  }
>X};
>X
>X# Expect:
>X# <opt>
>X#   <car license="LW1804" id="2" make="GM">
>X#     <option key="1" pn="9926543-1167" desc="Steering Wheel" />
>X#   </car>
>X#   <car license="SH6673" id="1" make="Ford">
>X#     <option key="2" pn="6389733317-12" desc="Electric Windows" />
>X#     <option key="3" pn="3735498158-01" desc="Leather Seats" />
>X#     <option key="4" pn="5776155953-25" desc="Sun Roof" />
>X#   </car>
>X# </opt>
>X
>X$_ = XMLout($ref, keyattr => { 'car' => 'license', 'option' => 'pn' });
>Xok(136, DataCompare($ref,                                      # Parses back OK 
>X      XMLin($_, forcearray => 1,
>X	    keyattr => { 'car' => 'license', 'option' => 'pn' })));
>Xok(137, s{\s*make="GM"}{gm}s);
>Xok(138, s{\s*id="2"}{gm}s);
>Xok(139, s{\s*license="LW1804"}{gm}s);
>Xok(140, s{\s*desc="Steering Wheel"}{opt}s);
>Xok(141, s{\s*pn="9926543-1167"}{opt}s);
>Xok(142, s{\s*key="1"}{opt}s);
>Xok(143, s{\s*<cargmgmgm>\s*<optionoptoptopt\s*/>\s*</car>}{CAR}s);
>Xok(144, s{\s*make="Ford"}{ford}s);
>Xok(145, s{\s*id="1"}{ford}s);
>Xok(146, s{\s*license="SH6673"}{ford}s);
>Xok(147, s{\s*desc="Electric Windows"}{1}s);
>Xok(148, s{\s*pn="6389733317-12"}{1}s);
>Xok(149, s{\s*key="2"}{1}s);
>Xok(150, s{\s*<option111}{<option}s);
>Xok(151, s{\s*desc="Leather Seats"}{2}s);
>Xok(152, s{\s*pn="3735498158-01"}{2}s);
>Xok(153, s{\s*key="3"}{2}s);
>Xok(154, s{\s*<option222}{<option}s);
>Xok(155, s{\s*desc="Sun Roof"}{3}s);
>Xok(156, s{\s*pn="5776155953-25"}{3}s);
>Xok(157, s{\s*key="4"}{3}s);
>Xok(158, s{\s*<option333}{<option}s);
>Xok(159, s{\s*<carfordfordford>\s*(<option\s*/>\s*){3}</car>}{CAR}s);
>Xok(160, s{^<(\w+)\s*>\s*CAR\s*CAR\s*</\1>$}{}s);
>X
>X
>X# Check that empty hashes translate to empty tags
>X
>X$ref = {
>X  'one' => {
>X    'attr1' => 'avalue1',
>X    'nest1' => [ 'nvalue1' ],
>X    'nest2' => {}
>X  },
>X  two => {}
>X};
>X
>X$_ = XMLout($ref);
>X
>Xok(161, s{<nest2\s*></nest2\s*>\s*}{<NNN>});
>Xok(162, s{<nest1\s*>nvalue1</nest1\s*>\s*}{<NNN>});
>Xok(163, s{<one\s*attr1\s*=\s*"avalue1">\s*}{<one>});
>Xok(164, s{<one\s*>\s*<NNN>\s*<NNN>\s*</one>}{<nnn>});
>Xok(165, s{<two\s*></two\s*>\s*}{<nnn>});
>Xok(166, m{^\s*<(\w+)\s*>\s*<nnn>\s*<nnn>\s*</\1\s*>\s*$});
>X
>X
>X# Check undefined values generate warnings 
>X
>X{
>Xmy $warn = '';
>Xlocal $SIG{__WARN__} = sub { $warn = $_[0] };
>X$_ = eval {
>X  $ref = { 'tag' => undef };
>X  XMLout($ref);
>X};
>Xok(167, $warn =~ /Use of uninitialized value/);
>X}
>X
>X
>X# Unless undef is mapped to empty tags
>X
>X$ref = { 'tag' => undef };
>X$_ = XMLout($ref, suppressempty => undef);
>Xok(168, m{^\s*<(\w*)\s*>\s*<tag\s*></tag\s*>\s*</\1\s*>\s*$}s);
>X
>X
>X# Test the keeproot option
>X
>X$ref = {
>X  'seq' => {
>X    'name' => 'alpha',
>X    'alpha' => [ 1, 2, 3 ]
>X  }
>X};
>X
>Xmy $xml1 = XMLout($ref, rootname => 'sequence');
>Xmy $xml2 = XMLout({ 'sequence' => $ref }, keeproot => 1);
>X
>Xok(169, DataCompare($xml1, $xml2));
>X
>X
>X# Test that items with text content are output correctly
>X# Expect: <opt one="1">text</opt>
>X
>X$ref = { 'one' => 1, 'content' => 'text' };
>X
>X$_ = XMLout($ref);
>X
>Xok(170, m{^\s*<opt\s+one="1">text</opt>\s*$}s);
>X
>X
>X# Even if we change the default value for the 'contentkey' option
>X
>X$ref = { 'one' => 1, 'text_content' => 'text' };
>X
>X$_ = XMLout($ref, contentkey => 'text_content');
>X
>Xok(171, m{^\s*<opt\s+one="1">text</opt>\s*$}s);
>X
>X
>X# Check 'noattr' option
>X
>X$ref = {
>X  attr1  => 'value1',
>X  attr2  => 'value2',
>X  nest   => [ qw(one two three) ]
>X};
>X
>X# Expect:
>X#
>X# <opt>
>X#   <attr1>value1</attr1>
>X#   <attr2>value2</attr2>
>X#   <nest>one</nest>
>X#   <nest>two</nest>
>X#   <nest>three</nest>
>X# </opt>
>X#
>X
>X$_ = XMLout($ref, noattr => 1);
>X
>Xok(172, !m{=}s);                               # No '=' signs anywhere
>Xok(173, DataCompare($ref, XMLin($_)));         # Parses back ok
>Xok(174, s{\s*<(attr1)>value1</\1>\s*}{NEST}s); # Output meets expectations
>Xok(175, s{\s*<(attr2)>value2</\1>\s*}{NEST}s);
>Xok(176, s{\s*<(nest)>one</\1>\s*<\1>two</\1>\s*<\1>three</\1>}{NEST}s);
>Xok(177, s{^<(\w+)\s*>(NEST\s*){3}</\1>$}{}s);
>X
>X
>X# Check noattr doesn't screw up keyattr
>X
>X$ref = { number => {
>X  'twenty one' => { dec => 21, hex => '0x15' },
>X  'thirty two' => { dec => 32, hex => '0x20' }
>X  }
>X};
>X
>X# Expect:
>X#
>X# <opt>
>X#   <number>
>X#     <dec>21</dec>
>X#     <word>twenty one</word>
>X#     <hex>0x15</hex>
>X#   </number>
>X#   <number>
>X#     <dec>32</dec>
>X#     <word>thirty two</word>
>X#     <hex>0x20</hex>
>X#   </number>
>X# </opt>
>X#
>X
>X$_ = XMLout($ref, noattr => 1, keyattr => [ 'word' ]);
>X
>Xok(178, !m{=}s);                               # No '=' signs anywhere
>X                                               # Parses back ok
>Xok(179, DataCompare($ref, XMLin($_, keyattr => [ 'word' ])));
>Xok(180, s{\s*<(dec)>21</\1>\s*}{21}s);
>Xok(181, s{\s*<(hex)>0x15</\1>\s*}{21}s);
>Xok(182, s{\s*<(word)>twenty one</\1>\s*}{21}s);
>Xok(183, s{\s*<(number)>212121</\1>\s*}{NUM}s);
>Xok(184, s{\s*<(dec)>32</\1>\s*}{32}s);
>Xok(185, s{\s*<(hex)>0x20</\1>\s*}{32}s);
>Xok(186, s{\s*<(word)>thirty two</\1>\s*}{32}s);
>Xok(187, s{\s*<(number)>323232</\1>\s*}{NUM}s);
>Xok(188, s{^<(\w+)\s*>NUMNUM</\1>$}{}s);
>X
>X
>X# 'Stress test' with a data structure that maps to several thousand elements.
>X# Unfold elements with XMLout() and fold them up again with XMLin()
>X
>Xmy $opt1 =  {};
>Xforeach my $i (1..40) {
>X  foreach my $j (1..$i) {
>X    $opt1->{TypeA}->{$i}->{Record}->{$j} = { Hex => sprintf("0x%04X", $j) };
>X    $opt1->{TypeB}->{$i}->{Record}->{$j} = { Oct => sprintf("%04o", $j) };
>X  }
>X}
>X
>X$xml = XMLout($opt1, keyattr => { TypeA => 'alpha', TypeB => 'beta', Record => 'id' });
>X
>Xmy $opt2 = XMLin($xml, keyattr => { TypeA => 'alpha', TypeB => 'beta', Record => 'id' }, forcearray => 1);
>X
>Xok(189, DataCompare($opt1, $opt2));
>X
>Xexit(0);
>X
>X
>X
>X
>X
>X
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/2_XMLout.t
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/3_Storable.t
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/3_Storable.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/3_Storable.t'
>Xuse strict;
>X
>Xuse File::Spec;
>X
>Xeval { require Storable; };
>Xunless($INC{'Storable.pm'}) {
>X  print STDERR "no Storable.pm...";
>X  print "1..0\n";
>X  exit 0;
>X}
>X
>X# Initialise filenames and check they're there
>X
>Xmy $SrcFile   = File::Spec->catfile('t', 'desertnet.src');
>Xmy $XMLFile   = File::Spec->catfile('t', 'desertnet.xml');
>Xmy $CacheFile = File::Spec->catfile('t', 'desertnet.stor');
>X
>Xunless(-e $SrcFile) {
>X  print STDERR "test data missing...";
>X  print "1..0\n";
>X  exit 0;
>X}
>X
>Xprint "1..19\n";
>X
>Xmy $t = 1;
>X
>X##############################################################################
>X#                   S U P P O R T   R O U T I N E S
>X##############################################################################
>X
>X##############################################################################
>X# Print out 'n ok' or 'n not ok' as expected by test harness.
>X# First arg is test number (n).  If only one following arg, it is interpreted
>X# as true/false value.  If two args, equality = true.
>X#
>X
>Xsub ok {
>X  my($n, $x, $y) = @_;
>X  die "Sequence error got $n expected $t" if($n != $t);
>X  $x = 0 if(@_ > 2  and  $x ne $y);
>X  print(($x ? '' : 'not '), 'ok ', $t++, "\n");
>X}
>X
>X
>X##############################################################################
>X# Take two scalar values (may be references) and compare them (recursively
>X# if necessary) returning 1 if same, 0 if different.
>X#
>X
>Xsub DataCompare {
>X  my($x, $y) = @_;
>X
>X  my($i);
>X
>X  if(!ref($x)) {
>X    return(1) if($x eq $y);
>X    print STDERR "$t:DataCompare: $x != $y\n";
>X    return(0);
>X  }
>X
>X  if(ref($x) eq 'ARRAY') {
>X    unless(ref($y) eq 'ARRAY') {
>X      print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(@$x) != scalar(@$y)) {
>X      print STDERR "$t:DataCompare: expected ", scalar(@$x),
>X                   " element(s), got: ", scalar(@$y), "\n";
>X      return(0);
>X    }
>X    for($i = 0; $i < scalar(@$x); $i++) {
>X      DataCompare($x->[$i], $y->[$i]) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  if(ref($x) eq 'HASH') {
>X    unless(ref($y) eq 'HASH') {
>X      print STDERR "$t:DataCompare: expected hashref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(keys(%$x)) != scalar(keys(%$y))) {
>X      print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
>X                   " key(s) (", join(', ', keys(%$x)),
>X		   "), got: ",  scalar(keys(%$y)), " (", join(', ', keys(%$y)),
>X		   ")\n";
>X      return(0);
>X    }
>X    foreach $i (keys(%$x)) {
>X      unless(exists($y->{$i})) {
>X	print STDERR "$t:DataCompare: missing hash key - {$i}\n";
>X	return(0);
>X      }
>X      DataCompare($x->{$i}, $y->{$i}) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  print STDERR "Don't know how to compare: " . ref($x) . "\n";
>X  return(0);
>X}
>X
>X
>X##############################################################################
>X# Copy a file
>X#
>X
>Xsub CopyFile {
>X  my($Src, $Dst) = @_;
>X  
>X  open(IN, $Src) || return(undef);
>X  local($/) = undef;
>X  my $Data = <IN>;
>X  close(IN);
>X
>X  open(OUT, ">$Dst") || return(undef);
>X  print OUT $Data;
>X  close(OUT);
>X
>X  return(1);
>X}
>X
>X
>X##############################################################################
>X# Wait until the current time is greater than the supplied value
>X#
>X
>Xsub PassTime {
>X  my($Target) = @_;
>X
>X  while(time <= $Target) {
>X    sleep 1;
>X  }
>X}
>X
>X
>X##############################################################################
>X#                      T E S T   R O U T I N E S
>X##############################################################################
>X
>Xuse XML::SAX::Simple;
>X
>X# Initialise test data
>X
>Xmy $Expected  = {
>X          'server' => {
>X                        'sahara' => {
>X                                      'osversion' => '2.6',
>X                                      'osname' => 'solaris',
>X                                      'address' => [
>X                                                     '10.0.0.101',
>X                                                     '10.0.1.101'
>X                                                   ]
>X                                    },
>X                        'gobi' => {
>X                                    'osversion' => '6.5',
>X                                    'osname' => 'irix',
>X                                    'address' => '10.0.0.102'
>X                                  },
>X                        'kalahari' => {
>X                                        'osversion' => '2.0.34',
>X                                        'osname' => 'linux',
>X                                        'address' => [
>X                                                       '10.0.0.103',
>X                                                       '10.0.1.103'
>X                                                     ]
>X                                      }
>X                      }
>X        };
>X
>Xok(1, CopyFile($SrcFile, $XMLFile));  # Start with known source file
>Xunlink($CacheFile);                   # Ensure there are ...
>Xok(2, ! -e $CacheFile);               # ... no cache files lying around
>X
>Xmy $opt = XMLin($XMLFile);
>Xok(3, DataCompare($opt, $Expected));  # Got what we expected
>Xok(4, ! -e $CacheFile);               # And no cache file was created
>XPassTime(time());                     # Ensure cache file will be newer
>X
>X$opt = XMLin($XMLFile, cache => 'storable');
>Xok(5, DataCompare($opt, $Expected));  # Got what we expected again
>Xok(6, -e $CacheFile);                 # But this time a cache file was created
>Xmy $t0 = (stat($CacheFile))[9];       # Remember cache timestamp
>XPassTime($t0);
>X
>X$opt = XMLin($XMLFile, cache => 'storable');
>Xok(7, DataCompare($opt, $Expected));  # Got what we expected from the cache
>Xmy $t1 = (stat($CacheFile))[9];       # Check cache timestamp
>Xok(8, $t0, $t1);                      # has not changed
>X
>XPassTime(time());
>X$t0 = time();
>Xopen(FILE, ">>$XMLFile");             # Touch the XML file
>Xprint FILE "\n";
>Xclose(FILE);
>X$opt = XMLin($XMLFile, cache => 'storable');
>Xok(9, DataCompare($opt, $Expected));  # Got what we expected
>Xmy $t2 = (stat($CacheFile))[9];       # Check cache timestamp
>Xok(10, $t1 != $t2);                   # has changed
>X
>Xunlink($XMLFile);
>Xok(11, ! -e $XMLFile);                # Original XML file is gone
>Xopen(FILE, ">$XMLFile");              # Re-create it (empty)
>Xclose(FILE);
>Xutime($t1, $t1, $XMLFile);            # but wind back the clock
>X$t0 = (stat($XMLFile))[9];            # Skip these tests if that didn't work
>Xif($t0 == $t1) {
>X  $opt = XMLin($XMLFile, cache => 'storable');
>X  ok(12, DataCompare($opt, $Expected)); # Got what we expected from the cache
>X  ok(13, ! -s $XMLFile);                # even though the XML file is empty
>X}
>Xelse {
>X  print STDERR "no utime - skipping test 12...";
>X  ok(12, 1);
>X  ok(13, 1);
>X}
>X
>XPassTime($t2);
>Xopen(FILE, ">$XMLFile");              # Write some new data to the XML file
>Xprint FILE qq(<opt one="1" two="2"></opt>\n);
>Xclose(FILE);
>X
>X$opt = XMLin($XMLFile);            # Parse with no caching
>Xok(14, DataCompare($opt, { one => 1, two => 2})); # Got what we expected
>X$t0 = (stat($CacheFile))[9];          # And timestamp on cache file
>Xmy $s0 = (-s $CacheFile);
>Xok(15, $t0 == $t2);                   # has not changed
>X
>X                                      # Parse again with caching enabled
>X$opt = XMLin($XMLFile, cache => 'storable');
>X                                      # Came through the cache
>Xok(16, DataCompare($opt, { one => 1, two => 2}));
>X$t1 = (stat($CacheFile))[9];          # which has been updated
>Xmy $s1 = (-s $CacheFile);
>Xok(17, ($t0 != $t1) || ($s0 != $s1)); # Content changes but date may not on Win32
>X
>Xok(18, CopyFile($SrcFile, $XMLFile)); # Put back the original file
>XPassTime($t1);
>X$opt = XMLin($XMLFile, cache => 'storable');
>Xok(19, DataCompare($opt, $Expected)); # Got what we expected
>X
>X# Clean up and go
>X
>Xunlink($CacheFile);
>Xunlink($XMLFile);
>Xexit(0);
>X
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/3_Storable.t
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/4_MemShare.t
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/4_MemShare.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/4_MemShare.t'
>Xuse strict;
>X
>Xuse File::Spec;
>X
>X# Initialise filenames and check they're there
>X
>Xmy $SrcFile   = File::Spec->catfile('t', 'desertnet.src');
>Xmy $XMLFile   = File::Spec->catfile('t', 'desertnet.xml');
>X
>Xunless(-e $SrcFile) {
>X  print STDERR "test data missing...";
>X  print "1..0\n";
>X  exit 0;
>X}
>X
>Xprint "1..7\n";
>X
>Xmy $t = 1;
>X
>X##############################################################################
>X#                   S U P P O R T   R O U T I N E S
>X##############################################################################
>X
>X##############################################################################
>X# Print out 'n ok' or 'n not ok' as expected by test harness.
>X# First arg is test number (n).  If only one following arg, it is interpreted
>X# as true/false value.  If two args, equality = true.
>X#
>X
>Xsub ok {
>X  my($n, $x, $y) = @_;
>X  die "Sequence error got $n expected $t" if($n != $t);
>X  $x = 0 if(@_ > 2  and  $x ne $y);
>X  print(($x ? '' : 'not '), 'ok ', $t++, "\n");
>X}
>X
>X
>X##############################################################################
>X# Take two scalar values (may be references) and compare them (recursively
>X# if necessary) returning 1 if same, 0 if different.
>X#
>X
>Xsub DataCompare {
>X  my($x, $y) = @_;
>X
>X  my($i);
>X
>X  if(!ref($x)) {
>X    return(1) if($x eq $y);
>X    print STDERR "$t:DataCompare: $x != $y\n";
>X    return(0);
>X  }
>X
>X  if(ref($x) eq 'ARRAY') {
>X    unless(ref($y) eq 'ARRAY') {
>X      print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(@$x) != scalar(@$y)) {
>X      print STDERR "$t:DataCompare: expected ", scalar(@$x),
>X                   " element(s), got: ", scalar(@$y), "\n";
>X      return(0);
>X    }
>X    for($i = 0; $i < scalar(@$x); $i++) {
>X      DataCompare($x->[$i], $y->[$i]) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  if(ref($x) eq 'HASH') {
>X    unless(ref($y) eq 'HASH') {
>X      print STDERR "$t:DataCompare: expected hashref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(keys(%$x)) != scalar(keys(%$y))) {
>X      print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
>X                   " key(s) (", join(', ', keys(%$x)),
>X		   "), got: ",  scalar(keys(%$y)), " (", join(', ', keys(%$y)),
>X		   ")\n";
>X      return(0);
>X    }
>X    foreach $i (keys(%$x)) {
>X      unless(exists($y->{$i})) {
>X	print STDERR "$t:DataCompare: missing hash key - {$i}\n";
>X	return(0);
>X      }
>X      DataCompare($x->{$i}, $y->{$i}) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  print STDERR "Don't know how to compare: " . ref($x) . "\n";
>X  return(0);
>X}
>X
>X
>X##############################################################################
>X# Copy a file
>X#
>X
>Xsub CopyFile {
>X  my($Src, $Dst) = @_;
>X  
>X  open(IN, $Src) || return(undef);
>X  local($/) = undef;
>X  my $Data = <IN>;
>X  close(IN);
>X
>X  open(OUT, ">$Dst") || return(undef);
>X  print OUT $Data;
>X  close(OUT);
>X
>X  return(1);
>X}
>X
>X
>X##############################################################################
>X# Wait until the current time is greater than the supplied value
>X#
>X
>Xsub PassTime {
>X  my($Target) = @_;
>X
>X  while(time <= $Target) {
>X    sleep 1;
>X  }
>X}
>X
>X
>X##############################################################################
>X#                      T E S T   R O U T I N E S
>X##############################################################################
>X
>Xuse XML::SAX::Simple;
>X
>X# Initialise test data
>X
>Xmy $Expected  = {
>X          'server' => {
>X                        'sahara' => {
>X                                      'osversion' => '2.6',
>X                                      'osname' => 'solaris',
>X                                      'address' => [
>X                                                     '10.0.0.101',
>X                                                     '10.0.1.101'
>X                                                   ]
>X                                    },
>X                        'gobi' => {
>X                                    'osversion' => '6.5',
>X                                    'osname' => 'irix',
>X                                    'address' => '10.0.0.102'
>X                                  },
>X                        'kalahari' => {
>X                                        'osversion' => '2.0.34',
>X                                        'osname' => 'linux',
>X                                        'address' => [
>X                                                       '10.0.0.103',
>X                                                       '10.0.1.103'
>X                                                     ]
>X                                      }
>X                      }
>X        };
>X
>Xok(1, CopyFile($SrcFile, $XMLFile));  # Start with known source file
>Xmy $t0 = (stat($XMLFile))[9];         # Remember its timestamp
>X                                      
>X				      # Parse it with caching enabled
>Xmy $opt = XMLin($XMLFile, cache => 'memshare');
>Xok(2, DataCompare($opt, $Expected));  # Got what we expected
>X
>Xunlink($XMLFile);
>Xok(3, ! -e $XMLFile);                 # Original XML file is gone
>Xopen(FILE, ">$XMLFile");              # Re-create it (empty)
>Xclose(FILE);
>Xmy $t1 = $t0 - 1;
>Xeval { utime($t1, $t1, $XMLFile); };  # but wind back the clock
>Xmy $t2 = (stat($XMLFile))[9];         # Skip these tests if that didn't work
>Xif($t2 >= $t0) {
>X  print STDERR "no utime - skipping test 4...";
>X  ok(4, 1);
>X  ok(5, 1);
>X}
>Xelse {
>X  $opt = XMLin($XMLFile, cache => 'memshare');
>X  ok(4, DataCompare($opt, $Expected)); # Got what we expected from the cache
>X  ok(5, ! -s $XMLFile);                # even though the XML file is empty
>X}
>XPassTime(time());                      # Ensure timestamp changes
>X
>X
>Xopen(FILE, ">$XMLFile");               # Write some new data to the XML file
>Xprint FILE qq(<opt one="1" two="2"></opt>\n);
>Xclose(FILE);
>XPassTime(time());                      # Ensure current time later than file time
>X
>X                                       # Parse again with caching enabled
>X$opt = XMLin($XMLFile, cache => 'memshare');
>X                                       # Came through the cache
>Xok(6, DataCompare($opt, { one => 1, two => 2}));
>X
>X$opt->{three} = 3;                     # Alter the returned structure
>X                                       # Retrieve again from the cache
>Xmy $opt2 = XMLin($XMLFile, cache => 'memshare');
>X
>Xok(7, $opt2->{three}, 3);              # Confirm cached version is altered too
>X
>X
>Xexit(0);
>X
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/4_MemShare.t
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/5_MemCopy.t
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/5_MemCopy.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/5_MemCopy.t'
>Xuse strict;
>X
>Xuse File::Spec;
>X
>Xeval { require Storable; };
>Xunless($INC{'Storable.pm'}) {
>X  print STDERR "no Storable.pm...";
>X  print "1..0\n";
>X  exit;
>X}
>X
>X# Initialise filenames and check they're there
>X
>Xmy $SrcFile   = File::Spec->catfile('t', 'desertnet.src');
>Xmy $XMLFile   = File::Spec->catfile('t', 'desertnet.xml');
>X
>Xunless(-e $SrcFile) {
>X  print STDERR "test data missing...";
>X  print "1..0\n";
>X  exit 0;
>X}
>X
>X
>Xprint "1..7\n";
>X
>Xmy $t = 1;
>X
>X##############################################################################
>X#                   S U P P O R T   R O U T I N E S
>X##############################################################################
>X
>X##############################################################################
>X# Print out 'n ok' or 'n not ok' as expected by test harness.
>X# First arg is test number (n).  If only one following arg, it is interpreted
>X# as true/false value.  If two args, equality = true.
>X#
>X
>Xsub ok {
>X  my($n, $x, $y) = @_;
>X  die "Sequence error got $n expected $t" if($n != $t);
>X  $x = 0 if(@_ > 2  and  $x ne $y);
>X  print(($x ? '' : 'not '), 'ok ', $t++, "\n");
>X}
>X
>X
>X##############################################################################
>X# Take two scalar values (may be references) and compare them (recursively
>X# if necessary) returning 1 if same, 0 if different.
>X#
>X
>Xsub DataCompare {
>X  my($x, $y) = @_;
>X
>X  my($i);
>X
>X  if(!ref($x)) {
>X    return(1) if($x eq $y);
>X    print STDERR "$t:DataCompare: $x != $y\n";
>X    return(0);
>X  }
>X
>X  if(ref($x) eq 'ARRAY') {
>X    unless(ref($y) eq 'ARRAY') {
>X      print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(@$x) != scalar(@$y)) {
>X      print STDERR "$t:DataCompare: expected ", scalar(@$x),
>X                   " element(s), got: ", scalar(@$y), "\n";
>X      return(0);
>X    }
>X    for($i = 0; $i < scalar(@$x); $i++) {
>X      DataCompare($x->[$i], $y->[$i]) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  if(ref($x) eq 'HASH') {
>X    unless(ref($y) eq 'HASH') {
>X      print STDERR "$t:DataCompare: expected hashref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(keys(%$x)) != scalar(keys(%$y))) {
>X      print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
>X                   " key(s) (", join(', ', keys(%$x)),
>X		   "), got: ",  scalar(keys(%$y)), " (", join(', ', keys(%$y)),
>X		   ")\n";
>X      return(0);
>X    }
>X    foreach $i (keys(%$x)) {
>X      unless(exists($y->{$i})) {
>X	print STDERR "$t:DataCompare: missing hash key - {$i}\n";
>X	return(0);
>X      }
>X      DataCompare($x->{$i}, $y->{$i}) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  print STDERR "Don't know how to compare: " . ref($x) . "\n";
>X  return(0);
>X}
>X
>X
>X##############################################################################
>X# Copy a file
>X#
>X
>Xsub CopyFile {
>X  my($Src, $Dst) = @_;
>X  
>X  open(IN, $Src) || return(undef);
>X  local($/) = undef;
>X  my $Data = <IN>;
>X  close(IN);
>X
>X  open(OUT, ">$Dst") || return(undef);
>X  print OUT $Data;
>X  close(OUT);
>X
>X  return(1);
>X}
>X
>X
>X##############################################################################
>X# Wait until the current time is greater than the supplied value
>X#
>X
>Xsub PassTime {
>X  my($Target) = @_;
>X
>X  while(time <= $Target) {
>X    sleep 1;
>X  }
>X}
>X
>X
>X##############################################################################
>X#                      T E S T   R O U T I N E S
>X##############################################################################
>X
>Xuse XML::SAX::Simple;
>X
>X# Initialise test data
>X
>Xmy $Expected  = {
>X          'server' => {
>X                        'sahara' => {
>X                                      'osversion' => '2.6',
>X                                      'osname' => 'solaris',
>X                                      'address' => [
>X                                                     '10.0.0.101',
>X                                                     '10.0.1.101'
>X                                                   ]
>X                                    },
>X                        'gobi' => {
>X                                    'osversion' => '6.5',
>X                                    'osname' => 'irix',
>X                                    'address' => '10.0.0.102'
>X                                  },
>X                        'kalahari' => {
>X                                        'osversion' => '2.0.34',
>X                                        'osname' => 'linux',
>X                                        'address' => [
>X                                                       '10.0.0.103',
>X                                                       '10.0.1.103'
>X                                                     ]
>X                                      }
>X                      }
>X        };
>X
>Xok(1, CopyFile($SrcFile, $XMLFile));  # Start with known source file
>Xmy $t0 = (stat($XMLFile))[9];         # Remember its timestamp
>X                                      
>X				      # Parse it with caching enabled
>Xmy $opt = XMLin($XMLFile, cache => 'memcopy');
>Xok(2, DataCompare($opt, $Expected));  # Got what we expected
>X
>Xunlink($XMLFile);
>Xok(3, ! -e $XMLFile);                 # Original XML file is gone
>Xopen(FILE, ">$XMLFile");              # Re-create it (empty)
>Xclose(FILE);
>Xmy $t1 = $t0 - 1;
>Xeval { utime($t1, $t1, $XMLFile); };   # but wind back the clock
>Xmy $t2 = (stat($XMLFile))[9];         # Skip these tests if that didn't work
>Xif($t2 >= $t0) {
>X  print STDERR "no utime - skipping test 4...";
>X  ok(4, 1);
>X  ok(5, 1);
>X}
>Xelse {
>X  $opt = XMLin($XMLFile, cache => 'memcopy');
>X  ok(4, DataCompare($opt, $Expected)); # Got what we expected from the cache
>X  ok(5, ! -s $XMLFile);                # even though the XML file is empty
>X}
>X
>X
>XPassTime(time());                     # Ensure source file will be newer
>Xopen(FILE, ">$XMLFile");              # Write some new data to the XML file
>Xprint FILE qq(<opt one="1" two="2"></opt>\n);
>Xclose(FILE);
>X
>X                                      # Parse again with caching enabled
>X$opt = XMLin($XMLFile, cache => 'memcopy');
>X                                      # Came through the cache
>Xok(6, DataCompare($opt, { one => 1, two => 2}));
>X
>X$opt->{three} = 3;                    # Alter the returned structure
>X                                      # Retrieve again from the cache
>Xmy $opt2 = XMLin($XMLFile, cache => 'memcopy');
>X
>Xok(7, !defined($opt2->{three}));      # Confirm cached copy is not altered
>X
>X
>X# Clean up and go
>X
>Xunlink($XMLFile);
>Xexit(0);
>X
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/5_MemCopy.t
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/6_ObjIntf.t
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/6_ObjIntf.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/6_ObjIntf.t'
>Xuse strict;
>X
>X##############################################################################
>X# Derived version of XML::SAX::Simple that returns everything in lower case
>X##############################################################################
>X
>Xpackage XML::Simple::UC;
>X
>Xuse vars qw(@ISA);
>X@ISA = qw(XML::SAX::Simple);
>X
>Xsub build_tree {
>X  my $self = shift;
>X
>X  my $tree = $self->SUPER::build_tree(@_);
>X
>X  ($tree) = uctree($tree);
>X
>X  return($tree);
>X}
>X
>Xsub uctree {
>X  foreach my $i (0..$#_) {
>X    my $x = $_[$i];
>X    if(ref($x) eq 'ARRAY') {
>X      $_[$i] = [ uctree(@$x) ];
>X    }
>X    elsif(ref($x) eq 'HASH') {
>X      $_[$i] = { uctree(%$x) };
>X    }
>X    else {
>X      $_[$i] = uc($x);
>X    }
>X  }
>X  return(@_);
>X}
>X
>X
>X##############################################################################
>X# Derived version of XML::SAX::Simple that uses CDATA sections for escaping
>X##############################################################################
>X
>Xpackage XML::Simple::CDE;
>X
>Xuse vars qw(@ISA);
>X@ISA = qw(XML::SAX::Simple);
>X
>Xsub escape_value {
>X  my $self = shift;
>X
>X  my($data) = @_;
>X
>X  if($data =~ /[&<>"]/) {
>X    $data = '<![CDATA[' . $data . ']]>';
>X  }
>X
>X  return($data);
>X}
>X
>X
>X##############################################################################
>X# Start of the test script itself
>X##############################################################################
>X
>Xpackage main;
>X
>XBEGIN { print "1..27\n"; }
>X
>Xmy $t = 1;
>X
>X##############################################################################
>X#                   S U P P O R T   R O U T I N E S
>X##############################################################################
>X
>X##############################################################################
>X# Print out 'n ok' or 'n not ok' as expected by test harness.
>X# First arg is test number (n).  If only one following arg, it is interpreted
>X# as true/false value.  If two args, equality = true.
>X#
>X
>Xsub ok {
>X  my($n, $x, $y) = @_;
>X  die "Sequence error got $n expected $t" if($n != $t);
>X    $x = 0 if(@_ > 2  and  $x ne $y);
>X  print(($x ? '' : 'not '), 'ok ', $t++, "\n");
>X}
>X
>X##############################################################################
>X# Take two scalar values (may be references) and compare them (recursively
>X# if necessary) returning 1 if same, 0 if different.
>X#
>X
>Xsub DataCompare {
>X  my($x, $y) = @_;
>X
>X  my($i);
>X
>X  if(!ref($x)) {
>X    return(1) if($x eq $y);
>X    print STDERR "$t:DataCompare: $x != $y\n";
>X    return(0);
>X  }
>X
>X  if(ref($x) eq 'ARRAY') {
>X    unless(ref($y) eq 'ARRAY') {
>X      print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(@$x) != scalar(@$y)) {
>X      print STDERR "$t:DataCompare: expected ", scalar(@$x),
>X                   " element(s), got: ", scalar(@$y), "\n";
>X      return(0);
>X    }
>X    for($i = 0; $i < scalar(@$x); $i++) {
>X      DataCompare($x->[$i], $y->[$i]) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  if(ref($x) eq 'HASH') {
>X    unless(ref($y) eq 'HASH') {
>X      print STDERR "$t:DataCompare: expected hashref, got: $y\n";
>X      return(0);
>X    }
>X    if(scalar(keys(%$x)) != scalar(keys(%$y))) {
>X      print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
>X                   " key(s) (", join(', ', keys(%$x)),
>X		   "), got: ",  scalar(keys(%$y)), " (", join(', ', keys(%$y)),
>X		   ")\n";
>X      return(0);
>X    }
>X    foreach $i (keys(%$x)) {
>X      unless(exists($y->{$i})) {
>X	print STDERR "$t:DataCompare: missing hash key - {$i}\n";
>X	return(0);
>X      }
>X      DataCompare($x->{$i}, $y->{$i}) || return(0);
>X    }
>X    return(1);
>X  }
>X
>X  print STDERR "Don't know how to compare: " . ref($x) . "\n";
>X  return(0);
>X}
>X
>X
>X##############################################################################
>X# Start the tests
>X#
>X
>Xuse XML::SAX::Simple;
>X
>Xmy $xml = q(<cddatabase>
>X  <disc id="9362-45055-2" cddbid="960b750c">
>X    <artist>R.E.M.</artist>
>X    <album>Automatic For The People</album>
>X    <track number="1">Drive</track>
>X    <track number="2">Try Not To Breathe</track>
>X    <track number="3">The Sidewinder Sleeps Tonite</track>
>X    <track number="4">Everybody Hurts</track>
>X    <track number="5">New Orleans Instrumental No. 1</track>
>X    <track number="6">Sweetness Follows</track>
>X    <track number="7">Monty Got A Raw Deal</track>
>X    <track number="8">Ignoreland</track>
>X    <track number="9">Star Me Kitten</track>
>X    <track number="10">Man On The Moon</track>
>X    <track number="11">Nightswimming</track>
>X    <track number="12">Find The River</track>
>X  </disc>
>X</cddatabase>
>X);
>X
>Xmy %opts1 = (
>X  keyattr => { disc => 'cddbid', track => 'number' },
>X  keeproot => 1, 
>X  contentkey => 'title',
>X  forcearray => [ qw(disc album) ] 
>X);
>X
>Xmy %opts2 = (
>X  keyattr => { }
>X);
>X
>Xmy $xs1 = new XML::SAX::Simple( %opts1 );
>Xmy $xs2 = new XML::SAX::Simple( %opts2 );
>Xok(1, $xs1);                            # Object created successfully
>Xok(2, $xs2);                            # and another
>Xok(3, DataCompare(\%opts1, {            # Options values not corrupted
>X  keyattr => { disc => 'cddbid', track => 'number' },
>X  keeproot => 1, 
>X  contentkey => 'title',
>X  forcearray => [ qw(disc album) ] 
>X}));
>X
>Xmy $exp1 = {
>X  'cddatabase' => {
>X    'disc' => {
>X      '960b750c' => {
>X        'id' => '9362-45055-2',
>X        'album' => [ 'Automatic For The People' ],
>X        'artist' => 'R.E.M.',
>X        'track' => {
>X          1  => { 'title' => 'Drive' },
>X          2  => { 'title' => 'Try Not To Breathe' },
>X          3  => { 'title' => 'The Sidewinder Sleeps Tonite' },
>X          4  => { 'title' => 'Everybody Hurts' },
>X          5  => { 'title' => 'New Orleans Instrumental No. 1' },
>X          6  => { 'title' => 'Sweetness Follows' },
>X          7  => { 'title' => 'Monty Got A Raw Deal' },
>X          8  => { 'title' => 'Ignoreland' },
>X          9  => { 'title' => 'Star Me Kitten' },
>X          10 => { 'title' => 'Man On The Moon' },
>X          11 => { 'title' => 'Nightswimming' },
>X          12 => { 'title' => 'Find The River' }
>X        }
>X      }
>X    }
>X  }
>X};
>X
>Xmy $ref1 = $xs1->XMLin($xml);
>Xok(4, DataCompare($ref1, $exp1));       # Parsed to what we expected
>X
>X
>X# Try using the other object
>X
>Xmy $exp2 = {
>X  'disc' => {
>X    'album' => 'Automatic For The People',
>X    'artist' => 'R.E.M.',
>X    'cddbid' => '960b750c',
>X    'id' => '9362-45055-2',
>X    'track' => [
>X      { 'number' => 1,  'content' => 'Drive' },
>X      { 'number' => 2,  'content' => 'Try Not To Breathe' },
>X      { 'number' => 3,  'content' => 'The Sidewinder Sleeps Tonite' },
>X      { 'number' => 4,  'content' => 'Everybody Hurts' },
>X      { 'number' => 5,  'content' => 'New Orleans Instrumental No. 1' },
>X      { 'number' => 6,  'content' => 'Sweetness Follows' },
>X      { 'number' => 7,  'content' => 'Monty Got A Raw Deal' },
>X      { 'number' => 8,  'content' => 'Ignoreland' },
>X      { 'number' => 9,  'content' => 'Star Me Kitten' },
>X      { 'number' => 10, 'content' => 'Man On The Moon' },
>X      { 'number' => 11, 'content' => 'Nightswimming' },
>X      { 'number' => 12, 'content' => 'Find The River' }
>X    ]
>X  }
>X};
>X
>Xmy $ref2 = $xs2->XMLin($xml);
>Xok(5, DataCompare($ref2, $exp2));       # Parsed to what we expected
>X
>X
>X
>X# Confirm default options in object merge correctly with options as args
>X
>X$ref1 = $xs1->XMLin($xml, keyattr => [], forcearray => 0);
>X
>Xok(6, DataCompare($ref1, {              # Parsed to what we expected
>X  'cddatabase' => {
>X    'disc' => {
>X      'album' => 'Automatic For The People',
>X      'id' => '9362-45055-2',
>X      'artist' => 'R.E.M.',
>X      'cddbid' => '960b750c',
>X      'track' => [
>X        { 'number' => 1,  'title' => 'Drive' },
>X        { 'number' => 2,  'title' => 'Try Not To Breathe' },
>X        { 'number' => 3,  'title' => 'The Sidewinder Sleeps Tonite' },
>X        { 'number' => 4,  'title' => 'Everybody Hurts' },
>X        { 'number' => 5,  'title' => 'New Orleans Instrumental No. 1' },
>X        { 'number' => 6,  'title' => 'Sweetness Follows' },
>X        { 'number' => 7,  'title' => 'Monty Got A Raw Deal' },
>X        { 'number' => 8,  'title' => 'Ignoreland' },
>X        { 'number' => 9,  'title' => 'Star Me Kitten' },
>X        { 'number' => 10, 'title' => 'Man On The Moon' },
>X        { 'number' => 11, 'title' => 'Nightswimming' },
>X        { 'number' => 12, 'title' => 'Find The River' }
>X      ]
>X    }
>X  }
>X}));
>X
>X
>X# Confirm that default options in object still work as expected
>X
>X$ref1 = $xs1->XMLin($xml);
>Xok(7, DataCompare($ref1, $exp1));       # Still parsed to what we expected
>X
>X
>X# Confirm they work for output too
>X
>X$_ = $xs1->XMLout($ref1);
>X
>Xok(8,  s{<track number="1">Drive</track>}                         {<NEST/>});
>Xok(9,  s{<track number="2">Try Not To Breathe</track>}            {<NEST/>});
>Xok(10, s{<track number="3">The Sidewinder Sleeps Tonite</track>}  {<NEST/>});
>Xok(11, s{<track number="4">Everybody Hurts</track>}               {<NEST/>});
>Xok(12, s{<track number="5">New Orleans Instrumental No. 1</track>}{<NEST/>});
>Xok(13, s{<track number="6">Sweetness Follows</track>}             {<NEST/>});
>Xok(14, s{<track number="7">Monty Got A Raw Deal</track>}          {<NEST/>});
>Xok(15, s{<track number="8">Ignoreland</track>}                    {<NEST/>});
>Xok(16, s{<track number="9">Star Me Kitten</track>}                {<NEST/>});
>Xok(17, s{<track number="10">Man On The Moon</track>}              {<NEST/>});
>Xok(18, s{<track number="11">Nightswimming</track>}                {<NEST/>});
>Xok(19, s{<track number="12">Find The River</track>}               {<NEST/>});
>Xok(20, s{<album>Automatic For The People</album>}                 {<NEST/>});
>Xok(21, s{cddbid="960b750c"}{ATTR});
>Xok(22, s{id="9362-45055-2"}{ATTR});
>Xok(23, s{artist="R.E.M."}  {ATTR});
>Xok(24, s{<disc(\s+ATTR){3}\s*>(\s*<NEST/>){13}\s*</disc>}{<DISC/>}s);
>Xok(25, m{^\s*<(cddatabase)>\s*<DISC/>\s*</\1>\s*$});
>X
>X
>X# Check that overriding build_tree() method works
>X
>X$xml = q(<opt>
>X  <server>
>X    <name>Apollo</name>
>X    <address>10 Downing Street</address>
>X  </server>
>X</opt>
>X);
>X
>Xmy $xsp = new XML::Simple::UC();
>X$ref1 = $xsp->XMLin($xml);
>Xok(26, DataCompare($ref1, {
>X  'SERVER' => {
>X    'NAME' => 'APOLLO',
>X    'ADDRESS' => '10 DOWNING STREET'
>X  }
>X}));
>X
>X
>X# Check that overriding escape_value() method works
>X
>Xmy $ref = {
>X  'server' => {
>X    'address' => '12->14 "Puf&Stuf" Drive'
>X  }
>X};
>X
>X$xsp = new XML::Simple::CDE();
>X
>X$_ = $xsp->XMLout($ref);
>X
>Xok(27, m{<opt>\s*
>X <server\s+address="<!\[CDATA\[12->14\s+"Puf&Stuf"\s+Drive\]\]>"\s*/>\s*
>X</opt>}xs);
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/6_ObjIntf.t
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/desertnet.src
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/desertnet.src << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/desertnet.src'
>X<config>
>X  <server name="sahara" osname="solaris" osversion="2.6">
>X    <address>10.0.0.101</address>
>X    <address>10.0.1.101</address>
>X  </server>
>X  <server name="gobi" osname="irix" osversion="6.5">
>X    <address>10.0.0.102</address>
>X  </server>
>X  <server name="kalahari" osname="linux" osversion="2.0.34">
>X    <address>10.0.0.103</address>
>X    <address>10.0.1.103</address>
>X  </server>
>X</config>
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/desertnet.src
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/srt.xml
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/srt.xml << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/srt.xml'
>X<?xml version='1.0' standalone='yes'?>
>X
>X
>X   
>X<opt>
>X  <global tempdir="C:/Temp"
>X	  httpproxy="http://10.1.1.5:8080/"
>X	  proxyuser="foo"
>X	  proxypswd="bar" >
>X
>X    <exclude>/_vt</exclude>
>X    <exclude>/save\b</exclude>
>X    <exclude>\.bak$</exclude>
>X    <exclude>\.\$\$\$$</exclude>
>X
>X  </global>
>X
>X  <pubpath name="test1" title="web_source -&gt; web_target1">
>X    <source label="web_source"
>X            root="C:/webshare/web_source" />
>X    <target label="web_target1"
>X            root="C:/webshare/web_target1"
>X            temp="C:/webshare/web_target1/temp" />
>X
>X    <dir>wwwroot</dir>
>X
>X    <package name="images" dir="wwwroot/images" />
>X
>X  </pubpath>
>X
>X  <pubpath name="test2" title="web_source -&gt; web_target1 &amp; web_target2">
>X    <source label="web_source"
>X            root="C:/webshare/web_source" />
>X    <target label="web_target1"
>X            root="C:/webshare/web_target1"
>X            temp="C:/webshare/web_target1/temp" />
>X    <target label="web_target2"
>X            root="C:/webshare/web_target2"
>X            temp="C:/webshare/web_target2/temp" />
>X
>X    <dir>wwwroot</dir>
>X
>X    <package name="images" dir="wwwroot/images" />
>X    <package name="templates" dir="wwwroot/templates" />
>X    <package name="bios" dir="wwwroot/staff/bios" />
>X
>X  </pubpath>
>X
>X  <pubpath name="test3" title="web_source -&gt; web_target1 via HTTP">
>X    <source label="web_source"
>X            root="C:/webshare/web_source" />
>X    <target label="web_target1"
>X            root="http://127.0.0.1/cgi-bin/srt_slave.plx"
>X            noproxy="1" />
>X
>X    <dir>wwwroot</dir>
>X
>X    <addexclude>\.pdf$</addexclude>
>X
>X  </pubpath>
>X
>X</opt>
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/srt.xml
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir > /dev/null 2>&1
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir/test2.xml
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir/test2.xml << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir/test2.xml'
>X<opt location="t/subdir/test2.xml" />
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir/test2.xml
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/test1.xml
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/test1.xml << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/test1.xml'
>X<opt location="t/test1.xml" />
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/test1.xml
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX > /dev/null 2>&1
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/.exists
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/.exists << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/.exists'
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/.exists
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/Simple.pm
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/Simple.pm << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/Simple.pm'
>X# $Id: Simple.pm,v 1.1.1.1 2001/11/13 14:07:40 matt Exp $
>X
>Xpackage XML::SAX::Simple;
>X
>Xuse strict;
>Xuse vars qw($VERSION @ISA @EXPORT);
>Xuse XML::Simple ();
>Xuse XML::SAX;
>Xuse XML::Handler::Trees;
>X@ISA = ('XML::Simple');
>X
>X$VERSION = '0.01';
>X
>X@EXPORT = qw(XMLin XMLout);
>X
>Xsub XMLin {
>X    my $self;
>X    if($_[0]  and  UNIVERSAL::isa($_[0], 'XML::Simple')) {
>X        $self = shift;
>X    }
>X    else {
>X        $self = new XML::SAX::Simple();
>X    }
>X    $self->SUPER::XMLin(@_);
>X}
>X
>Xsub XMLout {
>X    my $self;
>X    if($_[0]  and  UNIVERSAL::isa($_[0], 'XML::Simple')) {
>X        $self = shift;
>X    }
>X    else {
>X        $self = new XML::SAX::Simple();
>X    }
>X    $self->SUPER::XMLout(@_);
>X}
>X
>Xsub build_tree {
>X    my $self = shift;
>X    my ($filename, $string) = @_;
>X    
>X    if($filename  and  $filename eq '-') {
>X        local($/);
>X        $string = <STDIN>;
>X        $filename = undef;
>X    }
>X    
>X    my $handler = XML::Handler::Tree->new();
>X    my $parser = XML::SAX::ParserFactory->parser(Handler => $handler);
>X    my $tree;
>X    if($filename) {
>X        $tree = $parser->parse_uri($filename);
>X    }
>X    else {
>X        if (ref($string)) {
>X            $tree = $parser->parse_file($string);
>X        }
>X        else {
>X            $tree = $parser->parse_string($string);
>X        }
>X    }
>X
>X    # use Data::Dumper;
>X    # warn("returning ", Dumper($tree), "\n");
>X    return($tree);
>X}
>X
>X1;
>X__END__
>X
>X=head1 NAME
>X
>XXML::SAX::Simple - SAX version of XML::Simple
>X
>X=head1 SYNOPSIS
>X
>X  use XML::SAX::Simple qw(XMLin XMLout);
>X  my $hash = XMLin("foo.xml");
>X
>X=head1 DESCRIPTION
>X
>XXML::SAX::Simple is a very simple version of XML::Simple but for
>XSAX. It can be used as a complete drop-in replacement for XML::Simple.
>X
>XSee the documentation for XML::Simple (which is required for this module
>Xto work) for details.
>X
>X=head1 AUTHOR
>X
>XMatt Sergeant, matt@sergeant.org
>X
>X=head1 SEE ALSO
>X
>XL<XML::Simple>, L<XML::SAX>.
>X
>X=cut
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/Simple.pm
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple > /dev/null 2>&1
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple/.exists
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple/.exists << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple/.exists'
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple/.exists
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX > /dev/null 2>&1
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple > /dev/null 2>&1
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple/.exists
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple/.exists << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple/.exists'
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple/.exists
>echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3
>mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3 > /dev/null 2>&1
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/.exists
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/.exists << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/.exists'
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/.exists
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/XML::SAX::Simple.3
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/XML::SAX::Simple.3 << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/XML::SAX::Simple.3'
>X.rn '' }`
>X''' $RCSfile$$Revision$$Date$
>X'''
>X''' $Log$
>X'''
>X.de Sh
>X.br
>X.if t .Sp
>X.ne 5
>X.PP
>X\fB\\$1\fR
>X.PP
>X..
>X.de Sp
>X.if t .sp .5v
>X.if n .sp
>X..
>X.de Ip
>X.br
>X.ie \\n(.$>=3 .ne \\$3
>X.el .ne 3
>X.IP "\\$1" \\$2
>X..
>X.de Vb
>X.ft CW
>X.nf
>X.ne \\$1
>X..
>X.de Ve
>X.ft R
>X
>X.fi
>X..
>X'''
>X'''
>X'''     Set up \*(-- to give an unbreakable dash;
>X'''     string Tr holds user defined translation string.
>X'''     Bell System Logo is used as a dummy character.
>X'''
>X.tr \(*W-|\(bv\*(Tr
>X.ie n \{\
>X.ds -- \(*W-
>X.ds PI pi
>X.if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
>X.if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch
>X.ds L" ""
>X.ds R" ""
>X'''   \*(M", \*(S", \*(N" and \*(T" are the equivalent of
>X'''   \*(L" and \*(R", except that they are used on ".xx" lines,
>X'''   such as .IP and .SH, which do another additional levels of
>X'''   double-quote interpretation
>X.ds M" """
>X.ds S" """
>X.ds N" """""
>X.ds T" """""
>X.ds L' '
>X.ds R' '
>X.ds M' '
>X.ds S' '
>X.ds N' '
>X.ds T' '
>X'br\}
>X.el\{\
>X.ds -- \(em\|
>X.tr \*(Tr
>X.ds L" ``
>X.ds R" ''
>X.ds M" ``
>X.ds S" ''
>X.ds N" ``
>X.ds T" ''
>X.ds L' `
>X.ds R' '
>X.ds M' `
>X.ds S' '
>X.ds N' `
>X.ds T' '
>X.ds PI \(*p
>X'br\}
>X.\"	If the F register is turned on, we'll generate
>X.\"	index entries out stderr for the following things:
>X.\"		TH	Title 
>X.\"		SH	Header
>X.\"		Sh	Subsection 
>X.\"		Ip	Item
>X.\"		X<>	Xref  (embedded
>X.\"	Of course, you have to process the output yourself
>X.\"	in some meaninful fashion.
>X.if \nF \{
>X.de IX
>X.tm Index:\\$1\t\\n%\t"\\$2"
>X..
>X.nr % 0
>X.rr F
>X.\}
>X.TH Simple 3 "perl 5.005, patch 03" "13/Nov/2001" "User Contributed Perl Documentation"
>X.UC
>X.if n .hy 0
>X.if n .na
>X.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
>X.de CQ          \" put $1 in typewriter font
>X.ft CW
>X'if n "\c
>X'if t \\&\\$1\c
>X'if n \\&\\$1\c
>X'if n \&"
>X\\&\\$2 \\$3 \\$4 \\$5 \\$6 \\$7
>X'.ft R
>X..
>X.\" @(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2
>X.	\" AM - accent mark definitions
>X.bd B 3
>X.	\" fudge factors for nroff and troff
>X.if n \{\
>X.	ds #H 0
>X.	ds #V .8m
>X.	ds #F .3m
>X.	ds #[ \f1
>X.	ds #] \fP
>X.\}
>X.if t \{\
>X.	ds #H ((1u-(\\\\n(.fu%2u))*.13m)
>X.	ds #V .6m
>X.	ds #F 0
>X.	ds #[ \&
>X.	ds #] \&
>X.\}
>X.	\" simple accents for nroff and troff
>X.if n \{\
>X.	ds ' \&
>X.	ds ` \&
>X.	ds ^ \&
>X.	ds , \&
>X.	ds ~ ~
>X.	ds ? ?
>X.	ds ! !
>X.	ds /
>X.	ds q
>X.\}
>X.if t \{\
>X.	ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
>X.	ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
>X.	ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
>X.	ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
>X.	ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
>X.	ds ? \s-2c\h'-\w'c'u*7/10'\u\h'\*(#H'\zi\d\s+2\h'\w'c'u*8/10'
>X.	ds ! \s-2\(or\s+2\h'-\w'\(or'u'\v'-.8m'.\v'.8m'
>X.	ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
>X.	ds q o\h'-\w'o'u*8/10'\s-4\v'.4m'\z\(*i\v'-.4m'\s+4\h'\w'o'u*8/10'
>X.\}
>X.	\" troff and (daisy-wheel) nroff accents
>X.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
>X.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
>X.ds v \\k:\h'-(\\n(.wu*9/10-\*(#H)'\v'-\*(#V'\*(#[\s-4v\s0\v'\*(#V'\h'|\\n:u'\*(#]
>X.ds _ \\k:\h'-(\\n(.wu*9/10-\*(#H+(\*(#F*2/3))'\v'-.4m'\z\(hy\v'.4m'\h'|\\n:u'
>X.ds . \\k:\h'-(\\n(.wu*8/10)'\v'\*(#V*4/10'\z.\v'-\*(#V*4/10'\h'|\\n:u'
>X.ds 3 \*(#[\v'.2m'\s-2\&3\s0\v'-.2m'\*(#]
>X.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
>X.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
>X.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
>X.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
>X.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
>X.ds ae a\h'-(\w'a'u*4/10)'e
>X.ds Ae A\h'-(\w'A'u*4/10)'E
>X.ds oe o\h'-(\w'o'u*4/10)'e
>X.ds Oe O\h'-(\w'O'u*4/10)'E
>X.	\" corrections for vroff
>X.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
>X.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
>X.	\" for low resolution devices (crt and lpr)
>X.if \n(.H>23 .if \n(.V>19 \
>X\{\
>X.	ds : e
>X.	ds 8 ss
>X.	ds v \h'-1'\o'\(aa\(ga'
>X.	ds _ \h'-1'^
>X.	ds . \h'-1'.
>X.	ds 3 3
>X.	ds o a
>X.	ds d- d\h'-1'\(ga
>X.	ds D- D\h'-1'\(hy
>X.	ds th \o'bp'
>X.	ds Th \o'LP'
>X.	ds ae ae
>X.	ds Ae AE
>X.	ds oe oe
>X.	ds Oe OE
>X.\}
>X.rm #[ #] #H #V #F C
>X.SH "NAME"
>XXML::SAX::Simple \- SAX version of XML::Simple
>X.SH "SYNOPSIS"
>X.PP
>X.Vb 2
>X\&  use XML::SAX::Simple qw(XMLin XMLout);
>X\&  my $hash = XMLin("foo.xml");
>X.Ve
>X.SH "DESCRIPTION"
>XXML::SAX::Simple is a very simple version of XML::Simple but for
>XSAX. It can be used as a complete drop-in replacement for XML::Simple.
>X.PP
>XSee the documentation for XML::Simple (which is required for this module
>Xto work) for details.
>X.SH "AUTHOR"
>XMatt Sergeant, matt@sergeant.org
>X.SH "SEE ALSO"
>Xthe \fIXML::Simple\fR manpage, the \fIXML::SAX\fR manpage.
>X
>X.rn }` ''
>X.IX Title "Simple 3"
>X.IX Name "XML::SAX::Simple - SAX version of XML::Simple"
>X
>X.IX Header "NAME"
>X
>X.IX Header "SYNOPSIS"
>X
>X.IX Header "DESCRIPTION"
>X
>X.IX Header "AUTHOR"
>X
>X.IX Header "SEE ALSO"
>X
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/XML::SAX::Simple.3
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile'
>X# This Makefile is for the XML::SAX::Simple extension to perl.
>X#
>X# It was generated automatically by MakeMaker version
>X# 5.4302 (Revision: 1.222) from the contents of
>X# Makefile.PL. Don't edit this file, edit Makefile.PL instead.
>X#
>X#	ANY CHANGES MADE HERE WILL BE LOST!
>X#
>X#   MakeMaker ARGV: (q[CC=cc], q[CCFLAGS=-O -pipe ], q[PREFIX=/usr/local])
>X#
>X#   MakeMaker Parameters:
>X
>X#	ABSTRACT_FROM => q[Simple.pm]
>X#	AUTHOR => q[Matt Sergeant, <matt@sergeant.org>]
>X#	NAME => q[XML::SAX::Simple]
>X#	PREREQ_PM => { XML::SAX=>q[0.02], XML::Handler::Trees=>q[0.02], XML::Simple=>q[1.06] }
>X#	VERSION_FROM => q[Simple.pm]
>X
>X# --- MakeMaker post_initialize section:
>X
>X
>X# --- MakeMaker const_config section:
>X
>X# These definitions are from config.sh (via /usr/libdata/perl/5.00503/mach/Config.pm)
>X
>X# They may have been overridden via Makefile.PL or on the command line
>XAR = ar
>XCC = cc
>XCCCDLFLAGS = -DPIC -fpic
>XCCDLFLAGS =  -Wl,-R/usr/lib
>XDLEXT = so
>XDLSRC = dl_dlopen.xs
>XLD = cc
>XLDDLFLAGS = -Wl,-E -shared -lperl -lm 
>XLDFLAGS = -Wl,-E -lperl -lm 
>XLIBC = 
>XLIB_EXT = .a
>XOBJ_EXT = .o
>XOSNAME = freebsd
>XOSVERS = 4.0-current
>XRANLIB = :
>XSO = so
>XEXE_EXT = 
>X
>X
>X# --- MakeMaker constants section:
>XAR_STATIC_ARGS = cr
>XNAME = XML::SAX::Simple
>XDISTNAME = XML-SAX-Simple
>XNAME_SYM = XML_SAX_Simple
>XVERSION = 0.01
>XVERSION_SYM = 0_01
>XXS_VERSION = 0.01
>XINST_BIN = blib/bin
>XINST_EXE = blib/script
>XINST_LIB = blib/lib
>XINST_ARCHLIB = blib/arch
>XINST_SCRIPT = blib/script
>XPREFIX = /usr/local
>XINSTALLDIRS = site
>XINSTALLPRIVLIB = /usr/libdata/perl/5.00503
>XINSTALLARCHLIB = /usr/libdata/perl/5.00503/mach
>XINSTALLSITELIB = /usr/local/lib/perl5/site_perl/5.005
>XINSTALLSITEARCH = /usr/local/lib/perl5/site_perl/5.005/i386-freebsd
>XINSTALLBIN = $(PREFIX)/bin
>XINSTALLSCRIPT = $(PREFIX)/bin
>XPERL_LIB = /usr/libdata/perl/5.00503
>XPERL_ARCHLIB = /usr/libdata/perl/5.00503/mach
>XSITELIBEXP = /usr/local/lib/perl5/site_perl/5.005
>XSITEARCHEXP = /usr/local/lib/perl5/site_perl/5.005/i386-freebsd
>XLIBPERL_A = libperl.a
>XFIRST_MAKEFILE = Makefile
>XMAKE_APERL_FILE = Makefile.aperl
>XPERLMAINCC = $(CC)
>XPERL_INC = /usr/libdata/perl/5.00503/mach/CORE
>XPERL = /usr/bin/perl5.00503
>XFULLPERL = /usr/bin/perl5.00503
>X
>XVERSION_MACRO = VERSION
>XDEFINE_VERSION = -D$(VERSION_MACRO)=\"$(VERSION)\"
>XXS_VERSION_MACRO = XS_VERSION
>XXS_DEFINE_VERSION = -D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\"
>X
>XMAKEMAKER = /usr/libdata/perl/5.00503/ExtUtils/MakeMaker.pm
>XMM_VERSION = 5.4302
>X
>X# FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
>X# BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
>X# ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)  !!! Deprecated from MM 5.32  !!!
>X# PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
>X# DLBASE  = Basename part of dynamic library. May be just equal BASEEXT.
>XFULLEXT = XML/SAX/Simple
>XBASEEXT = Simple
>XPARENT_NAME = XML::SAX
>XDLBASE = $(BASEEXT)
>XVERSION_FROM = Simple.pm
>XOBJECT = 
>XLDFROM = $(OBJECT)
>XLINKTYPE = dynamic
>X
>X# Handy lists of source code files:
>XXS_FILES= 
>XC_FILES = 
>XO_FILES = 
>XH_FILES = 
>XMAN1PODS = 
>XMAN3PODS = Simple.pm
>XINST_MAN1DIR = blib/man1
>XINSTALLMAN1DIR = /usr/local/man/man1
>XMAN1EXT = 1
>XINST_MAN3DIR = blib/man3
>XINSTALLMAN3DIR = /usr/local/lib/perl5/5.00503/man/man3
>XMAN3EXT = 3
>XPERM_RW = 644
>XPERM_RWX = 755
>X
>X# work around a famous dec-osf make(1) feature(?):
>Xmakemakerdflt: all
>X
>X.SUFFIXES: .xs .c .C .cpp .cxx .cc $(OBJ_EXT)
>X
>X# Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
>X# some make implementations will delete the Makefile when we rebuild it. Because
>X# we call false(1) when we rebuild it. So make(1) is not completely wrong when it
>X# does so. Our milage may vary.
>X# .PRECIOUS: Makefile    # seems to be not necessary anymore
>X
>X.PHONY: all config static dynamic test linkext manifest
>X
>X# Where is the Config information that we are using/depend on
>XCONFIGDEP = $(PERL_ARCHLIB)/Config.pm $(PERL_INC)/config.h
>X
>X# Where to put things:
>XINST_LIBDIR      = $(INST_LIB)/XML/SAX
>XINST_ARCHLIBDIR  = $(INST_ARCHLIB)/XML/SAX
>X
>XINST_AUTODIR     = $(INST_LIB)/auto/$(FULLEXT)
>XINST_ARCHAUTODIR = $(INST_ARCHLIB)/auto/$(FULLEXT)
>X
>XINST_STATIC  =
>XINST_DYNAMIC =
>XINST_BOOT    =
>X
>XEXPORT_LIST = 
>X
>XPERL_ARCHIVE = 
>X
>XTO_INST_PM = Simple.pm
>X
>XPM_TO_BLIB = Simple.pm \
>X	$(INST_LIBDIR)/Simple.pm
>X
>X
>X# --- MakeMaker tool_autosplit section:
>X
>X# Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
>XAUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
>X
>X
>X# --- MakeMaker tool_xsubpp section:
>X
>X
>X# --- MakeMaker tools_other section:
>X
>XSHELL = /bin/sh
>XCHMOD = chmod
>XCP = cp
>XLD = cc
>XMV = mv
>XNOOP = $(SHELL) -c true
>XRM_F = rm -f
>XRM_RF = rm -rf
>XTEST_F = test -f
>XTOUCH = touch
>XUMASK_NULL = umask 0
>XDEV_NULL = > /dev/null 2>&1
>X
>X# The following is a portable way to say mkdir -p
>X# To see which directories are created, change the if 0 to if 1
>XMKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
>X
>X# This helps us to minimize the effect of the .exists files A yet
>X# better solution would be to have a stable file in the perl
>X# distribution with a timestamp of zero. But this solution doesn't
>X# need any changes to the core distribution and works with older perls
>XEQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
>X
>X# Here we warn users that an old packlist file was found somewhere,
>X# and that they should call some uninstall routine
>XWARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \
>X-e 'print "WARNING: I have found an old package in\n";' \
>X-e 'print "\t$$ARGV[0].\n";' \
>X-e 'print "Please make sure the two installations are not conflicting\n";'
>X
>XUNINST=0
>XVERBINST=1
>X
>XMOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
>X-e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
>X
>XDOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
>X-e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", shift, ">";' \
>X-e 'print "=over 4";' \
>X-e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
>X-e 'print "=back";'
>X
>XUNINSTALL =   $(PERL) -MExtUtils::Install \
>X-e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
>X-e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
>X-e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
>X
>X
>X# --- MakeMaker dist section:
>X
>XDISTVNAME = $(DISTNAME)-$(VERSION)
>XTAR  = tar
>XTARFLAGS = cvf
>XZIP  = zip
>XZIPFLAGS = -r
>XCOMPRESS = gzip --best
>XSUFFIX = .gz
>XSHAR = shar
>XPREOP = @$(NOOP)
>XPOSTOP = @$(NOOP)
>XTO_UNIX = @$(NOOP)
>XCI = ci -u
>XRCS_LABEL = rcs -Nv$(VERSION_SYM): -q
>XDIST_CP = best
>XDIST_DEFAULT = tardist
>X
>X
>X# --- MakeMaker macro section:
>X
>X
>X# --- MakeMaker depend section:
>X
>X
>X# --- MakeMaker cflags section:
>X
>X
>X# --- MakeMaker const_loadlibs section:
>X
>X
>X# --- MakeMaker const_cccmd section:
>X
>X
>X# --- MakeMaker post_constants section:
>X
>X
>X# --- MakeMaker pasthru section:
>X
>XPASTHRU = LIB="$(LIB)"\
>X	LIBPERL_A="$(LIBPERL_A)"\
>X	LINKTYPE="$(LINKTYPE)"\
>X	PREFIX="$(PREFIX)"\
>X	OPTIMIZE="$(OPTIMIZE)"
>X
>X
>X# --- MakeMaker c_o section:
>X
>X
>X# --- MakeMaker xs_c section:
>X
>X
>X# --- MakeMaker xs_o section:
>X
>X
>X# --- MakeMaker top_targets section:
>X
>X#all ::	config $(INST_PM) subdirs linkext manifypods
>X
>Xall :: pure_all manifypods
>X	@$(NOOP)
>X
>Xpure_all :: config pm_to_blib subdirs linkext
>X	@$(NOOP)
>X
>Xsubdirs :: $(MYEXTLIB)
>X	@$(NOOP)
>X
>Xconfig :: Makefile $(INST_LIBDIR)/.exists
>X	@$(NOOP)
>X
>Xconfig :: $(INST_ARCHAUTODIR)/.exists
>X	@$(NOOP)
>X
>Xconfig :: $(INST_AUTODIR)/.exists
>X	@$(NOOP)
>X
>Xconfig :: Version_check
>X	@$(NOOP)
>X
>X
>X$(INST_AUTODIR)/.exists :: /usr/libdata/perl/5.00503/mach/CORE/perl.h
>X	@$(MKPATH) $(INST_AUTODIR)
>X	@$(EQUALIZE_TIMESTAMP) /usr/libdata/perl/5.00503/mach/CORE/perl.h $(INST_AUTODIR)/.exists
>X
>X	-@$(CHMOD) $(PERM_RWX) $(INST_AUTODIR)
>X
>X$(INST_LIBDIR)/.exists :: /usr/libdata/perl/5.00503/mach/CORE/perl.h
>X	@$(MKPATH) $(INST_LIBDIR)
>X	@$(EQUALIZE_TIMESTAMP) /usr/libdata/perl/5.00503/mach/CORE/perl.h $(INST_LIBDIR)/.exists
>X
>X	-@$(CHMOD) $(PERM_RWX) $(INST_LIBDIR)
>X
>X$(INST_ARCHAUTODIR)/.exists :: /usr/libdata/perl/5.00503/mach/CORE/perl.h
>X	@$(MKPATH) $(INST_ARCHAUTODIR)
>X	@$(EQUALIZE_TIMESTAMP) /usr/libdata/perl/5.00503/mach/CORE/perl.h $(INST_ARCHAUTODIR)/.exists
>X
>X	-@$(CHMOD) $(PERM_RWX) $(INST_ARCHAUTODIR)
>X
>Xconfig :: $(INST_MAN3DIR)/.exists
>X	@$(NOOP)
>X
>X
>X$(INST_MAN3DIR)/.exists :: /usr/libdata/perl/5.00503/mach/CORE/perl.h
>X	@$(MKPATH) $(INST_MAN3DIR)
>X	@$(EQUALIZE_TIMESTAMP) /usr/libdata/perl/5.00503/mach/CORE/perl.h $(INST_MAN3DIR)/.exists
>X
>X	-@$(CHMOD) $(PERM_RWX) $(INST_MAN3DIR)
>X
>Xhelp:
>X	perldoc ExtUtils::MakeMaker
>X
>XVersion_check:
>X	@$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
>X		-MExtUtils::MakeMaker=Version_check \
>X		-e "Version_check('$(MM_VERSION)')"
>X
>X
>X# --- MakeMaker linkext section:
>X
>Xlinkext :: $(LINKTYPE)
>X	@$(NOOP)
>X
>X
>X# --- MakeMaker dlsyms section:
>X
>X
>X# --- MakeMaker dynamic section:
>X
>X## $(INST_PM) has been moved to the all: target.
>X## It remains here for awhile to allow for old usage: "make dynamic"
>X#dynamic :: Makefile $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
>Xdynamic :: Makefile $(INST_DYNAMIC) $(INST_BOOT)
>X	@$(NOOP)
>X
>X
>X# --- MakeMaker dynamic_bs section:
>X
>XBOOTSTRAP =
>X
>X
>X# --- MakeMaker dynamic_lib section:
>X
>X
>X# --- MakeMaker static section:
>X
>X## $(INST_PM) has been moved to the all: target.
>X## It remains here for awhile to allow for old usage: "make static"
>X#static :: Makefile $(INST_STATIC) $(INST_PM)
>Xstatic :: Makefile $(INST_STATIC)
>X	@$(NOOP)
>X
>X
>X# --- MakeMaker static_lib section:
>X
>X
>X# --- MakeMaker manifypods section:
>XPOD2MAN_EXE = /usr/bin/pod2man
>XPOD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \
>X-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "Makefile";' \
>X-e 'print "Manifying $$m{$$_}\n";' \
>X-e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\047t install $$m{$$_}\n";' \
>X-e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
>X
>Xmanifypods : pure_all Simple.pm
>X	@$(POD2MAN) \
>X	Simple.pm \
>X	$(INST_MAN3DIR)/XML::SAX::Simple.$(MAN3EXT)
>X
>X# --- MakeMaker processPL section:
>X
>X
>X# --- MakeMaker installbin section:
>X
>X
>X# --- MakeMaker subdirs section:
>X
>X# none
>X
>X# --- MakeMaker clean section:
>X
>X# Delete temporary files but do not touch installed files. We don't delete
>X# the Makefile here so a later make realclean still has a makefile to use.
>X
>Xclean ::
>X	-rm -rf ./blib $(MAKE_APERL_FILE) $(INST_ARCHAUTODIR)/extralibs.all perlmain.c mon.out core so_locations pm_to_blib *~ */*~ */*/*~ *$(OBJ_EXT) *$(LIB_EXT) perl.exe $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def $(BASEEXT).exp
>X	-mv Makefile Makefile.old $(DEV_NULL)
>X
>X
>X# --- MakeMaker realclean section:
>X
>X# Delete temporary files (via clean) and also delete installed files
>Xrealclean purge ::  clean
>X	rm -rf $(INST_AUTODIR) $(INST_ARCHAUTODIR)
>X	rm -f $(INST_LIBDIR)/Simple.pm
>X	rm -rf Makefile Makefile.old
>X
>X
>X# --- MakeMaker dist_basics section:
>X
>Xdistclean :: realclean distcheck
>X
>Xdistcheck :
>X	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=fullcheck \
>X		-e fullcheck
>X
>Xskipcheck :
>X	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=skipcheck \
>X		-e skipcheck
>X
>Xmanifest :
>X	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=mkmanifest \
>X		-e mkmanifest
>X
>X
>X# --- MakeMaker dist_core section:
>X
>Xdist : $(DIST_DEFAULT)
>X	@$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
>X	    -e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "Makefile";'
>X
>Xtardist : $(DISTVNAME).tar$(SUFFIX)
>X
>Xzipdist : $(DISTVNAME).zip
>X
>X$(DISTVNAME).tar$(SUFFIX) : distdir
>X	$(PREOP)
>X	$(TO_UNIX)
>X	$(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
>X	$(RM_RF) $(DISTVNAME)
>X	$(COMPRESS) $(DISTVNAME).tar
>X	$(POSTOP)
>X
>X$(DISTVNAME).zip : distdir
>X	$(PREOP)
>X	$(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
>X	$(RM_RF) $(DISTVNAME)
>X	$(POSTOP)
>X
>Xuutardist : $(DISTVNAME).tar$(SUFFIX)
>X	uuencode $(DISTVNAME).tar$(SUFFIX) \
>X		$(DISTVNAME).tar$(SUFFIX) > \
>X		$(DISTVNAME).tar$(SUFFIX)_uu
>X
>Xshdist : distdir
>X	$(PREOP)
>X	$(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
>X	$(RM_RF) $(DISTVNAME)
>X	$(POSTOP)
>X
>X
>X# --- MakeMaker dist_dir section:
>X
>Xdistdir :
>X	$(RM_RF) $(DISTVNAME)
>X	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=manicopy,maniread \
>X		-e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
>X
>X
>X# --- MakeMaker dist_test section:
>X
>Xdisttest : distdir
>X	cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
>X	cd $(DISTVNAME) && $(MAKE)
>X	cd $(DISTVNAME) && $(MAKE) test
>X
>X
>X# --- MakeMaker dist_ci section:
>X
>Xci :
>X	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=maniread \
>X		-e "@all = keys %{ maniread() };" \
>X		-e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \
>X		-e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
>X
>X
>X# --- MakeMaker install section:
>X
>Xinstall :: all pure_install doc_install
>X
>Xinstall_perl :: all pure_perl_install doc_perl_install
>X
>Xinstall_site :: all pure_site_install doc_site_install
>X
>Xinstall_ :: install_site
>X	@echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
>X
>Xpure_install :: pure_$(INSTALLDIRS)_install
>X
>Xdoc_install :: doc_$(INSTALLDIRS)_install
>X	@echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
>X
>Xpure__install : pure_site_install
>X	@echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
>X
>Xdoc__install : doc_site_install
>X	@echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
>X
>Xpure_perl_install ::
>X	@$(MOD_INSTALL) \
>X		read $(PERL_ARCHLIB)/auto/$(FULLEXT)/.packlist \
>X		write $(INSTALLARCHLIB)/auto/$(FULLEXT)/.packlist \
>X		$(INST_LIB) $(INSTALLPRIVLIB) \
>X		$(INST_ARCHLIB) $(INSTALLARCHLIB) \
>X		$(INST_BIN) $(INSTALLBIN) \
>X		$(INST_SCRIPT) $(INSTALLSCRIPT) \
>X		$(INST_MAN1DIR) $(INSTALLMAN1DIR) \
>X		$(INST_MAN3DIR) $(INSTALLMAN3DIR)
>X	@$(WARN_IF_OLD_PACKLIST) \
>X		$(SITEARCHEXP)/auto/$(FULLEXT)
>X
>X
>Xpure_site_install ::
>X	@$(MOD_INSTALL) \
>X		read $(SITEARCHEXP)/auto/$(FULLEXT)/.packlist \
>X		write $(INSTALLSITEARCH)/auto/$(FULLEXT)/.packlist \
>X		$(INST_LIB) $(INSTALLSITELIB) \
>X		$(INST_ARCHLIB) $(INSTALLSITEARCH) \
>X		$(INST_BIN) $(INSTALLBIN) \
>X		$(INST_SCRIPT) $(INSTALLSCRIPT) \
>X		$(INST_MAN1DIR) $(INSTALLMAN1DIR) \
>X		$(INST_MAN3DIR) $(INSTALLMAN3DIR)
>X	@$(WARN_IF_OLD_PACKLIST) \
>X		$(PERL_ARCHLIB)/auto/$(FULLEXT)
>X
>Xdoc_perl_install ::
>X	-@$(DOC_INSTALL) \
>X		"Module" "$(NAME)" \
>X		"installed into" "$(INSTALLPRIVLIB)" \
>X		LINKTYPE "$(LINKTYPE)" \
>X		VERSION "$(VERSION)" \
>X		EXE_FILES "$(EXE_FILES)" \
>X		>> $(INSTALLARCHLIB)/perllocal.pod
>X
>Xdoc_site_install ::
>X	-@$(DOC_INSTALL) \
>X		"Module" "$(NAME)" \
>X		"installed into" "$(INSTALLSITELIB)" \
>X		LINKTYPE "$(LINKTYPE)" \
>X		VERSION "$(VERSION)" \
>X		EXE_FILES "$(EXE_FILES)" \
>X		>> $(INSTALLARCHLIB)/perllocal.pod
>X
>X
>Xuninstall :: uninstall_from_$(INSTALLDIRS)dirs
>X
>Xuninstall_from_perldirs ::
>X	@$(UNINSTALL) $(PERL_ARCHLIB)/auto/$(FULLEXT)/.packlist
>X
>Xuninstall_from_sitedirs ::
>X	@$(UNINSTALL) $(SITEARCHEXP)/auto/$(FULLEXT)/.packlist
>X
>X
>X# --- MakeMaker force section:
>X# Phony target to force checking subdirectories.
>XFORCE:
>X	@$(NOOP)
>X
>X
>X# --- MakeMaker perldepend section:
>X
>X
>X# --- MakeMaker makefile section:
>X
>X# We take a very conservative approach here, but it\'s worth it.
>X# We move Makefile to Makefile.old here to avoid gnu make looping.
>XMakefile : Makefile.PL $(CONFIGDEP)
>X	@echo "Makefile out-of-date with respect to $?"
>X	@echo "Cleaning current config before rebuilding Makefile..."
>X	-@$(RM_F) Makefile.old
>X	-@$(MV) Makefile Makefile.old
>X	-$(MAKE) -f Makefile.old clean $(DEV_NULL) || $(NOOP)
>X	$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL "CC=cc" "CCFLAGS=-O -pipe " "PREFIX=/usr/local"
>X	@echo "==> Your Makefile has been rebuilt. <=="
>X	@echo "==> Please rerun the make command.  <=="
>X	false
>X
>X# To change behavior to :: would be nice, but would break Tk b9.02
>X# so you find such a warning below the dist target.
>X#Makefile :: $(VERSION_FROM)
>X#	@echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
>X
>X
>X# --- MakeMaker staticmake section:
>X
>X# --- MakeMaker makeaperl section ---
>XMAP_TARGET    = perl
>XFULLPERL      = /usr/bin/perl5.00503
>X
>X$(MAP_TARGET) :: static $(MAKE_APERL_FILE)
>X	$(MAKE) -f $(MAKE_APERL_FILE) $@
>X
>X$(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
>X	@echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
>X	@$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
>X		Makefile.PL DIR= \
>X		MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
>X		MAKEAPERL=1 NORECURS=1 CCCDLFLAGS= \
>X		CC=cc \
>X		CCFLAGS='-O -pipe ' \
>X		PREFIX=/usr/local
>X
>X
>X# --- MakeMaker test section:
>X
>XTEST_VERBOSE=0
>XTEST_TYPE=test_$(LINKTYPE)
>XTEST_FILE = test.pl
>XTEST_FILES = t/*.t
>XTESTDB_SW = -d
>X
>Xtestdb :: testdb_$(LINKTYPE)
>X
>Xtest :: $(TEST_TYPE)
>X
>Xtest_dynamic :: pure_all
>X	PERL_DL_NONLAZY=1 $(FULLPERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use Test::Harness qw(&runtests $$verbose); $$verbose=$(TEST_VERBOSE); runtests @ARGV;' $(TEST_FILES)
>X
>Xtestdb_dynamic :: pure_all
>X	PERL_DL_NONLAZY=1 $(FULLPERL) $(TESTDB_SW) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(TEST_FILE)
>X
>Xtest_ : test_dynamic
>X
>Xtest_static :: test_dynamic
>Xtestdb_static :: testdb_dynamic
>X
>X
>X# --- MakeMaker ppd section:
>X# Creates a PPD (Perl Package Description) for a binary distribution.
>Xppd:
>X	@$(PERL) -e "print qq{<SOFTPKG NAME=\"XML-SAX-Simple\" VERSION=\"0,01,0,0\">\n}. qq{\t<TITLE>XML-SAX-Simple</TITLE>\n}. qq{\t<ABSTRACT></ABSTRACT>\n}. qq{\t<AUTHOR>Matt Sergeant, &lt;matt\@sergeant.org&gt;</AUTHOR>\n}. qq{\t<IMPLEMENTATION>\n}. qq{\t\t<DEPENDENCY NAME=\"XML-Handler-Trees\" VERSION=\"0,02,0,0\" />\n}. qq{\t\t<DEPENDENCY NAME=\"XML-SAX\" VERSION=\"0,02,0,0\" />\n}. qq{\t\t<DEPENDENCY NAME=\"XML-Simple\" VERSION=\"1,06,0,0\" />\n}. qq{\t\t<OS NAME=\"$(OSNAME)\" />\n}. qq{\t\t<ARCHITECTURE NAME=\"i386-freebsd\" />\n}. qq{\t\t<CODEBASE HREF=\"\" />\n}. qq{\t</IMPLEMENTATION>\n}. qq{</SOFTPKG>\n}" > XML-SAX-Simple.ppd
>X
>X# --- MakeMaker pm_to_blib section:
>X
>Xpm_to_blib: $(TO_INST_PM)
>X	@$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
>X	"-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
>X        -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'$(INST_LIB)/auto')"
>X	@$(TOUCH) $@
>X
>X
>X# --- MakeMaker selfdocument section:
>X
>X
>X# --- MakeMaker postamble section:
>X
>X
>X# End.
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile
>echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/pm_to_blib
>sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/pm_to_blib << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/pm_to_blib'
>END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/pm_to_blib
>echo x - p5-XML-SAX-Simple/work/.extract_done.p5-XML-SAX-Simple-0.01
>sed 's/^X//' >p5-XML-SAX-Simple/work/.extract_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.extract_done.p5-XML-SAX-Simple-0.01'
>END-of-p5-XML-SAX-Simple/work/.extract_done.p5-XML-SAX-Simple-0.01
>echo x - p5-XML-SAX-Simple/work/.patch_done.p5-XML-SAX-Simple-0.01
>sed 's/^X//' >p5-XML-SAX-Simple/work/.patch_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.patch_done.p5-XML-SAX-Simple-0.01'
>END-of-p5-XML-SAX-Simple/work/.patch_done.p5-XML-SAX-Simple-0.01
>echo x - p5-XML-SAX-Simple/work/.configure_done.p5-XML-SAX-Simple-0.01
>sed 's/^X//' >p5-XML-SAX-Simple/work/.configure_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.configure_done.p5-XML-SAX-Simple-0.01'
>END-of-p5-XML-SAX-Simple/work/.configure_done.p5-XML-SAX-Simple-0.01
>echo x - p5-XML-SAX-Simple/work/.build_done.p5-XML-SAX-Simple-0.01
>sed 's/^X//' >p5-XML-SAX-Simple/work/.build_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.build_done.p5-XML-SAX-Simple-0.01'
>END-of-p5-XML-SAX-Simple/work/.build_done.p5-XML-SAX-Simple-0.01
>echo x - p5-XML-SAX-Simple/work/.PLIST.mktmp
>sed 's/^X//' >p5-XML-SAX-Simple/work/.PLIST.mktmp << 'END-of-p5-XML-SAX-Simple/work/.PLIST.mktmp'
>Xlib/perl5/5.00503/man/man3/XML::SAX::Simple.3.gz
>Xlib/perl5/site_perl/5.005/i386-freebsd/auto/XML/SAX/Simple/.packlist
>Xlib/perl5/site_perl/5.005/XML/SAX/Simple.pm
>X@dirrm lib/perl5/site_perl/5.005/i386-freebsd/auto/XML/SAX/Simple
>X@unexec rmdir %D/lib/perl5/site_perl/5.005/XML/SAX 2>/dev/null || true
>X@unexec rmdir %D/lib/perl5/site_perl/5.005/XML 2>/dev/null || true
>X@unexec rmdir %D/lib/perl5/site_perl/5.005/i386-freebsd/auto/XML/SAX 2>/dev/null || true
>X@unexec rmdir %D/lib/perl5/site_perl/5.005/i386-freebsd/auto/XML 2>/dev/null || true
>X@unexec if [ -f %D/info/dir ]; then if sed -e '1,/Menu:/d' %D/info/dir | grep -q '^[*] '; then true; else rm %D/info/dir; fi; fi
>END-of-p5-XML-SAX-Simple/work/.PLIST.mktmp
>echo x - p5-XML-SAX-Simple/work/.install_done.p5-XML-SAX-Simple-0.01
>sed 's/^X//' >p5-XML-SAX-Simple/work/.install_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.install_done.p5-XML-SAX-Simple-0.01'
>END-of-p5-XML-SAX-Simple/work/.install_done.p5-XML-SAX-Simple-0.01
>echo x - p5-XML-SAX-Simple/work/.PLIST.setuid
>sed 's/^X//' >p5-XML-SAX-Simple/work/.PLIST.setuid << 'END-of-p5-XML-SAX-Simple/work/.PLIST.setuid'
>END-of-p5-XML-SAX-Simple/work/.PLIST.setuid
>echo x - p5-XML-SAX-Simple/work/.PLIST.startup
>sed 's/^X//' >p5-XML-SAX-Simple/work/.PLIST.startup << 'END-of-p5-XML-SAX-Simple/work/.PLIST.startup'
>END-of-p5-XML-SAX-Simple/work/.PLIST.startup
>echo x - p5-XML-SAX-Simple/work/.package_done.p5-XML-SAX-Simple-0.01
>sed 's/^X//' >p5-XML-SAX-Simple/work/.package_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.package_done.p5-XML-SAX-Simple-0.01'
>END-of-p5-XML-SAX-Simple/work/.package_done.p5-XML-SAX-Simple-0.01
>exit

Actions: View

Attachments on bug 32164: 17766