#!/usr/bin/perl 
use warnings; 
use strict; 
 
my %rules; 
 
# test data 
my $ruleKey1    = "aRule"; 
my $contents1   = "rulenumber=1"; 
my $rulenumber1 = 1; 
 
my $ruleKey2    = "bRule"; 
my $contents2   = "rulenumber=2"; 
my $rulenumber2 = 2; 
 
my $ruleKey3    = "cRule"; 
my $contents3   = "rulenumber=3"; 
my $rulenumber3 = 3; 
 
# add keys and their values to an anonymous array 
push @{ $rules{$ruleKey1} }, $contents1; 
push @{ $rules{$ruleKey1} }, $rulenumber1; 
 
push @{ $rules{$ruleKey2} }, $contents2; 
push @{ $rules{$ruleKey2} }, $rulenumber2; 
 
push @{ $rules{$ruleKey3} }, $contents3; 
push @{ $rules{$ruleKey3} }, $rulenumber3; 
 
for my $x ( sortit() ) { 
    print "$x->[0]\t$x->[1]\n"; 
} 
 
sub sortit { 
    map $_->[0], 
    sort { $a->[1] <=> $b->[1] } 
    map [ [ $_, @{ $rules{$_} }[0] ], @{ $rules{$_} }[1] ], 
    keys %rules; 
}

$rules{$ruleKey1} = [ $contents1, $rulenumber1 ];

aRule	rulenumber=1 
bRule	rulenumber=2 
cRule	rulenumber=3 
dRule	rulenumber=3

for my $x ( sortit() ) {  
    print "$x->[0]\t$x->[1]\n" unless $seen{$x->[1]}; 
    $seen{$x->[1]}++; 
}

for my $x ( sortit() ) {  
    unless ( $seen{$x->[1]} ) { 
        print "$x->[0]\t$x->[1]\n"; 
        $seen{$x->[1]}++; 
    } 
    else { 
        print STDERR "Oh noes! Duplicate: $x->[0] $x->[1]\n"; 
        die; 
    } 
}

$$sRules{$file} = [ $data, $rulenumber ];

Global symbol "%sRules" requires explicit package name at ...

#!/usr/bin/perl -w  
 
use Data::Dumper;  
use strict; 
 
my %rules; 
 
&get_rules( $path, $cConn, \%rules); 
 
while (($key, $value) = each %rules) 
{     
... 
} 
 
sub get_rules  
{	 
    my $path = shift; 
    my $cConn = shift; 
    my(%sRules) = %{( shift )}; 
  
    foreach $file ( @files ) 
	{ 
		... 
		 
		# add key and values to anonymous array ( creating an HoA ) 
		$sRules{$file} = [ $data, $rulenumber ]; 
		 
	} 
	 ... 
 
 
print "... current hash content is ... \n\n"; 
 
for my $key (keys %sRules) 
{ 
	print "$key => $sRules{$key}->[0]"; 
	print "$key => $sRules{$key}->[1]\n"; 
} 
 
# OUTPUT HERE WORKS FINE ... 
print Dumper(%sRules); 
 
&get_sorted_rules( \%sRules ); 
} # end of get_rules sub 
 
# sort the rules 
sub sort_rules 
{ 
	my(%snmRules) = %{( shift )}; 
 
print "start of the sort_rules sub!\n"; 
 
	map $_->[0], 
	sort { $a->[1] <=> $b->[1] } 
	map [ [ $_, @{ $snmRules{$_} }[0] ], @{ $snmRules{$_} }[1] ], 
	keys %snmRules; 
 
print "end of the sort_rules sub!\n"; 
} 
 
