my $DATA;
my @keys=qw(one two three);
#        ^--bug in your script I assume

# solution 1
eval "\$DATA->{" . join('}{',@keys) . "}= 'value';";


# solution 2
my $d= 'value';
foreach (reverse @keys) {
  my $x->{$_}=$d;
  $d= $x;
}
$DATA->{$keys[0]}= $d->{$keys[0]};
[download]

Note that my solution 2 is somewhat senseless. If for example you parse some XML with 'three' and 'threex' below 'two', this simple solution won't work. But in the same sense your parser doesn't make sense to represent all the data as an array.

Usually a parser will parse an xml recursively and the hash will be constructed while descending and ascending the tree. Using a similar method as I was using in solution 2. I would suggest using XML::Twig if XML::Simple is too simple for you.

If you are doing this as a learning exercise then you should take a look at the code used in some of the XML modules in CPAN. Note that many of the XML:: modules sit on top of one of a small number of parser modules, so bearing that in mind you might start by looking at something like XML::Parser.

The next next level up are modules like XML::TreeBuilder which maps fairly closely to what you have described so far. Beyond that are modules like XML::Twig which add ways of manipulating XML as it is being parsed thus reducing the need to store large parts of the file being processed in memory.

A common theme with these modules is that they are object oriented and tend to represent interesting parts of the XML document as objects. XML documents tend to have a highly recursive structure and using OO is one good way of dealing with that.

If, on the other hand you simply need a better way of dealing with XML than using XML::Simple (which is not), then you would save about ten years of your life by using XML::Twig or one of the other CPAN XML munging offerings.

On the other hand HTML::Element has a new_from_lol method that takes nested arrayrefs to form any type of XML possible.

Along those lines, I've developed code that compiles XML structure to the nested arrayref structure and uses Data::Diver to fill in the XML content with the hash values. Here a small sample of a file representing XML:

