Labeled Break (nothing at all whatsoever to do with GOTO)

But first, this word from our sponsor:
Group A wants anything resembling goto to burn in the fires of hell
Group B wants full non-crippled goto or nothing at all
Group C wants partial goto (non-backward jumping) or nothing at all
Groups B and C both (generally) want it called either GOTO or JUMP, not
BREAK

Since no group this size will ever come to an agreement on something this
divisive, I'd like to turn the topic to a completely different language
feature which (might) please enough people to get a rousing consensus.

Actual labeled breaks. Not the break+jump that was proposed earlier in the
guise of a break statement, but an actual straightforward, no funny-business
labeled break which does no more and no less than the current break N;
construct, but allows the use of identifier labels rather than numbers which
may change as the result of the addition or removal of break containers.

http://libssh2.org/patches/true_labeled_break.diff

Usage:

while FOO ($condition) {
/* statements /
break FOO;
/ more statements */
}

Or a stacked example:

for FOO(;;) {
while BAR (true) {
foreach BAZ ($arr as $val) {
switch Foof ($value) {
default:
do Plop {
break FOO;
} while (false);
}
}
}
}

Notes on this implementation:

• Labels can't be repeated in an ancestral line. For example, the parser
  will throw an ERROR on the following:
  while FOO(true) {
  while FOO(true) {
  break FOO;
  }
  }

• Labels can be repeated by siblings. I'm not married to this, and it
  certainly has WTF potential. This behavior is easily modified to throw an
  error. I left it permissable because there was no technical reason to
  disallow it. For example, the following is okay:
  while FOO(true) {
  break;
  }
  while FOO(true) {
  break FOO;
  }

• Labeled breaks also apply to continue; For example:
  foreach FOO($arr as $key => $val) {
  if ($key % 2) continue FOO;
  if (empty(%key)) break FOO;
  }

Hello, I represent group B (not in any way officially or anything else
that might give my words an iota of weight), but I (cough cough) WE
think that the above break system would make a terrible system for
finite state machines.

Additionally at this time I'd like to make clear that we are in support
for full uncrippled break WITHIN scope. Group A can feel free to travel
to the burning fires of hell and have a barbecue, and group C should
join us so that at least they get what they want as a subset.

As an aside, from what I've read, the multitude were in favour of
unrestricted goto. Quite a few were in favour of none at all (but not as
many as in group B) and those in favour of none at all had a large
subset that were in favour of unrestricted goto in the event that group
B should get their way :)

Cheers,
Rob.

