Non-local goto example needed

[PascalDragon]

For the demonstrated purpose setjmp()-longjmp() should be better, because it saves/restores registers and gives a return value.

non-local-gotos are implemented using setjmp/longjmp.

I have never tried nonlocal gotos. Theoretically these could be used to jump into a loop or into a procedure, which is a horrible idea for me.

With setjmp/longjmp you can do that as well, but unlike with non-local-gotos the compiler can't forbid critical uses, because these two functions are just ordinary functions and the compiler does not know what they do.

With setjmp/longjmp you must initialize jmp_buf, which stores the location and registers and you can return and you get a return value. You can only jump back to a location, where you have been before you cannot jump to arbitrary locations.
This is very different.

Of course you can use setjmp/longjmp to jump from one function to another, that's what makes them so dangerous:

Code: Pascal  [Select][+][-]

1. program tsetjmp;
2.  
3. var
4.   buf: jmp_buf;
5.  
6. procedure Test;
7. begin
8.   Writeln('Setting jmp_buf');
9.   if setjmp(buf) <> 0 then
10.     Writeln('Jumped')
11.   else
12.     Writeln('No jump');
13.   Writeln('In Test');
14. end;
15.  
16. procedure Test2;
17. begin
18.   Writeln('And... Jump!');
19.   LongJmp(buf, 1);
20.   Writeln('This won''t be visible');
21. end;
22.  
23. begin
24.   Test;
25.   Test2;
26. end.

This will print:

Code: [Select]

C:\fpc\git>.\testoutput\tsetjmp.exe
Setting jmp_buf
No jump
In Test
And... Jump!
Jumped
In Test

Experimental code example:  Variable "pos" is the jmp_buf, which stores registers and execution point.

Code: Pascal  [Select][+][-]

1.     while True do
2.  
3.     try
4.       while (true) do
5.       begin
6.         if setjmp(pos) > 0 then    //"pos" stores registers and execution point here into jmp_buf record.
7.            writeln('Error! Please input integer number!');
8.         readln(N);
9.        ...... //code which may raise exception can modify "pos" so
10.        ......//the exception always returns to the point where it was raised.
11.       end;
12.     except
13.       on E: EInOutError do
14.       begin
15.         longjmp(pos, 1);
16.         // Writeln(E.ClassName, ': ', E.Message);
17.       end;
18.     end;

Simplifies error handling, if you have multiple "readln" lines which can raise exceptions in the code.

Your code results in a memory leak, because the exception instance won't be freed:

Code: Pascal  [Select][+][-]

1. {$mode objfpc}
2.  
3. uses
4.   SysUtils;
5.  
6. var
7.   buf: jmp_buf;
8. begin
9.   try
10.     if setjmp(buf) <> 0 then begin
11.       Writeln('Jumped');
12.       Exit;
13.     end;
14.     raise Exception.Create('Test');
15.   except
16.     on E: Exception do begin
17.       Writeln('Caught exception, jumping');
18.       longjmp(buf, 1);
19.     end;
20.   end;
21. end.

Compiled with -ghlw2 this will be the result:

Code: [Select]

C:\fpc\git>.\testoutput\texcept.exe
Caught exception, jumping
Jumped
Heap dump by heaptrc unit of C:\fpc\git\testoutput\texcept.exe
97 memory blocks allocated : 3454/3752
95 memory blocks freed     : 3390/3688
2 unfreed memory blocks : 64
True heap size : 163840 (160 used in System startup)
True free heap : 163168
Should be : 163232
Call trace for block $0000000000118A40 size 40
  $0000000100008BBB
  $000000010000E046
  $000000010000E4F5
  $00007FFECA6323DF
  $00007FFECA5E14A4
  $00007FFECA5E11F5
  $00007FFEC821CF19
  $000000010000DEFB
  $0000000100001798  main,  line 14 of fpctests/texcept.pp
  $0000000100001806  main,  line 21 of fpctests/texcept.pp
  $000000010000DBB0
  $0000000100001700
  $00007FFEC9BC7614
  $00007FFECA5E26A1
  $00007FFECA5E26A1
Call trace for block $0000000000118B40 size 24
  $0000000100008B42
  $000000010000736A
  $000000010001693A
  $0000000100001786  main,  line 14 of fpctests/texcept.pp
  $0000000100001806  main,  line 21 of fpctests/texcept.pp
  $000000010000DBB0
  $0000000100001700
  $00007FFEC9BC7614
  $00007FFECA5E26A1
  $000000010001889A
  $00000001000080BC
  $0000000100001722  main,  line 8 of fpctests/texcept.pp
  $0000000100001806  main,  line 21 of fpctests/texcept.pp
  $000000010000DBB0
  $0000000100001700
  $00007FFEC9BC7614

Line 14 is the line where the exception is raised.

Can you do this with nonlocal goto?

No, because for the above reason the compiler forbids a non-local-goto out of a control-flow statement like a try … finally- or try …except-block and thus is in fact safer than using setjmp/longjmp directly (though I would use neither for something like this).

non-local-gotos are implemented using setjmp/longjmp.

What about exceptions? They are also implemented in this way?

At least on targets that don't have their own exception handling mechanism (i386-win32, x86_64-win64, aarch64-win64 and in trunk as an option also some POSIX targets like Linux) setjmp/longjmp are used to implement it, however the compiler ensures that they're only used in a correct way (e.g. no jumping to a foreign stack frame).

[BobDog]

What about using asm?

Code: Pascal  [Select][+][-]

