for( @input ) {

    if( /$start/ .. /$finish/ ) {
        do_this();
    } else {
        do_that();
    }

}
[download]

The trouble with using the flip flop directly is that it's still true when /$Finish/ matches, but the OP wants $State to be false when /$Finish/ matches. To account for this, my solution says ( ( /$Start/ .. /$Finish/ ) && ! /$Finish/ ). The inner parentheses are necessary because && binds tighter than the flip flop. Without them, it means ( /$Start/ .. ( /$Finish/ && ! /$Finish/ ) ), which is true at /$Start/ and then never turns false.

You're quite right. Gotta love boundary conditions ;-)

As an alternative to the parentheses, you could replace && with and, which has low enough precedence: /$start/ .. /$finish/ and !/$finish/.

There are some modules available doing exactly that, such as Class::StateMachine or FSA::Rules. Have a look at them, they may very well inspire you.

You sir, are the middle and two ends of a fine gentleman -- and a scholar to wit. This is by far the best answer I've seen on this thread. I wish I could ++ more than once.

FWIW to the OP: Desaware offers a pretty decent introduction to state machines. It seems to do a better job explaining them than I ever do, in any case.

<–radiant.matrix–>
Ramblings and references
The Code that can be seen is not the true Code
I haven't found a problem yet that can't be solved by a well-placed trebuchet

I don't know, I think a state machine may be overkill for something with only two states ("started" and "finished" from the looks of the OP).

May be, but as the OP refered to HTML it will not end with two states and then having a look at the code of those modules can do no harm.

CountZero

A program should be light and agile, its subroutines connected like a string of pearls. The spirit and intent of the program should be retained throughout. There should be neither too little or too much, neither needless loops nor useless variables, neither lack of structure nor overwhelming rigidity." - The Tao of Programming, 4.1 - Geoffrey James

my $action = \&initial_action;
for (@input){
    if (/$Start/){
        $action = \&do_this;
    } elsif (/$Finish/){
        $action = \&do_that;
    }

    # perform your action
    $action->(); 
}
[download]

But it might depend on your idea of "simple" if that's really more simple.

for ( @Input ) {
    $State = ( ( /$Start/ .. /$Finish/ ) && ! /$Finish/ );
    ($State) ? do_this() : do_that;
}
[download]

I don't know about "shorter, more economical", but perhaps easier to maintain:

## a dispatch table in the form state => CODEref
my %operation = (
   1 => \&do_this,
   0 => \&do_that,
   9 => \&do_another_thing,
);

## a table of transitions in the form pattern => state
my @transition = (
   [ $Start  => 1 ],
   [ $Finish => 0 ],
   [ $Break  => 9 ],
);

my $State = 0;  # or whatever your initial state is.

for my $item (@Input) {

    # check transition conditions in order; if met, change state
    for my $trans (@transition) {
       next unless $item =~ /$trans->[0]/;
       $State = $trans->[1];
       last;
    }

    $operation->{$State}->();  # dereference and execute op for this S
+tate
}
[download]

That's a very simple state machine that uses a dispatch table. It's pretty easy to expand: add transitions to the @transition structure, write a sub for each operation and add it to the %operation dispatch table. You don't need to change any other code.

However, if you have a large number of states and/or transitions, using one of the state-machine modules that CountZero references above could be a better choice.

for (@input) {
  my $status = /$start/.../$finish/;
  if ( $status and $status !~ /E/ ) {
    do_this();
  } else {
    do_that();
  }
}
[download]

my $machine = {$Start => \&do_this,
               $Finish => \&do_that};

my $doit = \&do_this;
foreach my $line(@Input)
{
    my $func = $machine->{$line};
    $doit = $func if (defined $func);

    $doit();
}
[download]

note that $Start and $Finish are regexes in the OP, so you can't just use them as if they were strings (as hash keys), and you can't assume that the whole string in $line matches. (It's enough if a substring matches, unless the regexes contain anchors).

You're exactly right, of course -- I didn't fully caveat the code (hey, this guy used caveat as a verb -- can he do that?). I was just trying to provide an alternative line of thought. 8o)
--
Wade

    echo "123\n2\n3\nxxx\n1\n2\n3" | perl -lne 'if (/1/.../3/) { print
+ $_ }'
    echo "123\n2\n3\nxxx\n1\n2\n3" | perl -lne 'if (/1/../3/) { print 
+$_ }'
[download]

$html_tag = '<img src="img.png" alt="peg leg > with a kickstand">';
[download]

my $x = SOME_HTML;

while($x =~ /\G(.*?)(<(?:"[^"]*"|'[^']*'|[^'">])*>)/gcs){
   do_something_with_text($1);
   do_something_with_tag($2);
}
[download]

That's different from the original in that it doesn't do the same as the previous iteration if there is no match at all.