Programmation C source/gestion des signaux

int main(void)
 printf("----------------------------------------\n");
 printf(" Gestion des signaux\n");
 printf("----------------------------------------\n");
 Les signaux permettent une communication, assez sommaire, entre le système et un
 processus, ou entre différents processus. Un signal ne porte qu'une seule
 information: son numéro, de type int. Un processus peut s'envoyer un signal à
 lui-même. Ces signaux sont envoyés de manière asynchrone: lorsqu'un processus
 reçoit un signal, son exécution est interrompue, et une fonction spécifique, dite
 gestionnaire de signal, est appelée, avec en paramètre le numéro du signal reçu,
 pour traiter l'événement. Lorsque cette fonction se termine, le processus reprend
 là où il s'était arrêté. C'est à chaque processus de déterminer ce qu'il fait
 quand il reçoit un signal de numéro donné, en définissant un gestionnaire de
 signal pour tous les signaux qu'il le souhaite. En l'absence de précisions dans
 nos programmes, l'implémentation fournira en effet un gestionnaire de signal par
 défaut, qui le plus souvent se contentera d'arrêter le programme.
 #if 0
 #include <signal.h>
 signal() // pour définir un gestionnaire de signal
 raise() // pour envoyer un signal au processus courant
 #endif
 Le C définit ces deux fonctions, et pas plus.
 On retrouve donc signal() et raise() sur tous les sytèmes d'exploitation
 qui propose le langage C; mais pour d'autres fonctions, elles sont propres
 à tel ou tel système. Par exemple nous avons les fonctions de gestion de
 signaux, définies par la norme POSIX, pour les systèmes qui ont choisi de
 respecter la norme POSIX.
 #if 0
 void (* signal( int sig, void (*func)(int) ) )(int);
 typedef void (*handler_t)(int);
 handler_t signal(int sig, handler_t func);
 #endif
 les paramètres :
 sig numéro de signal
 func pointeur vers la fonction de gestion du signal
 pour sig : dans signal.h
 nous avons un certain nombre de signaux définit par des macros
 par exemple SIGSEGV qui indique un accès illégal à la mémoire (SEGmentation
 Violation)
 pour func : dans signal.h, nous avons
 SIG_IGN le signal sera ignoré
 SIG_DFL le gestionnaire de signal par défaut sera mis en place
 sinon bien sur il faut donner une fonction que nous avons écrite !
 retour de signal() :
 En cas d'erreur, la fonction renvoie SIG_ERR et place la variable errno à une
 valeur significative.
 Exemple :
 avec le signal SIGFPE, qui normalement est là pour indiquer une exception
 lors des calculs en virgule flottante (Floating Point Exception)
 void sig_fpe(int sig)
 // grace au paramètre sig, cette fonction pourrait traiter différents signaux
 if (sig == SIGFPE)
 puts("le signal SIGFPE a été reçu, execution de sig_fpe()");
 else
 puts("sig_fpe() : signal reçu inconnu !");
 if (signal(SIGFPE, sig_fpe) == SIG_ERR)
 puts("Le gestionnaire de signal pour SIGFPE n'a pu etre defini.");
 else
 puts("Le gestionnaire de signal pour SIGFPE a pu etre defini.");
 raise(SIGFPE);
 while(1);
 return 0;

