Try catch resuming - exception

Question

if i am running code
try
{
line one
line 2
line 3
.
.
.
.
}
catch(Exception x)
{
}
now if exception occurs at any line i dont know and we do some stuff in catch so that exception dose not occur again at that line now we need to goback to line from where exception occurred and execute same line how can we do that?

Answer 1

Assuming this is Java, you can't do that - once the exception is thrown, nothing in the rest of the try block will be executed. You would have to use multiple try/catch blocks to explicitly do what you want:
try {
line one
} catch (Exception x) {
fixup line one
}
try {
line 2
} catch (Exception x) {
fixup line 2
}
...etc.

Answer 2

That sort of defeats the purpose of a try catch. If you catch an exception, you should handle the error. If you want to continue where you left off, the best way would probably be to put code in a finally block. This code will always run if there is an exception or no exception is thrown.
try {
//some exception prone code
}
catch(Exception e) {
//handle exception
}
finally {
//Always runs after exception caught or if no exception thrown
}

Answer 3

You don't. If you fixed the problem, you should run the entire block again. The point of a try block is that it has everything you need to perform a certain task. An exception makes everything after that in the task impossible. If you need to clean up, say, open file descriptors, you can use a finally block; but you really need to just fix the problem and try again or die with a good error message.

Answer 4

You can stick the try/catch block inside of a loop like so:
bool done = NO;
while ( ! done ) {
try {
done = YES;
} catch {
}
}
This causes the entire block to be re-executed. If you want to resume where you left off then you need to track your state along the way:
bool done = NO;
int state = 0; // setup some constants, kStateA = 0, kStateB = 1, etc:
while ( ! done ) {
try {
switch ( state ) {
case kStateA: line 1; ++state; // fall through
case kStateB: line 2; ++state;
// etc.
}
done = YES;
} catch {
}
}
The above code, simplified to be more in line with your question looks like this (though the state-machine concept is still the underlying principle):
bool done = NO;
int lineNumber = 1;
while ( ! done ) {
try {
switch ( lineNumber ) {
case 1: line 1; ++lineNumber; // fall through
case 2: line 2; ++lineNumber; // fall through
// etc.
}
done = YES;
} catch {
}
}