longjmp vs goto

[Nimmi Srivastav]

Can someone kindly clarify the distinction between long jumps and
gotos? Why is one frowned upon and not the other? Is there really
any situation where use of longjmp becomes inevitable? A real-life
code snippet would surely help.

Regards,
Nimmi

[Richard Heathfield]

Nimmi Srivastav wrote:

Can someone kindly clarify the distinction between long jumps and
gotos?
The goto construct is a good way to make it hard to read a function, whereas
the longjmp function is a good way to make it hard to read an entire
program.
Why is one frowned upon and not the other?
Because you weren't looking whilst I was frowning at the other.
Is there really
any situation where use of longjmp becomes inevitable?
Not on my watch.
A real-life code snippet would surely help.

Help what? I already /have/ a headache.
All right, let's try to answer this intelligently. Firstly, the basic
difference between them is that longjmp lets you hop around between
functions - or rather, setjmp lets you say "HERE!" and longjmp then
teleports you there later on.

In my experience, it is generally possible, and wise, to manage without
either. Both of them *can* be used wisely, I suppose, but I find it
remarkably easy to do without them.

No doubt there will be some people here who feel differently about it.

--
Richard Heathfield : bi****@eton.pow ernet.co.uk
"Usenet is a strange place." - Dennis M Ritchie, 29 July 1999.
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html
K&R answers, C books, etc: http://users.powernet.co.uk/eton

[E. Robert Tisdale]

Nimmi Srivastav wrote:

Can someone kindly clarify the distinction
between long jumps and gotos?
They really are *not* comparable.
Why is one frowned upon and not the other?
the setjmp/longjpm functions are *not* for new or amateur programmers.
Is there really any situation
where use of longjmp becomes inevitable?
The setjmp/longjmp mechanism
is the way that C programmers "throw" exceptions.
Unfortunately, it does *not* clean-up after you.
Memory allocated from free storage after setjmp
will not be free'd.
A real-life code snippet would surely help.

Take a look at the man page:

http://www.rahul.net/cgi-bin/userbin...gjmp&section=3

The following code fragment indicates the flow of control of
the setjmp() and longjmp() combination:

/function declaration/
...
jmp_buf my_environment;
...
if (setjmp(my_envi ronment)) {
/* register variables have unpredictable values */
code after the return from longjmp
...
} else {
/* do not modify register vars in this leg of code */
this is the return from setjmp
...
}

[Derk Gwen]

ni************* @yahoo.com (Nimmi Srivastav) wrote:
# Can someone kindly clarify the distinction between long jumps and
# gotos? Why is one frowned upon and not the other? Is there really
# any situation where use of longjmp becomes inevitable? A real-life
# code snippet would surely help.

(1) You can't goto from one function to another. You can longjmp from a
function invocation anywhere upward in the protocol stack.

(2) ANS C doesn't have label variables, but jmp_bufs are variables.

In my recursive ascent parser, error recovery abandons the current parse
before recoverying and restarts from the initial state (more or less).
Rather than have initial function in the parser check on return if a
parse error occurs, I just longjmp from the error detection to the error
recovery.

--
Derk Gwen http://derkgwen.250free.com/html/index.html
I'm not even supposed to be here today.

[Christian Bau]

In article <8b************ *************@p osting.google.c om>,
ni************* @yahoo.com (Nimmi Srivastav) wrote:

Can someone kindly clarify the distinction between long jumps and
gotos? Why is one frowned upon and not the other? Is there really
any situation where use of longjmp becomes inevitable? A real-life
code snippet would surely help.

The answer is very simple: If you have to ask what is the difference
between goto and longjmp, then you shouldn't use either of them.

[xarax]

"Christian Bau" <ch***********@ cbau.freeserve. co.uk> wrote in message
news:ch******** *************** **********@slb-newsm1.svr.pol. co.uk...

In article <8b************ *************@p osting.google.c om>,
ni************* @yahoo.com (Nimmi Srivastav) wrote:

Can someone kindly clarify the distinction between long jumps and
gotos? Why is one frowned upon and not the other? Is there really
any situation where use of longjmp becomes inevitable? A real-life
code snippet would surely help.

The answer is very simple: If you have to ask what is the difference
between goto and longjmp, then you shouldn't use either of them.

He does not necessarily want to *use* them. He wants
to *understand* them. Big difference.

Knowledge is power.

[Leor Zolman]

On Fri, 30 Jan 2004 14:38:21 -0800, "E. Robert Tisdale"
<E.************ **@jpl.nasa.gov > wrote:

The setjmp/longjmp mechanism
is the way that C programmers "throw" exceptions.
Unfortunatel y, it does *not* clean-up after you.
Memory allocated from free storage after setjmp
will not be free'd.

Just to be clear, even C++ exception handling doesn't automagically
free up memory allocated from the _free store_ (using new/malloc/etc)
unless some type of smart pointer is inolved. Exception handling only
guarantees that destructors are run for automatic objects that need
them.
-leor

Leor Zolman
BD Software
le**@bdsoft.com
www.bdsoft.com -- On-Site Training in C/C++, Java, Perl & Unix
C++ users: Download BD Software's free STL Error Message
Decryptor at www.bdsoft.com/tools/stlfilt.html

[Capstar]

Richard Heathfield wrote:

Nimmi Srivastav wrote:

In my experience, it is generally possible, and wise, to manage without
either. Both of them *can* be used wisely, I suppose, but I find it
remarkably easy to do without them.
I have used it once. And I didn't know any better way of getting past
this. This was the problem. I had an application running on a VME
system, on which the host needed to communicate to about 8 VME-boards.
The addresses of these boards are set with jumpers, and the hosts has a
configuration file saying which board is at which address.
But when there was a mismatch in the confiuration file and the jumper
settings, the application would get a buserror, which causes it to crash.

This offcourse isn't the end of the world because the system wouldn't
work anyway, but because this system was for a customer it would be nice
to let the application give a proper message saying what happened and
then exit gracefully.

For this purpose I used a setjump right before accessing a board, and a
longjmp in the buserror signal handler. This way the application
wouldn't crash but exit gracefully.

But this is indeed for now the only application I used it in.

Just my two cents.

Mark

No doubt there will be some people here who feel differently about it.

--
<<Remove the del for email>>

[Richard Bos]

ni************* @yahoo.com (Nimmi Srivastav) wrote:

Can someone kindly clarify the distinction between long jumps and
gotos? Why is one frowned upon and not the other?
Both are frowned upon, but beginner programmers aren't likely to abuse
long jumps.
Is there really any situation where use of longjmp becomes inevitable?

I've only encountered one such situation: a dinky-toy compiler made a
long jump necessary.

Richard

[Markus Gyger]

ni************* @yahoo.com (Nimmi Srivastav) writes:

Can someone kindly clarify the distinction between long jumps and
gotos? Why is one frowned upon and not the other? Is there really
any situation where use of longjmp becomes inevitable? A real-life
code snippet would surely help.

A C++ to C translator usually implements exception handling using
[sig]longjmp(). You might need longjmp() to test if some hardware
is there or capable of doing certain things. An example where I
have used longjmp() was to test whether I'm running inside of
VMware or not (it's done by using an instruction that would
raise a SIGSEGV on a native x86 but not on VMware, and you need
the longjmp() to recover from the segmentation violation state).

You can usually "hide" a goto by using break or continue (in
switch or for/while) or simply create an new function and use
multiple return statements (I'm using this when there are a
lot of error checks), this is often easier to understand than
having to work with flags (depends on the application)...
Markus