Home arrow Perl Programming arrow Introduction to mod_perl (part 5): More Perl Basics

Introduction to mod_perl (part 5): More Perl Basics

In this article we continue to talk about the essential Perl basics,that you should know before starting to program for mod_perl.

TABLE OF CONTENTS:
  1. Introduction to mod_perl (part 5): More Perl Basics
  2. my() Scoped Variable in Nested Subroutines
  3. When You Cannot Get Rid of The Inner Subroutine
  4. perldoc's Rarely Known But Very Useful Options
  5. References
By: Stas Bekman
Rating: starstarstarstarstar / 5
March 12, 2003

print this article
SEARCH DEV SHED

TOOLS YOU CAN USE

advertisement

Sometimes it's very hard to understand what a warning is complainingabout. You see the source code, but you cannot understand why somespecific snippet produces that warning. The mystery often results fromthe fact that the code can be called from different places if it'slocated inside a subroutine.

Here is an example:

warnings.pl
-----------
#!/usr/bin/perl -w
use strict;
correct();
incorrect();
sub correct{
print_value("Perl");
}
sub incorrect{
print_value();
}
sub print_value{
my $var = shift;
print "My value is $var\n";
}

In the code above, print_value() prints the passed value. Subroutinecorrect() passes the value to print, but in subroutine incorrect() weforgot to pass it. When we run the script:

% ./warnings.pl

we get the warning:

Use of uninitialized value at ./warnings.pl line 16.

Perl complains about an undefined variable $var at the line thatattempts to print its value:

print "My value is $var\n";

But how do we know why it is undefined? The reason here obviously isthat the calling function didn't pass the argument. But how do we knowwho was the caller? In our example there are two possible callers, inthe general case there can be many of them, perhaps located in otherfiles.

We can use the caller() function, which tells who has called us, buteven that might not be enough: it's possible to have a longer sequenceof called subroutines, and not just two. For example, here it is subthird() which is at fault, and putting sub caller() in sub second()would not help us very much:

sub third{
second();
}
sub second{
my $var = shift;
first($var);
}
sub first{
my $var = shift;
print "Var = $var\n"
}

The solution is quite simple. What we need is a full calls stack traceto the call that triggered the warning.

The Carp module comes to our aid with its cluck() function. Let'smodify the script by adding a couple of lines. The rest of the scriptis unchanged.

warnings2.pl
-----------
#!/usr/bin/perl -w
use strict;
use Carp ();
local $SIG{__WARN__} = \&Carp::cluck;
correct();
incorrect();
sub correct{
print_value("Perl");
}
sub incorrect{
print_value();
}
sub print_value{
my $var = shift;
print "My value is $var\n";
}

Now when we execute it, we see:

Use of uninitialized value at ./warnings2.pl line 19.
main::print_value() called at ./warnings2.pl line 14
main::incorrect() called at ./warnings2.pl line 7

Take a moment to understand the calls stack trace. The deepest callsare printed first. So the second line tells us that the warning wastriggered in print_value(); the third, that print_value() wascalled by subroutine, incorrect().

script => incorrect() => print_value()

We go into incorrect() and indeed see that we forgot to pass thevariable. Of course when you write a subroutine like print_value itwould be a good idea to check the passed arguments before startingexecution. We omitted that step to contrive an easily debugged example.

Sure, you say, I could find that problem by simple inspection of thecode!

Well, you're right. But I promise you that your task would be quitecomplicated and time consuming if your code has some thousands oflines. In addition, under mod_perl, certain uses of the evaloperator and ``here documents'' are known to throw off Perl's linenumbering, so the messages reporting warnings and errors can haveincorrect line numbers. This can be easily fixed by helping compilerwith #line directive. If you put the following at the beginning ofthe line in your script:

#line 125

it will tell the compiler that the next line is number 125 forreporting needs. Of course the rest of the lines would be adapted aswell.

Getting the trace helps a lot.



 
 
>>> More Perl Programming Articles          >>> More By Stas Bekman
 

blog comments powered by Disqus
escort Bursa Bursa escort Antalya eskort
   

PERL PROGRAMMING ARTICLES

- Perl Turns 25
- Lists and Arguments in Perl
- Variables and Arguments in Perl
- Understanding Scope and Packages in Perl
- Arguments and Return Values in Perl
- Invoking Perl Subroutines and Functions
- Subroutines and Functions in Perl
- Perl Basics: Writing and Debugging Programs
- Structure and Statements in Perl
- First Steps in Perl
- Completing Regular Expression Basics
- Modifiers, Boundaries, and Regular Expressio...
- Quantifiers and Other Regular Expression Bas...
- Parsing and Regular Expression Basics
- Hash Functions

Developer Shed Affiliates

 


Dev Shed Tutorial Topics: