I suspect there is a little XY Problem going on here. However the following code builds a lookup hash that stores translations from codes to names and lists of names associated with names:

use warnings;
use strict;
use Data::Dump::Streamer;

my %lookup;
my $main;
my $action;
my $text;

while (<DATA>) {
    chomp;
    
    if (m/^Main\b/ .. m/^End\b/) {
        # Process Main/End blocks
        next if ! /Name = (\w+)/;
        $main = $1;
    } elsif (m/^Sub\b/ .. m/^End\b/) {
        # Process sub/end blocks
        $action = $1, next if /Action = Find: (\w+)/;
        $text = $1, next if /Text = (.*)/;
        next if ! /^End/ or ! defined $text;
        
        # Here if we have an End and $text is defined
        $lookup{$action} = $text if defined $action;
        
        my $key = $main;
        $key = $lookup{$key} if $key =~ /^\w\w$/;
        push @{$lookup{$key}}, $text;
        
        $action = undef;
        $text = undef;
    }
}

Dump (\%lookup);
[download]

Prints:

$HASH1 = {
           CA     => 'Canada',
           Countries
                  => [
                       'North America',
                       'Europe'
                     ],
           EU     => 'Europe',
           Europe => [ 'France' ],
           MX     => 'Mexico',
           NA     => 'North America',
           "North America"
                  => [
                       'United States',
                       'Canada',
                       'Mexico'
                     ],
           "United States"
                  => [
                       'Boston',
                       'Atlanta'
                     ],
           US     => 'United States'
         };
[download]

Thanks for the responses

I was also trying to use the recursive functions to read and print from the data file.

The code doesn't have the logic to build the tree but I was trying to get the sequence correctly.

Looking at your scripts, I think I should scrap this and look to build on what you provided.

Below is the code:-

my @arr = ( 'NA', 'EU' );
my $base = 'Countries';

process_full_list( $base, @arr );

sub process_full_list {
    
    my ($base1, @arr1 ) = @_;
   
    my $elem;  

    print "############################\n";
    print "In process full list: $base1 : @arr1\n";
    print "############################\n";
     
    foreach $elem ( @arr1 ) {
       process_next( $base1, $elem);
     }
}

sub process_next {
  
   my ( $r_base, $r_elem ) = @_;
   my ( $new_base, $new_elem, @new_arr);

   print "\tIn process next: $r_base : $r_elem\n";
    
    # The if loop is temporary. It will be replaced by a 
    # sub that will fetch the next array to process by 
    # reading from the file based on the search string.
   if ( $r_elem eq 'NA' ) {
       @new_arr = ( 'US', 'CA' );
   }
   elsif ( $r_elem eq 'EU') {
       @new_arr = ( 'FR', 'IT' );
   }
   elsif ( $r_elem eq 'US') {
       @new_arr = ( 'NY', 'LA' );
   }
   elsif ( $r_elem eq 'CA') {
       @new_arr = ( 'TO', 'VC' );
   }
  
    if( defined ( $r_elem ) && (@new_arr) ) {
      print "\tnew_base = $r_elem: new_arr=@new_arr\n";
      process_full_list( $r_elem, @new_arr );
   }
      
}
[download]

The output for the above is

###########################################
In process full list: Countries : NA EU
###########################################
        In process next: Countries : NA
        new_base = NA: new_arr=US CA
###########################################
In process full list: NA : US CA
###########################################
        In process next: NA : US
        new_base = US: new_arr=NY LA
###########################################
In process full list: US : NY LA
###########################################
        In process next: US : NY
        In process next: US : LA
        In process next: NA : CA
        new_base = CA: new_arr=TO VC
###########################################
In process full list: CA : TO VC
###########################################
        In process next: CA : TO
        In process next: CA : VC
        In process next: Countries : EU
        new_base = EU: new_arr=FR IT
###########################################
In process full list: EU : FR IT
###########################################
        In process next: EU : FR
        In process next: EU : IT
[download]

use strict;
use Data::Dumper;

my %H;
while (<DATA>) { 
    my $rootkey;
    my @elements;
    
    if (/Main/) {
        while (<DATA>) {
            $rootkey = "$1" if /^\s*Name\s*=\s*(.*)$/;
            unshift(@elements, "$1") 
                 if /^\s*(?:Action|Text)\s*=\s*(.*)$/;
            last if /---/;
        }
    }
    
    $H{$rootkey} = {@elements};
}

my %G = process(\%H, 'Countries');
print Dumper(\%G);

sub process {
    my ($href, $key) = @_;
    
    my %G;
    foreach my $k (keys %{$href->{$key}}) {
        $G{$key}{$k} = $href->{$key}{$k} =~ /^Find:\s+(.*)$/ ? 
            {process(\%H, $1)} : $href->{$key}{$k};
    }
    
    return %G;
}

__DATA__
Main
  Name = Countries
End
...

The rest of your data..
[download]

Thanks a lot for your help but I am still having trouble with the output

The output from your code is

$VAR1 = {
          'Countries' => {
               'Europe' => {
                    'EU' => {
                          'France' => ''
                          }
                },
                'North America' => {
                              'NA' => {
                                 'Mexico' => {},
                                 'United States' => {
                                       'US' => {
                                           'Atlanta' => '',
                                           'Boston' => ''
                                            }
                                        },                            
+                                 'Canada' => {}
                                 }
                              }
             }
        };
[download]

The 'find' codes such as 'EU','NA', 'US', etc. are still geting added to the data structure. I tried to modify your code without much success. I am still trying but it would be of great help, if you can help..

I posted some suggested code in your initial thread (I even tested it and it seemed to work -- it's nested down a bit, here). Now you have two places to look for answers to your one problem. Posting repeated content in different threads is a drag.

Are you staying anonymous for some particular reason? If you could manage to make up a user-id for yourself, it would be easier for you to keep track of your posts and the replies that you get. You could also use the ChatBox to draw people's attention to posts where you haven't gotten the answer you need yet.

Then there would be no need for you to keep posting the same code and the same data in multiple threads.

Sorry about all the confusion

I had updated the original link but as I didn't get any response, I thought no one will ever look at it. Hence, I created a new post with reference to the original. ...a bit of Panic...

As suggested, I have created an id for my own.

Thanks for your comments and code.. It works nicely..

Update: Using 'Tie', I was able to get the output in the order it was fed into the data structure..

use Tie::Autotie 'Tie::IxHash';
tie my %linked_dsc, 'Tie::IxHash';
[download]

some progress...

I want to try few other things by shuffling the blocks in the data file,etc..like shown below and modify the code as required.

Update 2:Atlast, I managed to achieve (script might be clumpsy though compared to your standards) what I wanted- modified the code to read and build the tree irrespective of the order in which the block appears (except for the first one) and also print the hash in the order it was read inside..

You guys are great!!! for the help, guidance and what not.. whatelse I can say!!! special thanks to graff (as I stole his code to create the structure and used that as a subroutine)

Read more... (701 Bytes)

Again.. thanks for your time and guidance