🚀 go-pugleaf

Kiedyś na tej grupie (w 2012 roku) był przykład z C implementującymi 
wyjątki za pomocą setjmp/longjmp:
#include <setjmp.h>
#define finally else

/* Typy wyjątków */

#define DivisionByZero 1
#define MemoryAllocError 2
jmp_buf ex_buffer;
int ex_status;
#include <stdio.h>

int calc(int w)
{
          if(w%2)
          {
                  return 0;
          } else
          {
                  longjmp(ex_buffer, DivisionByZero);
          }
}

int main(int argc, char* argv[])
{
          int w = 2;
          if ((ex_status = setjmp(ex_buffer)) == 0)
          {
                  printf("Zwrócono %d\n", calc(w));
          } else if (ex_status == DivisionByZero)
          {
                  printf("Chwycono wyjątek\n");
          }
          return 0;
}

Ograniczeniem jest to, że chwyta tylko wysłane wyjątki, a nie wyjątki 
maszynowe jak błąd dzielenia czy pamięci.
A jak gcc sobie radzi?
int main (void)
{
   int n=5;
   int d=0;
   int g;
   try
   {
     g = n/d;
     throw "";
   }
   catch(...)
   {
   g=0;
   }
   return 0;
}
generuje :
.LC0:
         .string ""
main:
         push    rbp
         mov     rbp, rsp
         sub     rsp, 16
         mov     DWORD PTR [rbp-4], 5
         mov     DWORD PTR [rbp-8], 0
         mov     eax, DWORD PTR [rbp-4]
         cdq
         idiv    DWORD PTR [rbp-8]
         mov     DWORD PTR [rbp-12], eax
         mov     edi, 8
         call    __cxa_allocate_exception
         mov     QWORD PTR [rax], OFFSET FLAT:.LC0
         mov     edx, 0
         mov     esi, OFFSET FLAT:typeinfo for char const*
         mov     rdi, rax
         call    __cxa_throw
         mov     rdi, rax
         call    __cxa_begin_catch
         mov     DWORD PTR [rbp-12], 0
         call    __cxa_end_catch
         mov     eax, 0
         leave
         ret

Link do gcc.godbolt.org: https://goo.gl/0J8TUn
Tu po prostu zamiast skoków używa wywołań funkcji 
__cxa_allocate_exception,__cxa_throw,__cxa_begin_catch,__cxa_end_catch
Trzeba by się przypatrzyć ich wnętrzu.
Ale uwaga - gdy w .c nie było throw, wtedy nie ma obsługi wyjątku mimo 
dzielenia. Czyżby gcc nie potrafił obsługiwać tego typu wyjątków? Co się 
stanie, gdy jednak będzie błąd dzielenia?