GOTO operator

I wrote up a patch for implementing gotos in php scripts a couple months ago
as an exercise in working with the Zend engine. I put it aside assuming
noone would actually want it, but Wez and Ilia convinced me to post it for
consideration:

Description:
http://pecl.org

Patch:
http://pecl.org/patches/opcode_goto_5.1.0.diff

Talk amongst yourselves...

Oh that's awesome... please say yes... please please please :) I've
always thought goto was a bit of a missing element in PHP since it's the
method of choice IMHO for fast and concise parsing.

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. |
`------------------------------------------------------------'

I wrote up a patch for implementing gotos in php scripts a couple months
ago as an exercise in working with the Zend engine. I put it aside
assuming noone would actually want it, but Wez and Ilia convinced me to
post it for consideration:

Big +1 from here. It will signficantly simplify my error handling code :)

If engine guru's don't have technical objections for this patch I think it
should be applied right away!

Edin

The patch looks ok to me.
One issue to be worked out is to prevent goto from jumping out of a
try..catch block.

goto is that nice tool that everyone is brainwashed to believe is
evil, instead of simply being taught how to use it properly.

+10 ;)

--Wez.

I wrote up a patch for implementing gotos in php scripts a couple months ago
as an exercise in working with the Zend engine. I put it aside assuming
noone would actually want it, but Wez and Ilia convinced me to post it for
consideration:

Description:
http://pecl.org

Patch:
http://pecl.org/patches/opcode_goto_5.1.0.diff

Talk amongst yourselves...

-Sara

Goto is an extremely useful for parsers and makes life much easier when
dealing with complex error handling situations.

+1

Ilia

I wrote up a patch for implementing gotos in php scripts a couple months
ago as an exercise in working with the Zend engine. I put it aside
assuming noone would actually want it, but Wez and Ilia convinced me to
post it for consideration:

Description:
http://pecl.org

Patch:
http://pecl.org/patches/opcode_goto_5.1.0.diff

Talk amongst yourselves...

-Sara

Hi,

I wrote up a patch for implementing gotos in php scripts a couple months ago
as an exercise in working with the Zend engine. I put it aside assuming
noone would actually want it, but Wez and Ilia convinced me to post it for
consideration:

I was really rolling on the floor when I saw this mail, because I faked
up such a patch as a joke a few days ago.

I love gotos. Try/Catch is goto for poor people ;)

+2^17,3 from me

Stefan

Goto is somewhat equivalent to 'case' combined with using 'continue' in loops.
More precisely, this 2 language constructions are the 'goto' implementation
with a different name so that Dijkstra does not get back from the grave to
punish us =D
It is true that goto is a little 'off-paradigm' in OOP and truly structured
languages, however, the point is this: sometimes continue and case produce
code that is not so clear and small at the same time as a little well used
goto. BUT goto allows non experienced or not well educated programmers to
begin writing horrible and totally unstructured code, and go further
developing bad programming habits... IMHO, would php be a more restrictive
language (strongly typed, or something alike) I would be totally and
unconditionally on for a goto addon. However, i see the bad habits and bad
code promotion as something that should be very carefully noted before
deciding whether to apply it or not.
I hope i have added some good points to help make the consideration deeper and
better =)

Regards
Leo

I wrote up a patch for implementing gotos in php scripts a couple months
ago as an exercise in working with the Zend engine. I put it aside
assuming noone would actually want it, but Wez and Ilia convinced me to
post it for consideration:

Description:
http://pecl.org

Patch:
http://pecl.org/patches/opcode_goto_5.1.0.diff

Talk amongst yourselves...

-Sara

--

Leonardo Pedretti
Axon Sistemas
Líder de Equipo Proyecto Basalto

I wrote up a patch for implementing gotos in php scripts a couple months ago
as an exercise in working with the Zend engine.
[...]

In the five or six year's I've been programming PHP, I haven't ever felt
the need to have "goto". Neither have I seen a newsgroup posting related
to it in the two years or so I followed the German PHP newsgroup,
de.comp.lang.php.

I don't think goto is really needed. People using other languages manage
to do without it, too.

So, -1.

• Timm

Personally I would never use it myself, as I know of better ways around it
which make more sense to me. But on the other hand if it would help others
then more power to yah. I think the argument of user's abusing it is bogus,
as clearly mentioned in this thread. There isn't a WTF factor, as almost
everyone knows what goto does. So frankly it boils down to this.

a.) If it can be added without affecting anything I do then great, do it.
b.) If your in the camp who is against using it (like me) then don't, but
don't tell others what they can and can't use.
c.) Newbies will be newbies no matter how much you hand hold them, so just let
them be newbies and hope they grow out of it sooner than later.

Just my 2c...

-Jeremy

I wrote up a patch for implementing gotos in php scripts a couple months
ago as an exercise in working with the Zend engine. I put it aside
assuming noone would actually want it, but Wez and Ilia convinced me to
post it for consideration:

Description:
http://pecl.org

Patch:
http://pecl.org/patches/opcode_goto_5.1.0.diff

Talk amongst yourselves...

-Sara

I wrote up a patch for implementing gotos in php scripts a couple months ago
as an exercise in working with the Zend engine. I put it aside assuming
noone would actually want it, but Wez and Ilia convinced me to post it for
consideration:

Description:
http://pecl.org

Patch:
http://pecl.org/patches/opcode_goto_5.1.0.diff

I think we should make it allow constant label names only, doing it
dynamically is just too confusing to read later on.

Derick

Is the average Joe going to write parsers in the everydays work? Probably
not. But give him the power of goto and (s)he is going to shoot him/her in
the legs, in the heart, in the head. And even not only himself because
(s)he will create a legacy code which someone else has to understand and
fix. We have extract() and we say in the docs it is not good to use it to
populate variables but people hack and workaround register_globals set to
off by just using this function. IMO PHP has enough power even without
"goto". Left aside what Dijkstra has written. goto code tends to become
spaghetti one. Sometimes I miss it when write PHP scripts (for example
jumping between 2 clauses in a switch, something which is used in
var_dump() C implementation) but then I reconsider that it is better this
way.

Parsers are just one place where GOTOs show their merit. GOTOs can be
immensely useful error handling mechanism that can save having to make dozens
of functions just to avoid code duplication. As I had mentioned earlier GOTO
can be used to eliminate stack smashes caused by recursive functions that are
the simplest solution (according to average Joe) to many problems.
IMHO just saying something can be abused does not seem like a good reason,
because that can applied to anything. Exceptions can be abused, OO can be
abused, xml can be abused, etc...

Ilia

Is the average Joe going to write parsers in the everydays work? Probably
not.
But give him the power of goto and (s)he is going to shoot him/her in the
legs,
in the heart, in the head. And even not only himself because (s)he will
create a
legacy code which someone else has to understand and fix.

function foo() { foo(); }
for($i = 0; $i < 10; $i--);
php -f {$_SERVER['PHP_SELF']};
while (!($fp = fopen('/does/not/exist', 'r')));

All oversimplistic examples obviously, but the concepts aren't unfamiliar to
those of us that actually volunteer in the trenches on usenet, irc, forums,
etc...

To quote Wez: "GOTO doesn't kill code, bad programmers do."

We have extract()
and we say in the docs it is not good to use it to populate variables but
people
hack and workaround register_globals set to off by just using this
function.

Taking away their tools will not make them code more intelligently, it'll
send them off to another language where they CAN continue making the same
mistakes. The way to breed better programmers is to point out their
mistakes and suggest how they can correct them. But not every
implementation of a particular concept is a mistake, if it were we'd have
only one CMS, only one gallery script, only one Blog, and come to that....
only one language.

IMO PHP has enough power even without "goto". Left aside what Dijkstra has
written. goto code tends to become spaghetti one.

I could just as easily state that nested code with lots of OOP does the same
thing. I'll say it agin:

"GOTO doesn't kill code, bad programmers do."

Sometimes I miss it when
write PHP scripts (for example jumping between 2 clauses in a switch,
something
which is used in var_dump() C implementation) but then I reconsider that
it is better
this way.

Often it is better. And sometimes it's not. Funny how generalizations
work.

Looks like I am -1 if that counts :)

Damn skippy it does. Everyone's oppinion counts. Whether the dicision is
made to add it or leave it out, the voices of this community will have made
an impact on that decision.

-Sara

----- Original Message -----
From: "Andrey Hristov" php@hristov.com
To: ilia@prohost.org
Cc: internals@lists.php.net
Sent: Thursday, July 29, 2004 8:00 PM
Subject: Re: [PHP-DEV] GOTO operator

--- snip ---

Is the average Joe going to write parsers in the everydays work? Probably
not.

how about:

function pseudocode()
{
$a=allocate_resource_z();
$b=allocate_resource_y();

$res=do_stuff();
if(!$res)
    goto err_out;

$c=allocate_resource_x();
$res=do_more_stuff();
if(!$res)
    goto err_out;

$d=allocate_resource_foo();
$res=do_even_more_stuff();
if(!$res)
    goto err_out;

return true;

err_out:
free_resouce($a);
free_resouce($b);
if(isset($c)) free_resouce($c);
if(isset($d)) free_resouce($c);

return false;

}

here the do_stuff()s would be trivial inline code that makes no sense to
break out, each being a few slocs. everything looks neat and it is perfectly
clear what is going on.

with no goto:

function pseudocode()
{
$a=allocate_resource_z();
$b=allocate_resource_y();

$res=do_stuff();
if(!$res)
{
    free_resource($a);
    free_resource($b);
    return false;
}

$c=allocate_resource_x();
$res=do_more_stuff();
if(!$res)
{
    free_resouce($a);
    free_resource($b);
    free_resource($c);
    return false;
}

$d=allocate_resource_foo();
$res=do_even_more_stuff();
if(!$res)
{
    free_resouce($a);
    free_resource($b);
    free_resource($c);
    free_resource($d);
    return false;
}

return true;

}

.. now imagine this isn't pseudocode, but actual code. you're doing a bunch
of stuff and the repetition becomes extremely unmanagable, especially if you
are doing miantenance later. ie, say you allocate another resource at the
beginning - add a free_resource() in one place only with the goto example,
in N places without.

before you discount the resource allocation stuff (in C this would be
primarily malloc()s), there is quite enough stuff that you can 'allocate' in
real code that isn't going to get gc'ed.

and yes, i've been missing goto dearly when doing real development. right
now, i'm emulating it by implementing allocation functions such that they
keep a list (or hashtable rather) of resources belonging to each function
and i can release them all in one line of code, but i'm still replicating
that line of code everywhere and, quite frankly, it's a kludge.

i agree with ilia - dont' castrate the language in a misguided effort to
protect the clueless. abuse of goto is best prevented by education on its
proper uses (few very specific cases).

paul

But reading the various posts here, I changed a little my opinion. I'm in
favor of a goto operator if the "scope" of its labels is limited to, say,
a
function/method only.

And that's precisely how this implementation of GOTO behaves. You can only
jump to a label within the same op array. That means:

*) No jumping between functioncs
*) No jumping into/out-of the global scope
*) No jumping from any code in one file to code in another file (even if
it's global scope on both ends)

This is (roughly speaking) the same as C's rules under which you can only
jump within a function. (Execution within a global scope doesn't really
apply).

-Sara