-- Erik Naggum, http://groups.google.com/group/comp.lang.lisp/msg/bb32931876...

http://kerneltrap.org/node/553

BTW, I think nobody linked the classic goto critique from Dijkstra yet: http://www.cs.utexas.edu/~EWD/transcriptions/EWD02xx/EWD215.... (or paywalled in ACM context at http://portal.acm.org/citation.cfm?id=362929.362947 )

Dijkstra was pretty specific about the cases where goto would be confusing and made a case that one should would be better off just not using it at all. His argument applies much more to gotos that can jump across procedure boudaries. Most surviving gotos (including the PHP goto) are not that unconstrained so they do represent a compromise between Dijkstra's position and the pragmatic use of goto where it actually improves the readability of code - especially when exceptions are not available for some reason.

My team has (kind of) implemented it in hardware as a way of patching ROM code in RAM. When the PC becomes equal to an address in the comefrom table, the PC is loaded with a RAM address and execution continues there.

If you have a big chunk of code that could need small tweaks, storing it in ROM and implementing a small RAM alongside it saves a lot of chip area.

I'm almost 100% sure Freescale does this on some of their 32-bit microcontrollers.

Yes, I design ICs. No, I do not work for Freescale.

Too late.

I wonder why this took so long. To this date the oversight of omitting goto from a language that otherwise seemed so geared towards obfuscation puzzled me greatly.

20 COMEFROM 50

30 but when will they include comefrom.

40 COMEFROM 10

50 I always wanted goto,

60 COMEFROM 30

70 http://en.wikipedia.org/wiki/COMEFROM

Comefrom could be usefull to implement aspect oriented semantics.

Invisible asserts are also possible for debugging purposes, that don't pollute the codebase. They also don't self-document the code but (and I might be mistaken) PHP can't just optimize some statements out so as to not have them eat cycles like compiled langs.

Both of these could sit in separate modules and be coupled in or not depending on weather one debugs or deploys.

What is the reasoning behind goto in PHP though? I know php well enough, and I can't think of a time or place I've ever said: "I really wish I had a goto here!"

    1. Break out of nested loops.
    2. Jump to cleanup code at the end of a function instead of an early return.

1. Labeled loop control 2. Exceptions

PHP has #2 and a bad form of #1. In PHP you get to say how many loops to break out of, but not the name of the loop to go to. This makes code less self-documenting and can be fragile when editing code.

Other uses of goto for which substitutes are harder to find are to to make your language a more convenient compilation target, and when interacting with other control structures not under your control. These uses are VERY rare. In a decade of professional Perl programming I have seen each used twice. None of the examples were in any code base I worked with. Two were in the Perl core, the first is that the s2p utility emits gotos to emulate branches in sed, and the second is that the original Switch.pm used a goto to break out of any loops that it happened to interact with. (That one was a computed goto! After all he didn't know how this switch might interact with other switches.)

I would be willing to use goto for nested loops in PHP, but only because PHP does not offer labeled loop control. While I like to believe that I understand when to use goto for other reasons, I doubt I'll ever encounter a serious need to do that in any language.

I think I've used that twice in 10 years, but when you need it, you need it. At the cost of uglying up one function you can clean up tens or hundreds of invocation points, each of which involves duplicate (and hard-to-factor-out without-this-trick) logic. (This is the trick to factoring it out.) I'll pay that gladly.

  1. Many other languages use catch/throw or a more sophisticated version of break.
  2. This is often done with try/finally in other languages.

Though, admittedly, I don't think I've ever looked at a piece of code I've written that was more than six months old without thinking "who the hell did this and why did they want to torture me?"

Please tell me you're joking.

Otherwise, we may as well just do: "on error resume next :-)"

The gotos are necessary because kernel work requires allocating resources. If an error is hit, the function needs to exit, but it also needs to release its resources correctly. But, these resources need to be freed upon normal completion as well. Hence, gotos.

You should probably read some of the code before saying it's bad. See, for example, the function that implements a memory map: http://miller.cs.wm.edu/lxr3.linux/http/source/mm/mmap.c?v=2...

Again, I'm not seeing any specific need.

See also: call/cc for managing control flow in a tangle of mutually recursive functions.

All of the standard 'structured programming' constructs (if, while, for, switch, etc.) are just wrappers around conditional jumps in nearly every imperative language. switch even uses labels for fuck's sake!

To assert that there is no possible good use for GOTO implies that every conceivable control flow pattern has a more clean and intuitive implementation using only the high level control structures.

When you consider the variation, from language to language, in the selection of control structures available, the conjecture seems absurd. At the very least, GOTO is a reasonable compromise when forced to use a language like C, which lacks structures for such common patterns as exceptions, among others.

What is certainly worse than using GOTO is contorting code to use high level control structures in counter-intuitive ways, or worse yet, implementing ad-hoc control mechanisms using conditional variables. For purposes of readability, an informatively labeled GOTO is greatly preferable to such obfuscation.

Fortunately, we have versatile languages like LISP and Ruby which provide a rich library of control flow abstractions and allow us to create our own using closures. For the rest of the world, let them have their GOTO.

In saying this, I take my life into my own hands, as you can now bet that I will be forced in the future to work on fixing some code written by someone that takes this new feature and runs with it.

Making the language minimalistic is never a goal of a language design unless it's a Brainfuck. If it were a goal, there would've not been three loop constructs in any modern languages.

  goto hell;

> This is not a full unrestricted goto. The target label must be within the same file and context, meaning that you cannot jump out of a function or method, nor can you jump into one.

but that doesn't quite imply that the label names don't need to be unique.

That would be quite typical for PHP, IMHO, with its global scope of top level variables (= not in a function) of old.

I guess now it will be even easier to spot bad PHP code. That's the only plus I can think of.

Those who use PHP properly don't need this, and the ones who currently write spaghetti....well, will now write even worse spaghetti! At least the good developers now have another way to spot bad code, I guess..

I wonder: would goto have a better reputation if flowcharts were used more often?

  Goto floor(10);
  window.open();
  jump();