From the Carp.pm source

# The $CarpLevel variable can be set to "strip off" extra caller level
+s for
# those times when Carp calls are buried inside other functions.
[download]

E.g

sub subGit{ carp 'Outta here'; }
sub Git{ subGit() }

$Carp::CarpLevel = 0;
print Git;
Outta here
        main::subGit() called at (eval 5) line 1
        main::Git() called at (eval 12) line 1
        eval 'print Git

;' called at C:\test\p1.pl line 9
1

$Carp::CarpLevel = 1;
print Git;
Outta here
        main::Git() called at (eval 14) line 1
        eval 'print Git

;' called at C:\test\p1.pl line 9
1

$Carp::CarpLevel = 2;
print Git;
Outta here
        eval 'print Git

;' called at C:\test\p1.pl line 9
1
[download]

use Carp;
use Sub::Uplevel;

sub foo { git() }
sub git { uplevel 2, \&implementation }
sub implementation { croak "and so it ends" }

foo();

__output__
and so it ends at pmsopw_256988.pl line 4
    main::foo() called at pmsopw_256988.pl line 8
[download]

_________
broquaint

Thanks, this seems to do what I want:

#!/usr/bin/perl
use Carp qw(croak);

sub imp { croak shift(), ": oops" }

sub git { local $Carp::CarpLevel = 2; imp @_; }

git "hello";
[download]

Gives:

perl -w ./git.pl
hello: oops at ./git.pl line 8
[download]

Sub::Uplevel doesn't work because I don't have it installed on my system. I also want to avoid relying on code which won't work in the old versions of perl some web sites still have installed. Is it core on recent versions or is it CPAN?

My main other worry is that $Carp::CarpLevel isn't documented in the Carp manpage, and thus possibly may stop working without warning. I'll have to suck it and see, I spoze.

I thought of rethrowing, but I want the imp routine to be as straightforward to use as possible (it's a constructor implementation, meant to make writing constructors easier, a la my draft documentation:

A generalised constructor for hash- and array-based classes. Given an array defining the arguments to the constructor of the form:

  @CHECKS = 
  (
      arg1 => undef, # a mandatory but unchecked argument
      arg2 => 'mumble', # an optional scalar argument, with the defaul
+t
      arg3 => \&check_arg3, # a checked argument.
  );
[download]

-where check_arg3 should expect the object being constructed as its first argument, and the named arguments supplied to the constructor supplied in a hashref as the second argument.

(Using an array @CHECKS instead of a hash %CHECKS allows the order of argument processing to be specified.)

This then allows a constructor to be written in the client class as

  sub new { ClassUtils::construct {}, \@CHECKS, @_ }
[download]

(to construct a hash based class), or:

  sub new { ClassUtils::construct [], \@CHECKS, @_ }
[download]

(to construct an array based class).

The resulting class can be constructed like this:

  $OBJ = $CLASS->new(arg1 => 1,
                     arg2 => 'git',
                     arg3 => $X);
[download]

Any other arguments supplied over and above those defined in %CHECKS are ignored.

Subclasses' constructors can be defined like this:

  sub new { ClassUtils::construct SUPER::new(@_), \%CHECKS, @_ }
[download]

The superclass's constructor is called first, and the resulting object passed to ClassUtils::construct, both informing it which type of object to build, and giving it a partially constructed object to add to. ClassUtils::construct gets the name of the class to bless the objects into from its third argument, so the object will be reblessed into the appropriate class.

Ta, and ta ta

Probably not exactly what you want... but you could rethrow the error:

sub git {
    eval { implementation @_ };
    carp $@ if $@;
}
[download]

Update: BrowserUK's advice seems to be more helpful.