What is if (!caller) in perl?

Question

There are some perl files, which I have to convert them to python. Reading perl concepts and understanding.

some_file.pl

use Cwd qw(realpath cwd);
realpath( $0 ) =~ /(.+)\/[^\/]+$/;
require "some_other.pl";
use warnings;
use strict;

sub sub_routine1 {
    my ($a) = @_;
    # Do something
}

sub sub_routine2 {
    my ($b, $c) = @_;
    # Do something
}

sub sub_routine3 {
    my ($c, $d, $e) = @_;
    # do something
}

if (!caller) {
    # Variable decalarations
    # Do something
}

1. In the above code, what does (!caller) mean ? How can I use that in python or any equivalent ?
2. In second line, I guess it's matching reg-ex pattern. But what does this exactly mean realpath( $0 ) =~ /(.+)\/[^\/]+$/;

Answer 1

if (!caller) ... is the modulino pattern for Perl, used in dual-use source code files (a source code file that can either be incorporated into another script or run on its own). The equivalent pattern in Python is:

if __name__ == "__main__":
    ...

Answer 2

caller is a built-in Perl function that returns information about the caller of a subroutine. perldoc -f caller or see here for more information.

caller returns undef (which is treated as false) if there is no caller -- i.e., if it's called from the top level of your script rather than from inside a subroutine. if (!caller) can be used in a Perl module to let it behave in one way if it's invoked directly, and to behave differently if it's invoked from another script or module.

Answer 3

I'd highly recommend taking a chance to read through some of Perl's documentation as the regex operators are quite confusing/unintuitive at first.

Here are some things that might help:

https://perldoc.perl.org/perlrequick.html

https://perldoc.perl.org/perlretut.html

https://perldoc.perl.org/perlop.html

https://www.tutorialspoint.com/perl/perl_subroutines.htm

When we look at the line

realpath( $0 ) =~ /(.+)\/[^\/]+$/;

'$0' contains the name of the program being run, as given to the shell. If the program was run directly through the Perl interpreter, '$0' contains the file name. The backslash can perform one of two tasks: it either takes away the special meaning of the character following it (for instance, | matches a vertical bar, it's not an alternation), or it is the start of a backslash or escape sequence. The '.' is the concatenation operator, Perl's way of combining two or more things. So this statement is simply reading in the filepath.

Taking a look at:

https://perldoc.perl.org/functions/caller.html

Caller returns the context of the current pure perl subroutine call.

And so the following

if (!caller) {
    # Variable decalarations
    # Do something
}

is handling the case for whatever reason there are no subroutines running. Subroutines in Perl have to be called before they begin running. So this probably acts as a simple null check for when the file is called.