sub lol {
    my ($self) = @_;

    my $root = $self->data;

    [
        QBXML => DIVE( $root, qw() ),
        [
            QBXMLMsgsRq => { 'onError' => 'stopOnError' } =>
              DIVE( $root, qw() ),
            [
                CustomerAddRq => DIVE( $root, qw() ),
                [
                    CustomerAdd => DIVE( $root, qw() ),
                    [ Name => DIVE( $root, qw(Name) ) ],
                    [ IsActive => DIVE( $root, qw(IsActive) ) ],
                    [
                        ParentRef => DIVE( $root, qw(ParentRef) ),
                        [ ListID => DIVE( $root, qw(ParentRef ListID) 
+) ],
                        [ FullName => DIVE( $root, qw(ParentRef FullNa
+me) ) ]
                    ],
                    [ CompanyName => DIVE( $root, qw(CompanyName) ) ],
                    [ Salutation => DIVE( $root, qw(Salutation) ) ],
                    [ FirstName => DIVE( $root, qw(FirstName) ) ],
                    [ MiddleName => DIVE( $root, qw(MiddleName) ) ],
                    [ LastName => DIVE( $root, qw(LastName) ) ],
                    [
                        BillAddress => DIVE( $root, qw(BillAddress) ),
                        [ Addr1 => DIVE( $root, qw(BillAddress Addr1) 
+) ],
                        [ Addr2 => DIVE( $root, qw(BillAddress Addr2) 
+) ],
                        [ Addr3 => DIVE( $root, qw(BillAddress Addr3) 
+) ],
                        [ Addr4 => DIVE( $root, qw(BillAddress Addr4) 
+) ],
                        [ Addr5 => DIVE( $root, qw(BillAddress Addr5) 
+) ],
                        [ City => DIVE( $root, qw(BillAddress City) ) 
+],
                        [ State => DIVE( $root, qw(BillAddress State) 
+) ],
                        [
                            PostalCode =>
                              DIVE( $root, qw(BillAddress PostalCode) 
+)
                        ],
                        [ Country => DIVE( $root, qw(BillAddress Count
+ry) ) ],
                        [ Note => DIVE( $root, qw(BillAddress Note) ) 
+]
                    ],
                    [
                        ShipAddress => DIVE( $root, qw(ShipAddress) ),
                        [ Addr1 => DIVE( $root, qw(ShipAddress Addr1) 
+) ],
                        [ Addr2 => DIVE( $root, qw(ShipAddress Addr2) 
+) ],
                        [ Addr3 => DIVE( $root, qw(ShipAddress Addr3) 
+) ],
                        [ Addr4 => DIVE( $root, qw(ShipAddress Addr4) 
+) ],
                        [ Addr5 => DIVE( $root, qw(ShipAddress Addr5) 
+) ],
                        [ City => DIVE( $root, qw(ShipAddress City) ) 
+],
                        [ State => DIVE( $root, qw(ShipAddress State) 
+) ],
                        [
                            PostalCode =>
                              DIVE( $root, qw(ShipAddress PostalCode) 
+)
                        ],
                        [ Country => DIVE( $root, qw(ShipAddress Count
+ry) ) ],
                        [ Note => DIVE( $root, qw(ShipAddress Note) ) 
+]
                    ],
                    [ Phone => DIVE( $root, qw(Phone) ) ],
                    [ AltPhone => DIVE( $root, qw(AltPhone) ) ],
                    [ Fax => DIVE( $root, qw(Fax) ) ],
                    [ Email => DIVE( $root, qw(Email) ) ],
                    [ Contact => DIVE( $root, qw(Contact) ) ],
                    [ AltContact => DIVE( $root, qw(AltContact) ) ],
...
[download]

#!/usr/bin/perl
package XMLcrude;

use strict;
use warnings;

sub new{
my $this = shift;
my $class = ref($this) || $this;
my $self={@_};
bless $self, $class;
return $self;
}

# If you do not have access to XML::Simple, and are not allowed to ins
+tall it, this can replace it in most situations.


#############################
# XML IN - suck in the XML file
#
sub XMLin{
my $self=shift;
$self->{file}=shift||return;

#load file into @file
open my $FILE, '<', $self->{file} or die "Unable to open log file [$se
+lf->{file}], system said $!";
if(<$FILE> !~ /<?xml/){die 'Not an XML file!  Header "<?xml" is missin
+g!'}
my @file=<$FILE>;
close $FILE;

my $data=join '',@file;
   $data=~s/<!--.*?-->//gs;  # Strip out comments.

my ($root,$value,@key);
foreach my $tag(split(/(<.*?>)/,$data)){
    
    #found a tag, so create a hash element for it.
    if($tag=~/<((?:[^>'"]*|(['"]).*?\1)*)>/){

        #start tag - add element depth
        if($tag!~/^<\//){
            $tag=~s/<|>//g;    # Remove brackets
            push @key,$tag;                        # <START>  Starting
+ tag, so remember this tag name.  Used to make key for hash element.

        #end tag - remove element depth
        }else{

            if(defined $value){    #record data
                my $key=\$self;                # Get reference to our 
+self. (A reference to the reference to the hash that stores our data)
                $key=\($$key->{$_}) for @key;    # Build up hash eleme
+nt key using the tags we gathered in @key
                $value=~s/\n|\t//g;                # Clean up the valu
+e.
                if(length $value){$$key= $value;}    # Assign value, i
+ncluding zeros, to hash element reference if there is data
                $value='';                        # Clear value for ne
+xt round.
            }
            $root=pop @key;                        # </END> Closing ta
+g, so lower the element depth... also, remember the very last value r
+emoved.
        }

        next;                                    # We are done process
+ing tags.
    }

    $value.=$tag;                                # Record value
}

return $self->$root};                            # XML document should
+ start with a "root" container element that holds everything.
}

1;
[download]

Programmatic access of hashes

We only deal in human access of in memory data structures :D lick the RAM chip, but watch out for the CPU heatsink ;D

Tutorials► Data Types and Variables► Data Type: Hash► references quick reference

perlref, perldsc