Coréen/Grammaire/Verbes
Les verbes coréens se placent toujours en fin de phrase.
Syntaxe.
La structure de la phrase coréenne suit le principe SOV (sujet-objet-verbe). Le verbe, y compris ses suffixes, se place donc en fin de phrase. 
Dans une proposition relative, il se place en fin de proposition et juste devant le nom auquel il se rapporte.
Morphologie.
Le verbe se compose d'un radical suivi éventuellement d'un ou plusieurs affixes qui marquent les modalités du verbe (temps, respect, nuances...).
Exemple.
Soit le verbe suivant, qui peut constituer une phrase à lui tout seul :
가십니까 : « (y) allez-vous ? » (en s'adressant à une personne que l'on respecte)
Dans l'exemple canonique, 가십니까 se décompose ainsi (l'ordre des affixes est impératif) :
L'affixe de respect envers la personne dont on parle (honorificité).
Exemple : 선생님은 읽으세요 (le professeur lit)
L'affixe de respect envers la personne dont on parle est :
Les affixes de respect envers la personne à qui on parle (politesse et formalité).
Dans les verbes coréens, les affixes permettent de marquer plusieurs niveaux de respect envers l'interlocuteur. Les quatre principaux niveaux de langage sont :
Les deux premiers niveaux sont les plus utilisés.
Le langage formel ("hapsyoche/ 합쇼체").
Exemple : 저는 읽습니다 (« je lis »).
Le langage formel s'utilise notamment entre des inconnus, des collègues masculins, à la télévision et avec des clients.
Dans le langage formel, l'affixe de respect envers la personne à qui on parle est :
Le langage informel ("haeyoche/ 해요체").
Exemple : 저는 읽어요 (« je lis »).
Le langage informel s'utilise notamment entre des inconnus (surtout avec des personnes d'âge plus élevé ou égal) et plus particulièrement par les femmes, dans des situations peu formelles.
Dans le langage informel, le radical est suivi de l'affixe suivant :
Lorsque le radical se termine par une voyelle identique à la première voyelle de l'affixe, celle-ci disparaît :
Il y a également contraction lorsque le radical se termine par d'autres voyelles :
Le langage neutre ("haerache/ 해라체").
Exemple : 저는 읽다 (« je lis »).
Sur le plan de la politesse, ce niveau de langage est neutre, voire impoli. Il s'utilise avec des amis proches, des membres de la famille du même âge ou entre jeunes gens. Il est également courant dans les livres et les journaux.
Le langage familier (B"anmal/ 반말").
Exemple : 나는 읽어 (« je lis »).
Ce niveau de langage s'utilise avec des amis proches, des membres de la famille et des jeunes. Il peut être impoli s'il est employé avec un inconnu.
Cette forme se construit simplement en supprimant le marqueur de politesse 요 dans la forme du style poli informel décrit précédemment.
Nominalisation d'un verbe.
Un verbe peut être transformé en substantif en remplaçant la terminaison 다 par 기. La forme résultante peut être utilisée par exemple comme sujet ou objet d'une phrase.
Exemple : 나는 읽기를 좋아해요 (« j'aime lire »)
Forme passive.
Le passif peut être formé, pour certains verbes mais pas tous, par l'ajout d'une syllabe ou la modification de la dernière syllabe :
Le passif peut aussi être formé, pour tous les verbes transitifs, en combinant la forme en -ㅓ ou en -ㅏ du verbe avec le verbe auxiliaire 지-, qui a valeur de changement d'état.
Cette forme exprime souvent une certaine difficulté rencontrée au cours du processus, l'agent (l'auteur de l'action) jouant un rôle important, alors que la forme précédente exprime une passivité plus spontanée dans laquelle le rôle de l'agent paraît moins nécessaire.
Le verbe auxiliaire 지- peut aussi être combiné :
Conjugaison.
Langage formel.
Présent et futur.
Exemples :
Passé.
Si le radical se termine par une voyelle, il y a contraction avec la première voyelle de la terminaison temporelle, voire fusion si c'est la même voyelle.
Exemples :
Langage informel.
Présent et passé.
Le présent et le passé du langage poli informel présentent les mêmes cas de fusion de voyelles ou de contraction que le passé du langage poli formel.
Exemples :
Futur.
Exemples :
Règles spécifiques.
Conjugaison de 이다 (être).
Dans le langage poli formel :
Exemples :
Contractions de voyelles.
Lorsque le radical se termine par certaines voyelles, celles-ci se contractent avec la voyelle 어 ou 아 de la terminaison verbale.
Voir ci-dessous pour les radicaux en ㅡ.
Radical en ㅂ, ㅡ, ㄷ ou ㅎ.
Dans le langage poli informel, devant les terminaisons commençant par des voyelles 아 ou 어, la fin du radical se transforme selon les règles suivantes.
Exemple :
Exemple :
Exemple :
Exemple :
Exemple :
Modalités diverses.
Négation : ne ... pas.
La négation peut s'exprimer :
La construction avec 안 est considérée comme moins formelle que la forme en -지 않다. 
L'adverbe 못 contient une nuance d'impossibilité.
Pouvoir / ne pas pouvoir faire quelque chose.
La capacité à faire quelque chose s'exprime avec la forme du futur en (으)ㄹ, suivie de 수 et du verbe 있다.
Pour l'incapacité (« ne pas pouvoir »), il suffit de remplacer 있다 par son contraire, 없다