Are you sure the logic is right? You would be pushing the same @tempList onto @bigList in each iteration of the loop. I would expect it more like this:

<LOOP HERE>
{
     @tempList = <obtained in another part of the code>
     push(@bigList, @tempList);
}
[download]

Also if you push it this way, you do not get a list of lists, Perl will flatten everything into one big list. You need to push a reference to a list onto the @BigList. If you re-use @tempList, then you also need to copy the array, otherwise you overwrite previous results. So I would propose something like:

      push @BigList, [ @tempList ];
[download]

which creates a reference to a copy of @tempList.

UPDATE: To access this structure, you would say $BigList[2]->[5] to access the third small list's sixth element (counting starts at zero).

As hdb said, unless you push a reference the original list is lost and there is no way to recover. If you push a reference you don't have a flat list in @biglist though, you have a list of lists which may not be what you want. Maybe the below code will help make it clear

use strict;
use warnings;

my @source = (
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
);

my @bl1;
print "BL1:\n";
push @bl1,@$_ for @source;
print "$_\n" for @bl1;

my @bl2;
print "BL2:\n";
push @bl2,$_ for @source;
print "@$_\n" for @bl2;
[download]

Output:

BL1:
1
2
3
4
5
6
7
8
9
BL2:
1 2 3
4 5 6
7 8 9
[download]

If you want to keep @bigList unchanged then you could use another array to keep start and end positions for each list added, something like this

#!perl;
use strict;
use warnings;

my @test = ([ qw(A B C) ],[ qw(1 2 3 4)], [qw( x y )]);
my @bigList = ();
my @chunk = ();
for my $ar (@test){
  my @templist = @$ar;
  my $start = scalar @bigList;
  push @bigList,@templist;
  my $end = $#bigList;
  push @chunk,[$start,$end];
}
print "@bigList \n";

# each smaller list
for my $ar (@chunk){
  my ($start,$end) = @$ar;
  print "@bigList[$start..$end] \n";
}
[download]

You need to push a reference to the sublist onto the bigger list, taking care, as noted, that Perl does not “flatten” them.   (Data::Dumper is your best friend.)

The reason why references are needed is that, in the end, all of these data structures are one-dimensional.   If @biglist is supposed to contain, say, 5 sublists, then it will then be a list containing 5 entries, each one of which is a reference to its own separate list.

There are, as noted, several ways to build the final structure, and Data::Dumper is quite smart about printing out what it actually sees.   Create a tiny stand-alone test case to prove your logic.