my %hash =
( "Abe" => 
    { "lastname" => "Lincoln", 
      "friends" => 
        { "George" => 
            { "lastname" => "Washington", 
              "wife"     => "Martha"
            }
          "James" =>
            { "lastname" => "Madison", 
              "wife"     => "Dolly"
            }
        },
    },
  "Franklin" =>
    { "lastname" => "Roosevelt", 
      "wife" => "Eleanor"
    }
)
[download]

There are several ways to do this. The most direct is to create a sub to navigate the hash for you. The sub will take a hash ref, a value, and a list of keys. The value may itself be a hash(ref), so you can nest these and use loops and so forth.

For example:

#!/your/perl/here

use strict;
use warnings;
use Data::Dumper;

sub update_hash
{
    my ($h, $value, @keys) = @_;
    for my $key (@keys[0..$#keys-1])
    {
        $h = $h->{$key};
    }
    $h->{$keys[-1]} = $value;
}

# build up a hash from scratch

my %hash;
update_hash(\%hash, {}, 'one');
update_hash(\%hash, {}, 'one','two');
update_hash(\%hash, 123, 'one','two','three');

# don't have to start at the top
update_hash($hash{one}{two},129,'nine');
update_hash($hash{one}{two},{},'zero');
update_hash($hash{one}{two},1208,'zero','eight');

print Dumper(\%hash);

__OUTPUT__
$VAR1 = {
          'one' => {
                     'two' => {
                                'three' => 123,
                                'zero' => {
                                            'eight' => 1208
                                          },
                                'nine' => 129
                              }
                   }
        };
[download]

...
# populate your %project
readItem(\%project);
...
sub readItem {
   my ($project) = @_;

   my $sub_project = $project->{...}->{...};
   etc.
}
[download]

my %multi_level = (
      'foo'  => { 1 => 'A', 2 => 'B' },
      'bar'  => { 'C' => 'see', 'T' => 'tea' },
);

my $sub_part = $multi_level{foo}; # sub_part is a hashref, 
# also pointed at by $multi_level{foo}
print $multi_level{foo}->{1} . "\n";  # works (prints 'A')

$sub_part->{3} = 'C';
print $multi_level{foo}->{3} . "\n"; # works (prints 'C')

my $part_two = $multi_level{foo}->{1}; # part_two is a 
# scalar, a copy of the value of $multi_level{foo}->{1}, 
# namely 'A'. Changing it will not change %multi_level
[download]

my $a = 'blah';
my $b = $a;
$b = 'foo';
print "$a\n";  # prints 'blah'
print "$b\n";  # prints 'foo'
[download]

I'm not clear on what problem you're having in using a ref for initialization. Could you amend your post to include a few lines of your initialization code? It's certainly possible to do something like

my $this_level = $project{$activeProject}{components}{"Software"}{subC
+omponents}{"Database"};
$this_level->{label} = 'Test-1.01';
$this_level->{some_other_tag} = 'You passed';
[download]

$project{$activeProject}{components}{"Software"}{subComponents}{"Database"}{label} is syntactically equivalent to $project{$activeProject}->{components}->{"Software"}->{subComponents}->{"Database"}->{label}.

The $project hash's values are hashrefs. You can modify the values of those hashrefs within a subroutine.

my %h;
$h{a}{b}{c} = 'd';

print "$h{a}{b}{c}\n";
f($h{a}{b});
print "$h{a}{b}{c}\n";

sub f {
  my $x = shift;
  $x->{c} = 'e';
}
[download]

produces

d
e
[download]

$project{$activeProject}->{components}->{"Software"}->{subComponents}-
>{"Database"}->{label}
[download]

You were on track for adding elements to the hash without typing the entire structure each time. To add stuff to that final level, you can do:

$subDatabase->{label} = "whatever";
$subDatabase->{foobar} = "something else";
[download]

Since $subDatabase is a reference to the original structure, the changes will persist after you leave the sub (assuming %project is defined outside the sub's scope, as it appears.)

Note: It's always a good idea, but especially when working with complex data structures, to turn strict and warnings on, if you haven't already.

*label= \$project{$activeProject}
                 {components}
                 {Software}
                 {subComponents}
                 {Database}
                 {label} ;
[download]

You read the value using print $lable;, and assign a new value using '$label='Test-2'; .

This is a lot shorter than the OP which exhibited the full train of variables, and was coded like this:

$project{$activeProject}
        {components}
        {Software}
        {subComponents}
        {Database}
        {label}
        = 'Test-2';
[download]

$activeProject->set_label('Test-1.01');
[download]

package component;
my %sc;
sub new { bless { name => "$_[1]" }, 'component'; }
sub name { $_[0]->{name}; }
sub sc  { 
    $sc{$_[0]->name} = [] unless $sc{$_[0]->name};
    push @{$sc{$_[0]->name}}, $_[1]; 
    $_[0]{$_[1]} = new component($_[1]); 
    };
sub label:lvalue { $_[0]->{lbl}; }
sub subs { \@{$sc{$_[0]->name}}; }
1;

package project;
sub new { bless { }, 'project'; }
sub components { my @c; @c = sort keys %{$_[0]}; \@c; }
sub addcomponent {  
    $_[0]->{$_[1]} = new component( $_[1] );  
    $_[0]->{$_[1]};
}
sub show {
  my $proj = shift;
  foreach my $comp ( @{$proj->components} ){
    print "$comp\n";
    next unless $#{$proj->{$comp}->subs} > 0;

    foreach my $sc ( @{$proj->{$comp}->subs} ){
    next unless $proj->{$comp}{$sc};
        print "\t$sc\t" if $sc;
    print $proj->{$comp}{$sc}->label,"\n" 
      if $proj->{$comp}{$sc}->label;
    }
  }
}
1;

use strict;

my $proj = new project();

my $i = 0;
while( <DATA> ){
  $i++; chomp;
  next if $i == 1;
  my ($comp, $subcomp, $label ) = split /\t/, $_;
  my $sw = $proj->{$comp};
  $sw = $proj->addcomponent( $comp ) unless $sw;
  my $sc = $sw->sc($subcomp);
  $sc->label = $label;
}

$proj->show;

my $hw = join ', ', @{$proj->{Hardware}->subs};

print "Hardware subcomponents ( $hw )\n";
my $sw = $proj->{Software};
my $db = $sw->{Database};
my $label = $db->label;

print "$sw->{name} $db->{name} $label\n";


__DATA__
COMPONENT    SUBCOMPONENT    LABEL
Software    Database    Test-1.01
Software    Good Languages    Perl
Software    Sucky Languages    Java
Hardware    Monitor    19" LCD
Hardware    CPU    Pentium 2.4 Ghz
[download]