It can be done with goto, but it's a very, very bad idea. You probably need to rethink your design, but I couldn't say how without more details, so I leave the rest to you.

Update: After some CB chatter, some thought saying "very, very bad idea" was too strong without more explaination. However, I don't think I could do better than the classic Go To Statement Considered Harmful (external link).

One method is to make the "main" part of your code into a subroutine itself such that to start at the beginning again, you simply call that routine. I find your request quite bizarre though. Why would you want to do this?

One method is to make the "main" part of your code into a subroutine itself such that to start at the beginning again, you simply call that routine.

This will lead to memory exhaustion under some circumstances.

Question: is tail-recursion possible in Perl?

It could lead to memory exhaustion. But then there's always goto &main; (or more likely @_=(); goto &main;). This form of goto isn't quite as evil as goto LABEL or goto EXPR.

duff

P.S. Of course tail-recursion is possible, though not always desirable :)

My first comment is that the way you are asking this question leaves a ton of room for interpretation.

If your "subroutne" is in a seperate .pl file how are you calling it? For sake of discussion I will assume you are doing something like:

#!/usr/bin/perl -w 
use CGI qw/ fatalsToBrowser/; # don't do this in production
use strict;
require "myfile.pl";

&foo(); # &foo is defined in myfile.pl
[download]

.
.
. #much handwaving

exec($0);
.
.
.
[download]

Otherwise it gets slightly trickier. Check out the CGI.pm documentation and look at the redirect method. Yould do something like:

:
:
# NOTE: $q was defined elsewhere as my $q=new CGI;
print $q->redirect("http://my.site.tld/cgi-bin/foo.cgi?...")
:
:
:
[download]

exec $0;
[download]

Is one way. But its in the same class as goto, and like it is probably not a good idea on the whole. You should probably redesign your code so that this isnt needed. Perl has a whole host of looping constructs that can be used for this type of thing. Please have a review of perlsyn for more details on looping structures.

It seems to be rather a Bad Idea to me. For example, if you are just making a blind jump back to the beginning, how are you going to ensure you don't wind up back in the same subroutine and loop forever. Global variables? <shudder>

Anyway, maybe you could tell us a little more about what you are trying to accomplish, so we can help you find a Better Way.

Show us your code and explain the problem you are having. That will be more effective than asking us how to implement the solution you have in mind. Without the code, we have to guess anyway.

-sauoq
"My two cents aren't worth a dime.";

Like most of the comments above, I don't know exactly what you are trying to accomplish by doing this. But since you mention it is part of a CGI script, I am tempted to believe you are handling a POSTed form and after checking the parameters you would like to redisplay the original form with some error messages. But your program design is such that you need to start your program over to display the form again.

If this is the case, then I would suggest you look at some tools that help organize your code in a much more comprehensive way. Particularly have a look at the CGI::Application module. This lets you divide your CGI program up into "run modes", and it makes it trivial to jump from one "run mode" to another.

I would paste in an example, but the docs have lots of examples, and you can do a Super Search here at PerlMonks and find tonnes of help on using CGI::Application.

Good Luck

- Cees

That said, here's the simplest form I could come up with that has a prayer of maintaining decent lexical scoping:

MAIN: {
    # All of your code goes here...
    if ( $bad_scenario ) { redo MAIN; };
}
[download]

That's pretty simple, but you have to also worry about cleanup and housekeeping. If you need the ability to reset everything as a last ditch effort to restore your script to its original runstate, you might try this:

my $bad = 0;
MAIN: {
    # Main code section.
    print "Main block\n";
    $bad = 1;
    next MAIN if $bad;
    last MAIN # This must be the last line of the main
              # block to execute.
} continue {
    # Close open filehandles, reset globals, etc.
    print "Continue block\n";
    if ( $bad ) {$bad=0; redo MAIN;};
[download]

It jumps around a bit, and isn't clean, but if done right, it could work.

I have a feeling you're taking a convoluted route to something that, with a different approach, can be handled by a loop, by exception handling, or by some other conventional programming methodology.

As everyone else says, show us your code, and explain what you're trying to achieve, rather than how you're trying to implement it.