# collect sorted HoA of rules 
sub get_sorted_rules 
{ 
	my(%snRules) = %{( shift )}; 
 
	my $arrayRef;	 
	my %seen = (); 
 
	print "start of get_sorted_rules sub!\n\n"; 
	 
	# NO OUTPUT HERE ... WHY NOT? 
	print Dumper(%snRules); 
 
	for $arrayRef ( sort_rules( \%snRules )) 
	{ 
		 
        print "inside the for loop within get_sorted_rules sub!\n\n"; 
		# check for duplicate rules and print out each rule's hash array ref if NOT a duplicate 
 
		# ERROR ON NEXT LINE:  "Can't use string ("1") as an ARRAY ref while "strict refs" in use ..." 
		unless ( $seen{$arrayRef->[1]} ) 
		{ 
			print "$arrayRef->[0]\t$arrayRef->[1]\n"; 
			$seen{$arrayRef->[1]}++; 
		} 
		else 
		{ 
			die "Oh no! Duplicate rule numbers: $arrayRef->[0] $arrayRef->[1]\n"; 
		} 
	} 
	 
	# can I remove all the rulenumbers like this? 
    for my $key (keys %snRules) 
	{ 
	    # remove all of the rulenumbers here ... use delete function ...  
		delete $snRules{$key}->[1]; 
	} 
 
#	print "end of get_sorted_rules sub!\n\n"; 
}

$$sRules{$file} = [ $data, $rulenumber ];

my (%sRules) = %{ (shift) };

 
sub get_rules 
      
	my $sRules 
                         
	foreach $file ( @files ) 
    { 
                           ... 
     
                    # add key and values to anonymous array ( HoA ) 
                    $$sRules{$file} = [ $data, $rulenumber ]; 
 
	} 
	 
	&get_sorted_rules( %{$sRules} ); 
	 
} # end get_rules 
 
	# collect sorted hash of rules 
    sub get_sorted_rules 
    { 
		my( $snRules ) = shift; 
		my $arrayRef; 
		my %seen = (); 
 
		print "start of get_sorted_rules sub!\n\n"; 
 
		# ERROR NEXT LINE HERE:  "Can't use string ("abc") as a HASH ref while "strict refs" in use at " 
		for my $key (keys %{$snRules}) 
		{ 
		         print "$key => ${$snRules}{$key}->[0]"; 
		         print "$key => ${$snRules}{$key}->[1]\n"; 
		} 
		 
		# SAME ERROR NEXT LINE HERE:  "Can't use string ("abc") as a HASH ref while "strict refs" in use at " 
		for $arrayRef ( sort_rules( %{$snRules} )) 
        { 
     
			print "inside the for loop within get_sorted_rules sub!\n\n"; 
			 
            # check for duplicate rules and print out each rule's hash array ref if NOT a duplicate 
            unless ( $seen{$arrayRef->[1]} ) 
            { 
                             print "$arrayRef->[0]\t$arrayRef->[1]\n"; 
                             $seen{$arrayRef->[1]}++; 
                     } 
                     else 
                     { 
                             die "Oh no! Duplicate rule numbers: $arrayRef->[0] $arrayRef->[1]\n"; 
                     } 
             } 
     
             print "end of get_sorted_rules sub!\n\n"; 
		} 
	} 
 
	# sort the rules 
    sub sort_rules 
    { 
             my( $sbRules ) = shift; 
     
             print "start of the sort_rules sub!\n"; 
     
             map $_->[0], 
             sort { $a->[1] <=> $b->[1] } 
             map [ [ $_, @{ $$sbRules{$_} }[0] ], @{ $$sbRules{$_} }[1] ], 
             keys %{$sbRules}; 
     
             print "end of the sort_rules sub!\n"; 
    }

&get_sorted_rules( %{$sRules} );

&get_sorted_rules( $sRules );

#!/usr/bin/perl  
use warnings; 
use strict; 
use Data::Dumper; 
 
my $path  = ''; 
my $cConn = ''; 
my %rules; 
 
get_rules( $path, $cConn, \%rules ); 
 
# print Dumper %rules; 
 
sub get_rules { 
    my ( $path, $cConn, $href ) = @_; 
 
    # part that's different from the original 
    while (<DATA>) { 
        my ( $file, $data, $rulenumber ) = split; 
        $$href{$file} = [ $data, $rulenumber ]; 
    } 
 
    for my $key ( keys %{$href} ) { 
        print "$key => ${$href}{$key}->[0], "; 
        print "$key => ${$href}{$key}->[1]\n"; 
    } 
 
    get_sorted_rules($href); 
} 
 
