# 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   This is an example of what a simple config file used by the System Release
X   Tool (SRT) might look like.  The file itself doesn't do anything other
X   than serve as a moderately complex test case for t/1_XMLin.t.
X
X   If you would like to find out more about the SRT, email the author at:
X
X     grantm@web.co.nz
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