#ifndef EXCEPTION_H
#define EXCEPTION_H

#include <setjmp.h>

#define TRY for (es->next = &(struct exception) { .next = es->next } \
, es->num = 1; es->num && !setjmp(es->next->buf) \
; es->next = es->next->next, es->num = 0)
#define CATCH(NUM) for (; es->num == (NUM); es->num = 0)
#define FINALLY for (; es->num; es->num = 0)
#define THROW(NUM) for (jmp_buf *buf = &es->next->buf \
; (es->next = es->next->next, es->num = (NUM)); longjmp(*buf, es->num))

extern struct exception {
	jmp_buf buf;
	int num;
	struct exception *next;
} *es;

#endif /* EXCEPTION_H */

#include <stddef.h>

#include "exception.h"

struct exception *es = &(struct exception) { .next = NULL };

#include <stdio.h>
#include <stdlib.h>

#include "exception.h"

enum {
	TEST1 = 1, TEST2 = 2, TEST3 = 3
};


static void
test3(void)
{
	THROW(TEST3);
}


static void
test2(void)
{
	THROW(TEST2);
}


static void
test1(void)
{
	TRY {
		test2();
	} CATCH (TEST2) {
		puts("TEST2");
		THROW(TEST1);
	} 
}


int
main(void)
{
	TRY {
		test1();
	} CATCH (TEST1) {
		puts("TEST1");
	}

	TRY {
		;
	}

	TRY {
		test3();
	} FINALLY {
		puts("Exception!");
	} 

	return EXIT_SUCCESS;
}

#define  CATCH_STACKSZ  16


/* pile globale : st est la pile, p est un pointeur sur l’élément actuel */
extern struct {
    struct {
        int      code;
        jmp_buf  env;
    } *p, st[CATCH_STACKSZ];
} catch;
/* catch.p est initialisé au 1er élément de catch.st - 1 (indique qu’on
   n’est dans aucun bloc try). */



#define  CATCH_ERROR(msg)  \
    fputs(  \
      "error: file `" #__FILE__ "`, line " #__LINE__ ", function `"  \
        #__func__ "`: "  msg  ".\n" ,  \
      stderr)


/* version non sécurisée */
#define  _try        \
    if(  ++catch.p ,  !( catch.p->code = setjmp(catch.p->env) )  )
       /* entrée dans un bloc try → on empile */