sub get_sorted_rules { 
    my $href = shift; 
    my %seen; 
 
    for my $aref ( sort_rules($href) ) { 
        unless ( $seen{ $aref->[1] } ) { 
            print "$aref->[0]\t$aref->[1]\n"; 
            $seen{ $aref->[1] }++; 
        } 
        else { 
            print STDERR 
              "Oh no! Duplicate rule numbers: $aref->[0] $aref->[1]\n"; 
            die; 
        } 
    } 
 
    for my $key ( keys %$href ) { 
        delete $$href{$key}->[1]; 
    } 
 
    # print Dumper $href; 
} 
 
sub sort_rules { 
    my $href = shift; 
 
    map $_->[0], sort { $a->[1] <=> $b->[1] } 
    map [ [ $_, @{ $$href{$_} }[0] ], @{ $$href{$_} }[1] ], 
    keys %{$href}; 
} 
 
__DATA__ 
aRule rulenumber=1 1 
bRule rulenumber=2 2 
cRule rulenumber=3 3 
dRule rulenumber=4 4

for $arrayRef ( sort_rules( %{$snRules} )) 
	{ 
		 
print "inside the for loop within get_sorted_rules sub!\n\n"; 
		# check for duplicate rules and print out each rule's hash array ref if NOT a duplicate 
 
		unless ( $seen{$arrayRef->[1]} ) 
		{ 
			print "$arrayRef->[0]\t$arrayRef->[1]\n"; 
			$seen{$arrayRef->[1]}++; 
		} 
		else 
		{ 
		... 
             } 
	}

print "$aref->[0]\t$aref->[1]\n";

$href{$aref->[0]} = {$aref->[1]};

$seen{$arrayRef->[1]} = 1; 
$seen{$arrayRef->[1]} += 1; 
$seen{$arrayRef->[1]} = 'peekaboo';

# new global hash for sorted rules 
my %sortedRules; 
 
... 
 
unless ($seen{aref->[1]} ) 
{ 
 print "$aref->[0]\t$aref->[1]\n"; 
 my $filename = $aref->[0]; 
 my $contents = $aref->[1]; 
 
 $sortedRules{$filename} = $contents; 
.. 
}

unless ( $seen{ $aref->[1] } ) { 
    push @sorted, [ $aref->[0], $aref->[1] ]; 
    $seen{ $aref->[1] }++; 
}

for my $x ( @sorted ) { 
    print "$x->[0] $x->[1]\n"; 
}

#!/usr/bin/perl  
use warnings; 
use strict; 
use Data::Dumper; 
 
my $path  = ''; 
my $cConn = ''; 
my @sorted; 
 
get_rules( $path, $cConn ); 
 
for my $aref ( @sorted ) { 
    print "$aref->[0] $aref->[1]\n"; 
} 
 
sub get_rules { 
    my ( $path, $cConn ) = @_; 
    my %rules; 
 
    # replace this part with your own code to populate the hash 
    while (<DATA>) { 
        my ( $file, $data, $rulenumber ) = split; 
        $rules{$file} = [ $data, $rulenumber ]; 
    } 
 
    get_sorted_rules( \%rules ); 
} 
 
sub get_sorted_rules { 
    my $href = shift; 
    my %seen; 
 
    for my $aref ( sort_rules($href) ) { 
        unless ( $seen{ $aref->[1] } ) { 
            push @sorted, [ $aref->[0], $aref->[1] ]; 
            $seen{ $aref->[1] }++; 
        } 
        else { 
            print STDERR "Oh no! Duplicate rule numbers: $aref->[0] $aref->[1]\n"; 
            die; 
        } 
    } 
} 
 
sub sort_rules { 
    my $href = shift; 
    map $_->[0], sort { $a->[1] <=> $b->[1] } 
    map [ [ $_, @{ $$href{$_} }[0] ], @{ $$href{$_} }[1] ], 
    keys %{$href}; 
} 
 
__DATA__ 
dRule rulenumber=4 4 
bRule rulenumber=2 2 
cRule rulenumber=3 3 
aRule rulenumber=1 1

$rules{"cRule-test"} = [ "# cRule-test rulenumber=8\n", "8" ];