Shell Programming and Scripting

Assuming the following code

sub foo {
dosomething {...}
else { foo }

is the number of times foo has been called kept track of internally and how could I access that count?

What do you exactly mean by "the number of times it has been called"? A subroutine may have been called 1000 times, but one after another (not recursive); or it can be like what you have shown, a series of recursive invocations that builds up a call stack.

You can always keep track of the count yourself, but with a global (package) variable (instead of "my"), so that it keeps the value during the recursion. Simple, and it's probably more elegant than another method I can think of, below.

The following only applies to recursive invocations.

Every programming language must internally keep track of the call stack for procedural calls. However, whether that is available to you is another story.

I think you can get this sort of Perl internal information with XS. But that is too hardcore, and I don't know exactly how to do it. So forget it for now.

Probably a more approachable method is to use the caller() function.

This example is inspired by your code:

Code:

#!/usr/bin/perl

sub foo {
	my $num = shift;
	if ($num == 0) {
		DB::printstack();
	} else {
		foo($num - 1);
	}
}

foo(6);

package DB;

sub printstack {
	my $i = 1;
	for (;;) {
		my ($package, $filename, $line, $subroutine) = caller($i);
		last if (!defined(scalar caller($i))); 
		print "Subroutine: $subroutine; Line: $line; Arg: ${DB::args[0]}\n";
		$i++;
	}
}

1;

Code:

Subroutine: main::foo; Line: 8; Arg: 0
Subroutine: main::foo; Line: 8; Arg: 1
Subroutine: main::foo; Line: 8; Arg: 2
Subroutine: main::foo; Line: 8; Arg: 3
Subroutine: main::foo; Line: 8; Arg: 4
Subroutine: main::foo; Line: 8; Arg: 5
Subroutine: main::foo; Line: 12; Arg: 6

So foo(6) will invoke foo(5) all the way until foo(0), so the call stack in this context should have 7 entries. On foo(0), we trigger the printstack() function to print the call stack. We go from the caller for foo(0), i.e. foo(1) all the way back to foo(6) at the file scope. If you want to get a count, you may probably just capture $subroutine for all iterations and look for the number of entries which matches "main::foo".

Is this too verbose for a count? Yes, but this has other uses (e.g. as debugging and trace execution) which can be useful though you did not mention in your question.