/* version sécurisée (attention les yeux) */
#define  try           \
    if(catch.p == catch.st + CATCH_STACKSZ - 1)  /* On est déjà au sommet de la pile. */  \
        CATCH_ERROR("too much nested `try` blocks (a maximum of "
          #CATCH_STACKSZ " is supported), skipping this one");  \
    else _try


/* version non sécurisée */
#define  _catch(ID)    \
    for(ID = (catch.p--)->code  ;  (catch.p+1)->code;  (catch.p+1)->code = 0)
       /* sortie d’un bloc try → on dépile */

/* version sécurisée */
#define  catch(ID)     \
    if(catch.p == catch.st + CATCH_STACKSZ - 1)  /* On est déjà au sommet de la pile. */  \
        CATCH_ERROR("skipping corresponding `catch` block");  \
    else _catch(ID)


/*  version non sécurisée */
#define  _throw(CODE)  \
    longjmp(catch.p->env, (CODE))
    
/*  version sécurisée */
#define  throw(CODE)   \
    if(catch.p == catch.st - 1) {  /* On n’est dans aucun bloc try. */  \
        CATCH_ERROR("throw not in a try block");  \
        exit(CODE);  /* Pourquoi pas ? */  \
    } else _throw(CODE);

#ifndef INCLUDED_TRYCATCH_H
#define INCLUDED_TRYCATCH_H

/* Ce header nécessite C99. */
#if !defined (__STDC_VERSION__)  ||  __STDC_VERSION__ < 199901L 
#error : USE OF “TRYCATCH.H” REQUIRES C99.
#endif

#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>



/* type : pile d’environnements `jmp_buf` (utilisée dans la macro `try`) */
struct try {
	struct try  *prev;
	jmp_buf     env;
};

/* type : informations de gestion de la pile de jmp_buf et des exceptions */
struct catch {
	struct try  *envs;    /* haut de la pile (NULL si pas dans un bloc `try`) */
	int         code;     /* code numérique de l’exception (0 si sans objet) */
};

/* globale de gestion du système d’exceptions */
extern  struct catch  catch;



/* gestion des erreurs (message d’erreur détaillé) */
#define  Throw(msg)                                                         \
	fprintf(stderr, "error [file `%s`, line %u, function `%s`]: %s.\n",        \
	  __FILE__, __LINE__, __func__, (msg))



/** TRY **/

/* Crée un élément de la pile de classe automatique (non nommé et local au bloc
   `try`), le rajoute au sommet de la pile globale, puis appelle `setjmp` pour
   définir le point de retour de `throw`.
   Dépile à la fin. On doit dépiler dans le `for` car l’élément de pile lui est
   local. Dans tous les cas, la boucle `for` ne doit pas se répéter.
   Deux cas de figure :
   − sortie normale du bloc `try` : cf la 3è partie du `for` pour dépiler, et la
     1ère condition pour ne pas recommencer le bloc (utilise le comportement en
     cours-circuit de &&) ;
   − sortie avec un `throw` : cf le ternaire de la 2ème condition, pour dépiler
     et arrêter le `for`. */

#define  try                                                                   \
	for( catch.code = 1,  catch.envs = & (struct try) { .prev = catch.envs }   \
	   ; catch.code  &&  ( setjmp(catch.envs->env)                             \
	                       ? (catch.envs = catch.envs->prev, 0)                \
	                       : 1                                  )              \
	   ; catch.code = 0,  catch.envs = catch.envs->prev                        \
	)



/** CATCH (+ catchSwitch) **/

/* Exécute le contenu du bloc s’il y a une exception (code non nul), en stockant
   son code dans la variable de type `int` passée (qui peut être une déclaration,
   auquel cas cette variable sera locale au bloc `catch`).
   Un bloc `catch` n’aura d’effet que s’il est le premier après un bloc `try`
   (remet le code d’exception à 0). */

#define  catch(VAR)                                                            \
	for(VAR = catch.code  ;  catch.code  ;  catch.code = 0)

/* Raccourci pour effectuer un `switch` sur le code de l’exception, sans nommer
   une variable pour le stocker (s’utilise comme un `switch` normal). */

#define  catchSwitch()                                                         \
	for(;  catch.code  ;  catch.code = 0)                                      \
		switch(catch.code)



/** THROW (+ rethrow) **/

/* « Lance » le code d’exception passé, qui doit être non nul. L’exécution du
   programme revient grâce à `longjmp` au dernier bloc `try` englobant. Si aucun
   bloc `try` n’englobe `throw`, quitte le programme avec le code lancé. */

#define  throw(CODE)                                                           \
	do {                                                                       \
		catch.code = (CODE);                                                   \
		if(!catch.code) {                                                      \
			Throw("throwing a null exception code");                           \
			exit(EXIT_FAILURE);                                                \
		}                                                                      \
		else if(!catch.envs) {                                                 \
			Throw("`throw` outside of a `try` block");                         \
			exit(catch.code);                                                  \
		}                                                                      \
		else                                                                   \
			longjmp(catch.envs->env, catch.code);                              \
	} while(0)

/* « Relance » l’exception qui a été capturée (possible seulement dans un bloc
   `catch`). */

#define  rethrow()                                                             \
	throw(catch.code)



#endif

#include "trycatch.h"

struct catch  catch =  {NULL, 0};

#include "trycatch.h"
#include <stdio.h>



typedef  enum {EXC_Z, EXC_NOTRY, EXC_42, EXC_DIVBYZ, EXC_ORDER}  Exception;

int division(int a, int b) {
	if(!a)
		throw(EXC_Z);        /* doit provoquer une erreur (code nul) */
	else if(a==-1)
		throw(EXC_NOTRY);    /* doit provoquer une erreur (throw sans try) */
	else if(b==42)
		throw(EXC_42);       /* exception relancée avec rethrow() */
	else if(!b)
		throw(EXC_DIVBYZ);     /* exception gérée dans le catchSwitch() */
	else if(a<b)
		throw(EXC_ORDER);      /* idem */
	return a / b;
}

int main(void) {
	int a,  b;

	while(1) {
		fputs("a, b? ", stdout);
		scanf("%i%i", &a, &b);

		try {
		
			try {
				printf("%i / %i  =  %i\n", a, b, division(a,b));
			}
			catchSwitch() {
			  case EXC_DIVBYZ:
				puts("exc: /0");     break;
			  case EXC_ORDER:
				puts("exc: a<b");    break;
			  default:    /* EXC_42 ou EXC_NOTRY */
				rethrow();          break;
			}
			
		}
		
		catch(Exception e) {
			if(e == EXC_42)
				puts("exc: 42");
			else    /* EXC_NOTRY */
				rethrow();    /* erreur : pas dans un bloc `try` */
		}
	}
}