1. {$GOTO ON}
2.  
3. label
4. lbl,nest;
5.  
6. procedure one;
7. const f:integer=0;
8. procedure nested;
9. begin
10. writeln('HELLO');
11. asm nest: end;
12. f:=f+1;
13. writeln('nested in one ');
14. if (f=2) or (f=4) then writeln(' press return  . . .');
15. asm ret end;
16. writeln ('unseen');
17. end;
18.  
19. begin
20. writeln('Proc one start');
21. asm call nest end;
22. exit;
23. asm lbl: end;
24. writeln('Proc one at label:');
25. asm ret end;
26. writeln ('unseen');
27. end;
28.  
29.  
30. procedure two;
31. begin
32. writeln('Proc two');
33. asm call lbl end;
34. end;
35.  
36.  
37. begin
38. one;
39. two;
40. asm call nest end;
41. readln;
42.  
43. one;
44. two;
45. asm call nest end;
46. readln;
47. end.
48.  
49.  

Also for 64 bits:

Code: Pascal  [Select][+][-]

1. {$mode objfpc}
2.  {$GOTO ON}
3.  
4. uses
5.   SysUtils;
6.  label
7. lbl;
8. var
9.  started:BOOLEAN=false;
10.  
11. begin
12.   try
13. asm lbl: end;
14.    if started then begin
15.       Writeln('Jumped . . .');
16. asm ret end;
17.     end;
18.     raise Exception.Create('Test');
19.   except
20.     on E: Exception do begin
21.       Writeln('Caught exception, jumping');
22.       started:=true;
23. asm call lbl end;
24.     end;
25.   end;
26. end.
27.  

option -ghlw2 as advised previously.

[Peter H]

@Pascaldragon
Ok this causes a memory leak.
What I want to do:
I want to jump back to the point before the line which raised the exception and return an error code.
This enables me to give a helpful error message, to try again and fix the problem.
I hope, I can then do this:
(This is experimental code, which I truncated for clarity)
Anyway, should be easier if I disable exceptions and use lasterror then.....
I do not want exceptions if they do not give me a chance to try again and fix the problem...

Code: Pascal  [Select][+][-]

1.   procedure main;
2.   var
3.     i: integer;
4.     N2, N, root: int64;
5.     rest: int64;
6.     base: integer;
7.     pos: jmp_buf;
8.     error: boolean;
9.   const
10.     NL = #13#10;
11.   begin
12.     Initialize(pos);   //avoid warning
13.  
14.     while True do begin
15.     try
16.       error := False;
17.       if setjmp(pos) > 0 then writeln('Bitte Zahl eingeben');
18.       readln(N);
19.       // other code that can raise exceptions
20.       //....
21.     except
22.       on E: EInOutError do
23.         error := True;
24.       // Writeln(E.ClassName, ': ', E.Message);
25.     end;
26.     if error then
27.       longjmp(pos, 1);
28.      end;
29.   end;
30.  

This code seems to confuse the debugger, if I input an invalid integer. ;-)

[alpine]

I want to jump back to the point before the line which raised the exception and return an error code.
This enables me to give a helpful error message, to try again and fix the problem.

But why you should bother with so peculiar thing as non-local goto, shouldn't it be so much easier to write it like:

Code: Pascal  [Select][+][-]

1.   error := False;
2.   repeat
3.     try
4.       if Error then writeln('Bitte Zahl eingeben');
5.       readln(N);
6.       // other code that can raise exceptions
7.       //....
8.     except
9.       on E: EInOutError do
10.         error := True;
11.     end;
12.   until not error;

[Peter H]

It must jump over lines which already where successful executed.

I think, this works:

Code: Pascal  [Select][+][-]

1.   procedure main;
2.   var
3.     i: integer;
4.     N2, N, root: int64;
5.     rest: int64;
6.     base: integer;
7.     pos: jmp_buf;
8.     error: boolean;
9.   const
10.     NL = #13#10;
11.   begin
12.     Initialize(pos);   //avoid warning
13.     error := False;
14.     while True do
15.     try
16.       if error then //try to fix the last error
17.       begin
18.         error := False;
19.         longjmp(pos, 1);
20.       end;
21.  
22.       if setjmp(pos) > 0 then writeln('Error! Bitte Zahl eingeben');
23.       readln(N);
24.       if setjmp(pos) > 0 then writeln('Error! Input integer value 1..10!');
25.       readln(N2);
26.       if (N2<1) or (N2>10) then Raise EInOutError.Create('Range Error!');;
27.  
28.       // other code which can raise exceptions follows here
29.       // If always setjmp is used, program will jump to last error.
30.       // ..........
31.     except
32.       on E: EInOutError do
33.       begin
34.         error := True;
35.         Writeln(E.ClassName, ': ', E.Message);
36.       end;
37.     end;
38.   end;

Of course this can also be done with a state machine and without longjmp, but not so easy.

[alpine]

It must jump over lines which already where successful executed.

Then consider:

Code: Pascal  [Select][+][-]

1.   progress := 0; error = false;
2.   while True do
3.     try
4.       case progress of
5.         0:
6.           begin
7.             if error then writeln('Bitte Zahl eingeben');
8.             readln(N);
9.             Inc(progress); error := false;
10.           end;
11.         1:
12.           begin
13.             // other code that can raise exceptions
14.             //....
15.             Inc(progress); error := false;
16.           end;
17.       otherwise
18.         Break;
19.       end;
20.     except
21.       on E: EInOutError do
22.         error := True;
23.     end;
24.  

[Peter H]

Essentially case also uses a jumptable under the hood, it is a programmed jump.
I find my solution better, but this is a matter of taste.

[alpine]

Essentially case also uses a jumptable under the hood, it is a programmed jump.
I find my solution better, but this is a matter of taste.

With case you're not messing with PC,SP, or at least not directly. With longjmp you're not restoring the whole execution context, as you have seen that it can "leak". But otherwise it looks neater - at least in source.