If you use constant subs instead of variables for toggling debugging, Perl is smart enough to compile them out of existence so when you go into production the debugging will have no adverse performance effects.

You can observe this in action using B::Deparse:

[~] $ perl -MO=Deparse -e'sub D(){0}print"foo"if D'
sub D () {
    0;
}
'???';
-e syntax OK
[~] $ perl -MO=Deparse -e'sub D(){1}print"foo"if D'
sub D () {
    1;
}
print 'foo';
-e syntax OK
[download]

The `???' in the first example means that Perl has optimized out whatever used to be there. And you'll note the lack of a conditional in the second example, which was also optimized out. Perl is smart enough to realize that a subroutine with no parameters can be computed at compile time, and so replaces all calls to D() with its actual value (0 or 1 depending on the example). Then the peephole optimizer realizes that the print statements depend on the conditionals, and since the value of the conditionals is known, eliminates them and leaves either nothing, in the case of D() == 0, or just the bare print, in the case of D() == 1.

-dlc

my $debug = 11;
...
print STDERR "something worked: $wombat\n" if $debug > 5;
...
print STDERR "in here: too much detail", join ", ", @_, "\n" 
   if $debug > 20;
[download]

You could add something like that:

debugprint("now entering mysub ...\n", 11);
sub debugprint($$)
{
  my ($err_str, $debug_value) = @_;
  print $err_str if $debug_value >= $debug;
[download]

a

I use an approach along these lines, but break the printing out into a sub...

And I have a question to contribute:
Is there a way to tell on what line your sub was called from? So that I could include the current line number in the sub:

sub mydebug
{
  $msg = shift;
  print STDERR 'Line '. $linethatcalledme .": $msg\n";
}
[download]

I've been inactively looking for this for a while, almost to the point that I'm going to have to start looking for real =)

--Glenn

Here's a good place to look for real: caller. :)

Not only can caller tell you where your sub was called from, it can tell you where the sub that called your sub was called from, and so on all the way back to the main code.

use Log::Dispatch;

my $dispatcher = Log::Dispatch->new;

$dispatcher->add( Log::Dispatch::File->new( name => 'file1',
                                            min_level => 'debug',
                                            filename => 'logfile' ) );

$dispatcher->log( level => 'info',
                  message => 'Blah, blah' );

my $sub = sub { my %p = @_;  return reverse $p{message}; };
my $reversing_dispatcher = Log::Dispatch->new( callbacks => $sub );
[download]

--Glenn

It is said that the best debugging aid is a set of liberally sprinkled print statements and some careful logical thought.

I find it useful to give most of my larger programs a 'verbose' mode which prints out progress indication, time spent, contents of data structures and whatnot. The easiest way of doing so is to have a sub:

sub debug_info {
  print join ':', "\n*", @_;
  print "\n";
  return 1;
}
[download]

then throughout the program have lines like:

I usually make a command line option for verbosity with something like:

why not check your if $verbose value within your subroutine? That way you spend less time sprinkling "if $verbose" throughout your program.. Granted, my method is slightly less effecient, but you could change your sub to:

sub debug_info {
  return(0) unless $verbose;
  print join ':', "\n*", @_;
  print "\n";
  return 1;
}
[download]



-marius