Maëlan

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int n, char const* const* a) {
    char wd[1024];
    if(getcwd(wd, sizeof wd / sizeof *wd) == NULL)
        puts("[error when trying to get working directory"
             " (function `getcwd`).]");
    printf("[current working directory: '%s']\n"
           "[%u argument%c passed%c]\n", wd, n, n>1?'s':0, n?':':'.');
    for(; *a; ++a)
        puts(*a);
    return EXIT_SUCCESS;
}

#include <stdarg.h>
#include <stdio.h>
#undef    printf
 int      printf(char const * ____ ,... ) {
                  va_list   (    ___    ) ;
                  va_start  ( ___, ____ ) ;
 int              va_lid                  =
                  vprintf   ( ____ ,___ ) ;
                  va_end    (    ___    ) ;
          return  va_lid                  ;
                                          }

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

char* escape (const char* s)
{
	char* u = calloc(2*strlen(s), 1);
	
	for (char* t = u; *s; s++) switch (*s) {
	  case '\n':
		strcpy(t, "\\n\"\n\""); t += 5; break;
	  case '\"':
		*t++ = '\\'; *t++ = '"'; break;
	  case '\\':
		*t++ = '\\'; *t++ = '\\'; break;
	  default:
		*t++ = *s;
	}
	
	return u;
}

int main (void)
{
	const char* s =
"#include <stdio.h>\n"
"#include <stdlib.h>\n"
"#include <string.h>\n"
"\n"
"char* escape (const char* s)\n"
"{\n"
"	char* u = calloc(2*strlen(s), 1);\n"
"	\n"
"	for (char* t = u; *s; s++) switch (*s) {\n"
"	  case '\\n':\n"
"		strcpy(t, \"\\\\n\\\"\\n\\\"\"); t += 5; break;\n"
"	  case '\\\"':\n"
"		*t++ = '\\\\'; *t++ = '\"'; break;\n"
"	  case '\\\\':\n"
"		*t++ = '\\\\'; *t++ = '\\\\'; break;\n"
"	  default:\n"
"		*t++ = *s;\n"
"	}\n"
"	\n"
"	return u;\n"
"}\n"
"\n"
"int main (void)\n"
"{\n"
"	const char* s =\n"
"\"%s\";\n"
"	char* t = escape(s);\n"
"	printf(s, t);\n"
"	free(t);\n"
"}\n"
"";
	char* t = escape(s);
	printf(s, t);
	free(t);
}

#define _(a,b) a ("_("#a" , "#b")") b
_(int puts(char*); int main (void) { puts("#define _(a,b) a (\"_(\"#a\" , \"#b\")\") b"); puts , ; return 0; })

#define _(a,b)a("_("#a","#b")")b
_(main(){puts("#define _(a,b)a(\"_(\"#a\",\"#b\")\")b");puts,;})

#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` */
        }
    }
}