why are GOTO's not used ...

[raashid bhatt]

why are GOTO's not used they just a simple JMP instructions what's bad
about them

[Malcolm McLean]

"raashid bhatt" <ra**********@g mail.comwrote in message news:

why are GOTO's not used they just a simple JMP instructions what's bad
about them

Indeed. C has a perfectly functional goto statement, which will compile to a
basic assembler jump.

--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[Richard Heathfield]

raashid bhatt said:

why are GOTO's not used they just a simple JMP instructions what's bad
about them

goto Try

refuse to use them at all. Then wait six months. Then go and make some
goto medium-scale

Then wait six months. Then go and make some medium-scale changes to the
goto code

medium-scale changes to the code (not cosmetic, but not drastic surgery
goto either

Now try without them. Specifically, write a large program in which you
goto refuse

code (not cosmetic, but not drastic surgery either). Consider how difficult
goto this

either). Consider how easy this is, relative to the other program.
goto end

this is.
goto Now

Try them. Specifically, write a large program in which you use them freely.
goto Then

end

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[santosh]

Malcolm McLean wrote:

>
"raashid bhatt" <ra**********@g mail.comwrote in message news:

>why are GOTO's not used they just a simple JMP instructions what's
bad about them

Indeed. C has a perfectly functional goto statement, which will
compile to a basic assembler jump.

I note that you have failed to actually answer the OP's question.

To the OP:

It's not true to say that the goto is "not used". It's use is often
discouraged, but it's nevertheless used in some situations. Unlike
gets, goto *can* be used wisely, though in my experience, you need
quite some practise in programming before you can acquire this ability.
In short, goto is prone to abuse by beginners (though that's not to say
that *all* beginners abuse goto or that experienced programmers never
do so).

It's overuse tends to break up the "higher level" structure of the code
and it's flow of control making it hard to read and hard to extend. It
also throws away the intent the programmer had in coding a particular
construct which high-level statements can preserve and convey.

Just compare these two code fragments that do the same thing:

1.

for (i = 0; i < 10; i++) {
for (j = 0; j < 10; j++) {
putc('*', stdout);
}
putc('\n', stdout);
}

2.

i = 0;
outer_loop:
if (i == 10) {
goto end_loop;
}
else {
i++;
}
j = 0;
inner_loop:
putc('*', stdout);
if (j == 10) {
putc('\n', stdout);
goto outer_loop;
}
else {
j++;
goto inner_loop;
}
end_loop:
/* proceed */

You might as well program in assembler.

[Malcolm McLean]

"santosh" <sa*********@gm ail.comwrote in message

>
You might as well program in assembler.

That's actually quite a good technique.

Write the function in C, with the emphasis on getting it to work. Then
slowly replace the C control structures with ifs on a single variable, eg
if(flag) and gotos, to make it more and more assembly-like. Eventually each
line of C becomes one line of assembler. Then you can code up the assembly
function.

--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[santosh]

Malcolm McLean wrote:

>
"santosh" <sa*********@gm ail.comwrote in message

>>
You might as well program in assembler.

That's actually quite a good technique.

Write the function in C, with the emphasis on getting it to work. Then
slowly replace the C control structures with ifs on a single variable,
eg if(flag) and gotos, to make it more and more assembly-like.
Eventually each line of C becomes one line of assembler. Then you can
code up the assembly function.

Um, is there any *purpose* to such an exercise?

[Andrew Poelstra]

On 2008-08-17, santosh <sa*********@gm ail.comwrote:

Malcolm McLean wrote:

>>
"santosh" <sa*********@gm ail.comwrote in message

>>>
You might as well program in assembler.

That's actually quite a good technique.

Write the function in C, with the emphasis on getting it to work. Then
slowly replace the C control structures with ifs on a single variable,
eg if(flag) and gotos, to make it more and more assembly-like.
Eventually each line of C becomes one line of assembler. Then you can
code up the assembly function.

Um, is there any *purpose* to such an exercise?

I think the "purpose" is to write an assembler program without confusing
the hell out of yourself.

--
Andrew Poelstra ap*******@wpsof tware.com
To email me, use the above email addresss with .com set to .net

[santosh]

Andrew Poelstra wrote:

On 2008-08-17, santosh <sa*********@gm ail.comwrote:

>Malcolm McLean wrote:

>>>
"santosh" <sa*********@gm ail.comwrote in message

You might as well program in assembler.

That's actually quite a good technique.

Write the function in C, with the emphasis on getting it to work.
Then slowly replace the C control structures with ifs on a single
variable, eg if(flag) and gotos, to make it more and more
assembly-like. Eventually each line of C becomes one line of
assembler. Then you can code up the assembly function.

Um, is there any *purpose* to such an exercise?

I think the "purpose" is to write an assembler program without
confusing the hell out of yourself.

The method Malcolm explains *will* confuse me. Why try to imitate the
translation process of the C compiler while you can cut to the chase
and write in assembler to begin with?

[Andrew Poelstra]

On 2008-08-17, santosh <sa*********@gm ail.comwrote:

Andrew Poelstra wrote:

>On 2008-08-17, santosh <sa*********@gm ail.comwrote:

>>Malcolm McLean wrote:
"santosh" <sa*********@gm ail.comwrote in message
>
You might as well program in assembler.
>
That's actually quite a good technique.

Write the function in C, with the emphasis on getting it to work.
Then slowly replace the C control structures with ifs on a single
variable, eg if(flag) and gotos, to make it more and more
assembly-like. Eventually each line of C becomes one line of
assembler. Then you can code up the assembly function.

Um, is there any *purpose* to such an exercise?

I think the "purpose" is to write an assembler program without
confusing the hell out of yourself.

The method Malcolm explains *will* confuse me. Why try to imitate the
translation process of the C compiler while you can cut to the chase
and write in assembler to begin with?

C is much easier to structure - writing from assembler from the start
would obscure the business logic, making it much harder to complete.

--
Andrew Poelstra ap*******@wpsof tware.com
To email me, use the above email addresss with .com set to .net

[Keith Thompson]

"Malcolm McLean" <re*******@btin ternet.comwrite s:

"santosh" <sa*********@gm ail.comwrote in message

>>
You might as well program in assembler.

That's actually quite a good technique.

Write the function in C, with the emphasis on getting it to work.

And now you're done.

Then
slowly replace the C control structures with ifs on a single variable,
eg if(flag) and gotos, to make it more and more
assembly-like. Eventually each line of C becomes one line of
assembler. Then you can code up the assembly function.

Then measure the relative performance of your original C code
(compiled with maximum optimization) vs. the performance of the
assembly code. It's not unlikely that you'll find you've wasted your
time -- especially when you have to go through the whole exercise
again if you need the program to work on a different platform.

Your method might be a good one *if* you've confirmed (by
measurement!) that a particular chunk of code is a performance
bottleneck, that you can't correct the performance problem without
resorting to assembly language, and that it's worth the cost of the
extra effort and loss of portability.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"