$_[0] ||= "anonymous";  # <<<<<<<<<<<<<<<<<<< wrong wrong wrong
[download]

sub roy {
    my( $f, $b, $modifythisREF ) = @_;
    $$modifythisREF =~ s/yoda/yoda/g;
    return;
}

roy( "", "", \$body );

...
[download]

You can see if a scalar is read-only by using Scalar::Util::readonly. (That's the same as the Util routine several other people have mentioned, but the module was renamed, and now comes with recent versions of perl.)

However, I think you API is rather poor, and changing the API would relieve the need to check for read-only parameters. In general, you should only modify your parameters when you have /very/ good reason, because it isn't what your users expect.

Instead of taking in a name, a url, and a body, and refering them soley by their entries in @_, copy them into variables in your subroutine, and return the modified body.

Not only does this make your function behave the way callers are (more likely to) expect it to work, it makes the body of your function read more clearly. I noticed you refer to your paramters in the comments as "name", $url, and $body. So, taking from your lead...

#!/usr/bin/perl -w

use strict;
use warnings;
use HTML::Entities;

sub sanitize {
    my($name, $url, $body) = @_;

    # no name?
    $name ||= "anonymous";

    # add missing protocol in $url
    if ($url && $url !~ /^\w+:/) {
        $url = "http://" . $url
    }

    # add missing protocol in link in $body
    $body =~ s{\[(.*?)\]}{
        my $x = $1;
        if ($1 !~ /^\w+:/) {
            if ($1 =~ /\@/) {
                "[mailto:$x|$x]";
            } else {
                "[http://$x]"
            }
        } else {
            "[$x]"
        }
    }gex;

    # don't let people put in html
    $body = HTML::Entities::encode($body);

    # Return modified body.
    return $body;
}

my $body = "Mail me at [bugs\@microsoft.com].";
my $url;
my $name;
$body = sanitize("", $url, $body);

print $body, "\n";
[download]

Now, the varibles that are not assigned to in the mainline of the program aren't modified. You can pass in whatever you want in $name, without worring about if it's writable, because your copy of it will be. The API of your sub is more like it's users probably expect.

If you really want to not change the API of your function, so that you don't have to modifiy the existing callers, you can, near the return line, check for not defined wantarray, that is, if your sub is being called in void context (it's return value isn't being assigned anywhere), and do a $_[2]=$body.

Yeah, I admit that the API is shitty, but I was just amusing myself with @_ aliasing when I found this error. I was the only user of this little subroutine, anyway, and it wasn't part of any library I was going to distribute or anything.

Thanks for the tip on Scalar::Util::readonly(), and thanks to everyone else for their comments.

Try/catch with eval would work but I don't really see why you need to operate on $_[0] .....

eval{$_[0] ||= 'blah'}
if ( $@ ) {
    # handle exception....
    print "blech!\n";
}
# else .....
[download]

You can trap errors with eval,

    eval { $_[0] ||= 'anonymous' };
    return if $@;
[download]

Since these errors are really from misusing the sanitize() API, perhaps it would be better to perl prototype it, to convert the error to compile-time. A prototype of (\$\$\$) would work for the way you have the function written.

There is no need, however, for you to act on variables outside the function. If you just start the sub with     my ($user, $url, $body) = @_; and write the remainder on those variables, then you are guaranteed that all three are writable and no testing is required.

Just a thought.