.------------------------------------------------------------.
| InterJinn Application Framework - http://www.interjinn.com |
:------------------------------------------------------------:
| An application and templating framework for PHP. Boasting |
| a powerful, scalable system for accessing system services |
| such as forms, properties, sessions, and caches. InterJinn |
| also provides an extremely flexible architecture for |
| creating re-usable components quickly and easily. |
`------------------------------------------------------------'

Hello Sara,

nice work, clean patch, good solution - thanks! what more can one say?

best regards
marcus

p.s.: I'll have the thousands of replies on this thread on ignore :-)

Wednesday, November 30, 2005, 2:40:32 AM, you wrote:

But first, this word from our sponsor:
Group A wants anything resembling goto to burn in the fires of hell
Group B wants full non-crippled goto or nothing at all
Group C wants partial goto (non-backward jumping) or nothing at all
Groups B and C both (generally) want it called either GOTO or JUMP, not
BREAK

Since no group this size will ever come to an agreement on something this
divisive, I'd like to turn the topic to a completely different language
feature which (might) please enough people to get a rousing consensus.

Actual labeled breaks. Not the break+jump that was proposed earlier in the
guise of a break statement, but an actual straightforward, no funny-business
labeled break which does no more and no less than the current break N;
construct, but allows the use of identifier labels rather than numbers which
may change as the result of the addition or removal of break containers.

http://libssh2.org/patches/true_labeled_break.diff

Usage:

while FOO ($condition) {
/* statements /
break FOO;
/ more statements */
}

Or a stacked example:

for FOO(;;) {
while BAR (true) {
foreach BAZ ($arr as $val) {
switch Foof ($value) {
default:
do Plop {
break FOO;
} while (false);
}
}
}
}

Notes on this implementation:

• Labels can't be repeated in an ancestral line. For example, the parser
  will throw an ERROR on the following:
  while FOO(true) {
  while FOO(true) {
  break FOO;
  }
  }

• Labels can be repeated by siblings. I'm not married to this, and it
  certainly has WTF potential. This behavior is easily modified to throw an
  error. I left it permissable because there was no technical reason to
  disallow it. For example, the following is okay:
  while FOO(true) {
  break;
  }
  while FOO(true) {
  break FOO;
  }

• Labeled breaks also apply to continue; For example:
  foreach FOO($arr as $key => $val) {
  if ($key % 2) continue FOO;
  if (empty(%key)) break FOO;
  }

Best regards,
Marcus

I guess I fall into Group B, and I must say that I'd prefer either to
see goto/jump like construct or nothing at all. Be it a crippled
goto/jump or labeled breaks. So, my vote is a -1.

Ilia

Elegant solution, however, I'd prefer while(true) FOO { }.

while FOO(true) {} looks like a function call...

But first, this word from our sponsor:
Group A wants anything resembling goto to burn in the fires of hell
Group B wants full non-crippled goto or nothing at all
Group C wants partial goto (non-backward jumping) or nothing at all
Groups B and C both (generally) want it called either GOTO or JUMP, not
BREAK

Since no group this size will ever come to an agreement on something this
divisive, I'd like to turn the topic to a completely different language
feature which (might) please enough people to get a rousing consensus.

Actual labeled breaks. Not the break+jump that was proposed earlier in the
guise of a break statement, but an actual straightforward, no funny-business
labeled break which does no more and no less than the current break N;
construct, but allows the use of identifier labels rather than numbers which
may change as the result of the addition or removal of break containers.

http://libssh2.org/patches/true_labeled_break.diff

Usage:

while FOO ($condition) {
/* statements /
break FOO;
/ more statements */
}

Or a stacked example:

for FOO(;;) {
while BAR (true) {
foreach BAZ ($arr as $val) {
switch Foof ($value) {
default:
do Plop {
break FOO;
} while (false);
}
}
}
}

Notes on this implementation:

• Labels can't be repeated in an ancestral line. For example, the parser
  will throw an ERROR on the following:
  while FOO(true) {
  while FOO(true) {
  break FOO;
  }
  }

• Labels can be repeated by siblings. I'm not married to this, and it
  certainly has WTF potential. This behavior is easily modified to throw an
  error. I left it permissable because there was no technical reason to
  disallow it. For example, the following is okay:
  while FOO(true) {
  break;
  }
  while FOO(true) {
  break FOO;
  }

• Labeled breaks also apply to continue; For example:
  foreach FOO($arr as $key => $val) {
  if ($key % 2) continue FOO;
  if (empty(%key)) break FOO;
  }

Hi Sara,

This "break LABEL" construct does exactly the same as "break NUM",

Also I don't like syntax for loops that you suggested.
I prefer "LABEL: while(1) {...}" instead of while LABEL (1) {...}".

This construct has logic and make sense, but I am not sure that we should
incrise complication of PHP compiler without any serious benefits.
Readability is the only one benefit of this patch.

May be I missed something? I didn't look into patch deep.

Thanks. Dmitry.

-----Original Message-----
From: Sara Golemon [mailto:pollita@php.net]
Sent: Wednesday, November 30, 2005 4:41 AM
To: internals@lists.php.net
Subject: [PHP-DEV] Labeled Break (nothing at all whatsoever
to do with GOTO)

But first, this word from our sponsor:
Group A wants anything resembling goto to burn in the fires
of hell Group B wants full non-crippled goto or nothing at
all Group C wants partial goto (non-backward jumping) or
nothing at all Groups B and C both (generally) want it called
either GOTO or JUMP, not BREAK

Since no group this size will ever come to an agreement on
something this divisive, I'd like to turn the topic to a
completely different language feature which (might) please
enough people to get a rousing consensus.

Actual labeled breaks. Not the break+jump that was proposed
earlier in the guise of a break statement, but an actual
straightforward, no funny-business labeled break which does
no more and no less than the current break N; construct, but
allows the use of identifier labels rather than numbers which
may change as the result of the addition or removal of break
containers.

http://libssh2.org/patches/true_labeled_break.diff

Usage:

while FOO ($condition) {
/* statements /
break FOO;
/ more statements */
}

Or a stacked example:

for FOO(;;) {
while BAR (true) {
foreach BAZ ($arr as $val) {
switch Foof ($value) {
default:
do Plop {
break FOO;
} while (false);
}
}
}
}

Notes on this implementation:

• Labels can't be repeated in an ancestral line. For
  example, the parser will throw an ERROR on the following:
  while FOO(true) {
  while FOO(true) {
  break FOO;
  }
  }

• Labels can be repeated by siblings. I'm not married to
  this, and it certainly has WTF potential. This behavior is
  easily modified to throw an error. I left it permissable
  because there was no technical reason to disallow it. For
  example, the following is okay: while FOO(true) {
  break;
  }
  while FOO(true) {
  break FOO;
  }

• Labeled breaks also apply to continue; For example:
  foreach FOO($arr as $key => $val) {
  if ($key % 2) continue FOO;
  if (empty(%key)) break FOO;
  }

 I don't care what kind of GOTO I get as long as I get one.
 Right now I only see need for the forward jumping version,
 but I don't mind if you could jump backwards too. :)

 And I also want VETO on each and every bug report about it. :)
 If anyone dares to report a bug with goto in it -> automatic bogus.

 We make it work for the simple usage it's meant for and if someone
 uses it wrong, too bad. :)

 And the labeled breaks you suggest now can burn in hell!

 --Jani

But first, this word from our sponsor:
Group A wants anything resembling goto to burn in the fires of hell
Group B wants full non-crippled goto or nothing at all
Group C wants partial goto (non-backward jumping) or nothing at all
Groups B and C both (generally) want it called either GOTO or JUMP, not
BREAK

Since no group this size will ever come to an agreement on something this
divisive, I'd like to turn the topic to a completely different language
feature which (might) please enough people to get a rousing consensus.

Actual labeled breaks. Not the break+jump that was proposed earlier in the
guise of a break statement, but an actual straightforward, no funny-business
labeled break which does no more and no less than the current break N;
construct, but allows the use of identifier labels rather than numbers which
may change as the result of the addition or removal of break containers.

http://libssh2.org/patches/true_labeled_break.diff

Usage:

while FOO ($condition) {
/* statements /
break FOO;
/ more statements */
}

Or a stacked example:

for FOO(;;) {
while BAR (true) {
foreach BAZ ($arr as $val) {
switch Foof ($value) {
default:
do Plop {
break FOO;
} while (false);
}
}
}
}

Notes on this implementation:

• Labels can't be repeated in an ancestral line. For example, the parser
  will throw an ERROR on the following:
  while FOO(true) {
  while FOO(true) {
  break FOO;
  }
  }

• Labels can be repeated by siblings. I'm not married to this, and it
  certainly has WTF potential. This behavior is easily modified to throw an
  error. I left it permissable because there was no technical reason to
  disallow it. For example, the following is okay:
  while FOO(true) {
  break;
  }
  while FOO(true) {
  break FOO;
  }

• Labeled breaks also apply to continue; For example:
  foreach FOO($arr as $key => $val) {
  if ($key % 2) continue FOO;
  if (empty(%key)) break FOO;
  }

--
Give me your money at @ http://pecl.php.net/wishlist.php/sniper
Donating money may make me happier and friendlier for a limited period!
Death to all 4 letter abbreviations starting with P!

Sara++ :)

Although I prefer BAR:while (This would go better with goto if someone
would want to implement that some day.) I'd settle for while BAR since I
don't care about goto anyway.

So:

foreach BAZ ($arr as $val) +1

BAZ: foreach ($arr as $val) +2

foreach as BAZ ($arr as $val) -2 ('as' can be a bit confusing here)

Sara Golemon wrote:

But first, this word from our sponsor:
Group A wants anything resembling goto to burn in the fires of hell
Group B wants full non-crippled goto or nothing at all
Group C wants partial goto (non-backward jumping) or nothing at all
Groups B and C both (generally) want it called either GOTO or JUMP, not
BREAK

Since no group this size will ever come to an agreement on something this
divisive, I'd like to turn the topic to a completely different language
feature which (might) please enough people to get a rousing consensus.

Actual labeled breaks. Not the break+jump that was proposed earlier in the
guise of a break statement, but an actual straightforward, no funny-business
labeled break which does no more and no less than the current break N;
construct, but allows the use of identifier labels rather than numbers which
may change as the result of the addition or removal of break containers.

http://libssh2.org/patches/true_labeled_break.diff

Usage:

while FOO ($condition) {
/* statements /
break FOO;
/ more statements */
}

Or a stacked example:

for FOO(;;) {
while BAR (true) {
foreach BAZ ($arr as $val) {
switch Foof ($value) {
default:
do Plop {
break FOO;
} while (false);
}
}
}
}

Notes on this implementation:

• Labels can't be repeated in an ancestral line. For example, the parser
  will throw an ERROR on the following:
  while FOO(true) {
  while FOO(true) {
  break FOO;
  }
  }

• Labels can be repeated by siblings. I'm not married to this, and it
  certainly has WTF potential. This behavior is easily modified to throw an
  error. I left it permissable because there was no technical reason to
  disallow it. For example, the following is okay:
  while FOO(true) {
  break;
  }
  while FOO(true) {
  break FOO;
  }

• Labeled breaks also apply to continue; For example:
  foreach FOO($arr as $key => $val) {
  if ($key % 2) continue FOO;
  if (empty(%key)) break FOO;
  }

SG>>Actual labeled breaks. Not the break+jump that was proposed earlier in the

I think the idea is OK, though I don't like a syntax. There is a standard
for/while syntax which is used by a lot of procedural languages, and I see
no reason to break it. I see nothing wrong with using FOO: for label.

SG>>* Labels can be repeated by siblings. I'm not married to this, and it

I don't think this is really needed, though it's doable and has some logic
in it (after all, once the labelled block ends, the label is not longer
existing).

SG>>* Labeled breaks also apply to continue; For example:

yes, I think it's a good way to do it.

--
Stanislav Malyshev, Zend Products Engineer
stas@zend.com http://www.zend.com/ +972-3-6139665 ext.115