\chapter{Le langage C} \label{C}\index{C} Un chapitre un peu particulier, puisque c'est le début d'une initiation au langage C pour les non-codeurs qui souhaitent rentrer dans le sujet à la dure. Certaines des explications qui vont suivre ne sont pas très rigoureuses, mais montrent bien les principes généraux et les erreurs classiques. La futilité des exemples est assumée. Les détails nécessaires seront présentés dans la suite. % ========================================================= \section{Hello World} Hop, on y va... Le tout début de la vie d'un programme écrit en C est l'appel par le \textsl{runtime}\footnote{\texttt{crt0.s}} d'une fonction nommée \texttt{main} qui recevra deux paramètres\footnote{% En fait trois, mais restons simple.} dont l'utilisation est décrite un peu plus bas. Ces paramètres sont fournis par des mécanismes planquées dans la soute du système d'exploitation, et n'ont pas d'importance pour le moment.. \lstinputlisting[language=c]{code/C/hello.c} Un fois passé l'entrée, nous sommes dans la partie active. Nous appelons à ce moment une fonction de la bibliothèque standard : \texttt{puts} qui a pour but d'afficher sur l'écran le texte passé en paramètre. Voila, c'est fait. Dans les règles de l'art. Nous savons dire « bonjour » au monde. Point suivant~: dire bonjour à quelqu'un d'autre. Et pour cela il nous fait récupérer un argument depuis la ligne de commande. % ========================================================= \section{Arguments} Expliquons maintenant les deux paramètres \texttt{argc} et \texttt{argv} du point d'entrée du programme (la fonction main). Le premier est le nombre de "mots" détectés par l'interpréteur de commande qui va lancer votre proggy, et le second est un tableau de chaines de caractères contenant ces différents mots. Ce petit bout de code va nous afficher tout ça~: \lstinputlisting[language=c]{code/C/arguments.c} Et voici un exemple d'exécution depuis un shell~:\index{shell} \begin{verbatim} $ ./arguments un deux "trois quatre" 0 ./arguments 1 un 2 deux 3 trois quatre $ \end{verbatim} Nous constatons que la première valeur affichée est en fait le nom de notre programme, ou plutôt le chemin vers le fichier exécutable, et surtout que son indice est 0, ce qui semble logique\footnote{Rez-de-chaussée, premier étage, toussa\dots}. En C, les tableaux commencent toujours à l'indice 0. Pour le traitement des options, il faut sauter à la page \pageref{getopt}. . . . \begin{verbatim} if (config->optind < config->argc) for (int i = config->optind; i < config.argc; ++i) process(config->argv[i]); \end{verbatim} % ========================================================= \section{Les variables} En gros, une variable du C est une zone de mémoire destinée à contenir une valeur. Une variable peut être caractérisée par trois choses~: son nom, son type, et sa portée. \textbf{Le nom} : Il doit commencer par une lettre\footnote{To be ASCII or not to be ?} majuscule ou minuscule, laquelle peut être suivie d'un nombre suffisant de lettres, de chiffres et du caractère 'souligné'. La différence de casse est signifiante. \textbf{Le type} : C'est une désignation du genre d'information que l'on peut stocker dans une variable. \textbf{La portée} : % ========================================================= \section{Les fonctions} Nous avons vu brièvement dans la première section de ce chapitre la fonction \texttt{main} et ses deux paramètres. Il est temps de préciser les détails. Une fonction a un unique point d'entrée\footnote{Qui a déja joué avec le ENTRY du Fortran ?}, avec une éventuelle liste de paramètres, et une tout aussi éventuelle unique valeur de retour. XXX\index{XXX} % ========================================================= \section{Entrées / Sorties} \index{stdin} \index{stdout} \index{stderr} Il est évident qu'un logiciel qui n'a aucun moyen de communiquer avec le monde extérieur a bien moins d'utilité qu'un bon ed. Dans le schéma «~classique~» d'une utilisation interactive, ces échanges ont lieu par le truchement d'un terminal, qui peut tout aussi bien être une \textsl{real glasstty} ou une fenêtre d'un émulateur graphique de terminal, comme \texttt{xterm}. \subsection{Les trois flux canoniques} \texttt{stdin}, \texttt{stdout} et \texttt{stderr}\dots Par défaut, au lancement du programme, ces trois canaux d'entrée/sortie sont pré-connectés, et donc directement utilisables. Le premier (\texttt{stdin}), l'entrée standard, est connecté au clavier du consoliste\footnote{De quel roman est tiré ce terme ?}, le second (\texttt{stdout}), la sortie standard, permet d'afficher les résultats du programme sur l'écran, et le troisème (), la sortie d'erreur, permet d'afficher les éventuels messages d'erreur. La différence entre \textsl{out} et \textsl{err} est expliquée plus loin. \subsection{IO de base}\index{getchar}\index{putchar} Les fonctions \texttt{getchar} et \texttt{putchar} sont les plus simples. Avec elles, on peut lire un caractère depuis \texttt{stdin}, et afficher un caractère dans \texttt{stdout}. Tout cela semble très bien, mais la fonction de lecture est piégeuse "\textsc{It's a trap}", comme nous allons bientôt le voir. Vous devez logiquement penser que si nous allons lire un caractère depuis l'entrée du programme, nous pouvons utiliser une variable de type \texttt{char}, puisque ce type est prévu pour stocker un caractère. Seulement, pour indiquer l'abscence de caractère, la fin du fichier, il nous faut une valeur \textsl{out of band} et donc getchar renvoit en fait un \texttt{int} dont une valeur particulière sera nommée \texttt{EOF}, \textsl{end of file}. \begin{verbatim} while (EOF != (foo=getchar())) { .... \end{verbatim} Voilà un piège éliminé, et vous trouverez un exemple complet un peu plus loin. \subsection{Écrire : \texttt{printf}} \index{printf} La fonction \texttt{printf} permet d'afficher sur la sortie standard le contenu d'une (ou plusieurs) variable sous diverses présentations, qui sont contrôlables par un tout petit DSL\footnote{\textsl{domain specific language}}\index{DSL}~: la chaine de format. \begin{verbatim} int bar, foo = 42; bar = printf ("foo = %d\n", foo); \end{verbatim} La première ligne déclare deux variables dont une (foo) est initialisée à une valeur connue. La seconde ligne appelle la fonction '\texttt{printf}' avec les paramêtres appropriés et conserve la valeur de retour de celle-ci. Le premier de ces paramêtres, \texttt{"foo = \%d\textbackslash{}n"}, est appelé \emph{chaine de format}. C'est une chaine de caractères, que l'on peut classer en trois catégories~: \begin{itemize} % ------------ \item{\textsl{caractères crus} : ils sont directements poussés vers la sortie. La plupart d'entre eux donnent le résultat attendu.} \item{\textsl{codes de format} : les fragments qui commencent par le caractère '\%'. Ils servent à contrôler l'apparence de ce qui va suivre. Par exemple \texttt{\%x} va afficher un \texttt{int} en hexadécimal}. \item{\textsl{échappements} : les caractères précédés d'un '\textbackslash' ou \textsl{backslash}\footnote{barre-penchée-du-8} permettent d'inclure dans la chaine de format des caractères non imprimables. Par exemple, \texttt{'\textbackslash{}n'} va générer le caractère \textsl{newline} qui marque la fin d'une ligne de texte. } \end{itemize} % ------------ Quand à la valeur de retour, elle contient le nombre de caractères effectivement écrits. Ce nombre peut être différent du nombre attendu en cas d'erreur, par exemple si le disque est saturé. Ce nombre, que beaucoup de gens négligent, peut être utilisé pour un affichage de multiples données en limitant la longueur des lignes~: \begin{verbatim} int foo, nbre = 0; for (foo=0; foo<1000; foo++) { nbre += printf("%d ", foo); if (nbre > 62) { putchar('\n'); nbre = 0; } } \end{verbatim} % --------------------------------------------------------- % % voir aussi ~/code/network/README.md % \subsection{Lire : \texttt{fgets}} \index{fgets} Cette fonction a pour but de lire une ligne de texte depuis une entrée (stdin, fichier, socket\index{socket}...) et de la ranger en mémoire. Mais commençons par lire la documentation\index{RTFM} de cette fonction, en nous concentrant sur ces deux passages, avant de passer à un exemple\footnote{encore en phase de méditation}. Voici deux extraits de ce que nous affirme la page du manuel~: \begin{verbatim} DESCRIPTION fgets() reads in at most one less than size characters from stream and stores them into the buffer pointed to by s. Reading stops after an EOF or a newline. If a newline is read, it is stored into the buffer. A terminating null byte ('\0') is stored after the last character in the buffer. RETURN VALUE fgets() returns s on success, and NULL on error or when end of file oc‐ curs while no characters have been read. \end{verbatim} Prenez le temps d'y réfléchir, et essayons un cas simple d'utilisation pour examiner le comportement de cette fonction. Nous allons boucler sur la lecture d'une ligne depuis l'entrée standard dans un buffer d'une taille fixée, puis afficher le nombre de caractères que nous avons reçus. \lstinputlisting[language=c]{code/C/fgets-simple.c} % --------------------------------------------------------- % % \subsection{Lire : \texttt{scanf}} \index{scanf} Avez-vous bien révisé la section qui cause des pointeurs ? Êtes-vous prèt à d'étranges comportements ? À ne plus savoir où peut être la tête de lecture ? Alors les subtilités de \texttt{scanf} vont vous plaire. Nous allons commencer par un exemple simple~: la lecture de deux nombres entiers depuis l'entrée standard. Les valeurs lues seront stockée dans deux variables de type \texttt{int}. \begin{verbatim} #include ... int foo, bar, nbread; nbread = scanf("%d %d", &foo, &bar); \end{verbatim} Le premier argument est une chaine de caractères contenant des directives de conversion, semblables à celles du printf. Dans cette exemple, nous avons deux fois \texttt{"\%d"} séparées par une espace. Cette directive veut dire « lire les chiffres qui arrivent et les convertir en nombre entier quand il n'y en a plus », une simple règle de conversion. Les deux arguments suivants sont les adresses des deux variables destinées à recevoir les valeurs lues, ou, en langage commun « faut mettre ÇA LÀ ». Ce sont donc des pointeurs, on les reconnait au caractère \& qui précède leur nom. Quand à la valeur retournée par la fonction scanf, elle présente un grand intérêt car elle contient le nombre de lectures élémentaires qui se sont bien passées. Tous les cas d'erreur ne sont pas couvert, mais c'est suffisant pour traiter les cas simples de la discipline. Donc, en toute rigueur, le code que nous venons de voir devrait s'écrire, en utilisant comme il se doit le \textsl{yoda coding} pour le test de cette valeur de retour~: \begin{verbatim} ... int foo, bard; if (2 != scanf("%d %d", &foo, &bar)) { fputs("FAIL\n", stderr) abort(); } ... \end{verbatim} \textit{To be continued...} % --------------------------------------------------------- \subsection{Les fichiers}\index{fopen}\index{fclose} Lire et écrire depuis les flux gérés par le système, c'est bien, mais c'est mieux de pouvoir faire la même chose depuis ou vers un fichier enregistré. Il nous faut un moyen pour se 'connecter' à un ficher, et y balancer des trucs à grand coup de printf. Ce mécanisme passe par la fonction \texttt{fopen} et \texttt{fclose}. La première va nous renvoyer (si tout se passe bien) un pointeur sur une structure opaque de type \texttt{FILE *} qui pourra être utilisé dans la suite des opérations. Voici son prototype~: \begin{verbatim} #include FILE *fopen(const char *pathname, const char *mode); \end{verbatim} Le premier paramêtre est le nom du fichier concerné, possiblement avec son chemin d'accès (absolu ou relatif), comme \texttt{"foo.fimg"}, \texttt{"/var/tmp/foo.data"} ou \texttt{"./bla.txt"}. Le second est le mode d'accès à ce fichier. Ce mode précise, entre autres, si nous souhaitons lire ou écrire dans ce fichier. La valeur retournée par cette fonction est un pointeur qui peut être égal à \texttt{NULL} en cas d'erreur~: par exemple le fichier n'existe pas ou ne peut pas être crée. Notre fichier est maintenant ouvert, la fonction \texttt{fprintf} va nous permettre d'écrire quelque chose dedans. Elle est analogue au \texttt{prinf} vu un peu plus tôt, sauf qu'elle demande un argument supplémentaire, et c'est justement le pointeur retourné par \texttt{fopen}~: \begin{verbatim} int fprintf(FILE *stream, const char *format, ...); \end{verbatim} % ========================================================= \section{Quelques filtres Unix}\label{filtre-unix} Ce qu'on appelle un "filtre" est un logiciel destiné à transformer les données qui le traversent. Pour bien comprendre, le mieux, comme d'habitude, est un exemple. Il est un peu artificiel, car il s'agit d'éliminer les lettres \textsc{o} et \textsc{p}, sans raison valable. Le voici~: \lstinputlisting[language=c]{code/C/no-op.c} Démonstration immédiate~: \begin{verbatim} $ echo apopoz | ./no-op az $ ./no-op < no-op.c | head -5 /* * n-.c is an useless shell filter */ #include #include $ \end{verbatim} Vous voulez un autre exemple ? En voici un, parfois utile pour des simulations de terminal de \textsl{tipiak}\footnote{Le texte vert ou orange sur fond noir est de rigueur.} sur une ligne en boucle de courant à 300 Bauds, le tout pour un film que l'on souhaite classable en série Z. \lstinputlisting[language=c]{code/C/slowprint.c} % \vspace{2em} Vous prendrez bien soin de contempler le traitement d'un éventuel paramètre passé par la ligne de commande, et surtout le calcul alambiqué\footnote{On doit quand même pouvoir faire plus clair\dots} pour convertir une vitesse en Bauds à un délay acceptable par \texttt{nanosleep(2)}. Pour une explication plus détaillée sur les mécanismes utilisés et les usages possibles d'un tel filtre, il faut voir le concept de pipeline du shell en page \pageref{pipeline}. % ========================================================= \section{Les pointeurs}\label{pointeur}\index{pointeur} \textbf{Ah, enfin, on a failli attendre !} Qu'est-ce qu'un pointeur ? La réponse est multiple et parfois obscure, et c'est le pointeur qui fait à la fois la force et la faiblesse du C. Pour faire simple, un pointeur est une variable qui contient l'adresse dans la mémoire d'une autre variable. Mais en fait c'est un peu plus subtil : un pointeur « connait » le type (donc la taille) de l'objet pointé, et peut donc « parcourir » un tableau de ces objets. \begin{verbatim} Objet tableau[N]; Objet *ptr; ptr = tableau; // *ptr désigne tableau[0]; ptr++; // *ptr désigne tableau[1]; \end{verbatim} \index{XXX} XXX il y a encore beaucoup à dire, et de quoi bien rire \textsl{:)} % https://hackthedeveloper.com/function-pointer-in-c/ \subsection{Pointeurs et chaines} \begin{verbatim} char *text = "this is a text"; char text[] = "this is a text"; \end{verbatim} Vous le voyez, le piège ? \subsection{Pointeurs et fonctions} Exemple classique : qsort. % ========================================================= \section{Le préprocesseur}\index{cpp} \textbf{Attention !} L'utilisation abusive du préprocesseur peut générer des trolls de plusieurs centaines de posts. Nous avons déja abordé de loin la directive \texttt{\#include}, qui fait partie du préprocesseur, comme toutes les lignes de code commençant par le caractère \textbf{\#}. Le concept de base, qu'il faut bien capter, est que le préprocesseur pratique des \emph{substitutions de texte}. Pratiquement, il se passe ça~: \begin{verbatim} #define NUMID 1664 #define FLAVOUR "tisane" printf("La %d c'est de la %s\n", NUMID, FLAVOUR); \end{verbatim} Ces trois lignes de code (deux directives pour cpp et un appel classique de fonction) seront converties en une seule ligne de C. \begin{verbatim} printf("La %d c'est de la %s\n", 1664, "tisane"); \end{verbatim} C'est donc cette ligne qui sera ensuite passée au vrai compilateur pour être traduite en codes opératoires, dont l'exécution affichera une maxime dont la véracité demande à être vérifiée par l'expérimentation. Mais ça n'est pas fini. Ce sympathique \textsf{préproc'}% \footnote{Certains l'appellent même tendrement « mon cépépé » avec un regard de guimauve mal grillée.} nous permet aussi de faire de la compilation conditinnelle, et ça, c'est cool parce que ça ouvre la porte à plein de choses. Par exemple, l'instrumentation du code afin de faciliter les tests et le debug. \begin{verbatim} ... #ifdef TRACEUR fprintf(stderr, "pid %d was here.\n", getpid()); #endif ... \end{verbatim} Et à la compilation, il vous faut passer l'option \texttt{-DTRACEUR} à Gcc pour que ce message de trace soit pris en compte. % --------------------------------------------------------- \subsection{Les macros} Une chose très fourbe dont voici un exemple ? \begin{verbatim} #define pixidx (fi,x,y) (((y)*fi->width)+(x)) #define getRpix (fi,x,y) (fi->R[ pixidx(fi,(x),(y)) ]) #define getGpix (fi,x,y) (fi->G[ pixidx(fi,(x),(y)) ]) #define getBpix (fi,x,y) (fi->B[ pixidx(fi,(x),(y)) ]) \end{verbatim} Finalemant, ça n'est pas si compliqué que ça. Il suffit juste de savoir protéger les choses fragiles avec des parenthèses. Partout. % ========================================================= \section{Unités de compilation} Jusque à maintenant, nous n'avons vu que des programmes dont le code source n'était que dans un seul fichier, ce qui devient vite ingérable pour un gros projet. C permet facilement de faire de la compilation séparée~: chacun des fichiers source est compilé indépendament en un fichier \textsl{objet}, lesquels seront ensuite \textbf{liés} pour obtenir l'exécutable final. Mais découper un gros logiciel en plusieurs fichiers source a d'autres avantages. Bien maitrisé, c'est une technique assez sereine. Elle permet d'isoler des données spécifiques qu'il serait bien plus lourd et périlleux d'utiliser d'une autre façon. % ========================================================= \section{Les structures} Une structure est une sorte de boite dans laquelle on peut ranger plusieurs variables afin de les manipuler comme une seule entité. Les utilisateurs de 80 colonnes voient tout de suite de quoi il s'agit. XXX trouver un exemple parlant et décalé\dots % ========================================================= \section{Gestion de la mémoire} \index{malloc} \index{free} Nous avons déja entrevu la gestion « implicite » de la mémoire avec les variables locales. Il est temps de passer à une gestion explicite de celle-ci~: les fonctions \texttt{malloc} et \texttt{free} sont là pour ça. La première fonction demande au mc/p de nous préter une certaine quantité de mémoire, que nous pourront utiliser à notre guise. Et la seconde restitue cette zone mémoire au système sous-jacent. Un rapide synopsis minimal d'utilisation~: \begin{verbatim} int foo, *ptr; if (NULL==(ptr=malloc(sizeof(int)*NBITEMS))) abort(); for (foo=0; foo int getopt(int argc, char * const argv[], const char *optstring); extern char *optarg; extern int optind, opterr, optopt; \end{verbatim} La page de man de getopt(3) contient des explications détaillées et un exemple simple d'utilisation. % ========================================================= % Sun Sep 3 05:48:37 UTC 2023 % % \section{Analyser une ligne de texte} \index{parser} Nous désirons implémenter une interface en ligne de commande (aka CLI\index{cli}) pour un enchainement simple d'intructions assez semblables. On peut aussi voir ça comme la création d'un \textsl{domain specific language} (aka DSL\index{DSL}). Pour être cohérent avec le shell, nous allons utiliser la même méthode de séparation des mots sur la ligne à décomposer~: utiliser une liste pré-définie de séparateur de champs, comme le \$IFS du shell. Pour simplifier l'exemple, toutes les commandes susceptibles d'être tapées seront structurées de la même manière. \subsection{la fonction \texttt{strtok}} \index{strtok} Cette fonction nous permet de « découper » notre ligne de commande en \textsl{tokens} par un ensemble de caractères de séparation appelé \texttt{delim} dans cet extrait du man\index{man}. \begin{verbatim} #include char *strtok(char *str, const char *delim); The strtok() function breaks a string into a sequence of zero or more nonempty tokens. On the first call to strtok(), the string to be parsed should be specified in str. In each subsequent call that should parse the same string, str must be NULL. \end{verbatim} Concrètement, nous allons utiliser deux séparateurs très classiques, l'espace et la tabulation \texttt{ delim = "\symbol{92}t ";}. on peut ensuite aller regarder dans la mémoire ce qui s'y passe~: \begin{verbatim} --- chaine d'origine 66 6f 6f 20 20 20 62 61 72 09 71 75 75 78 20 77 69 7a 00 f o o b a r q u u x w i z --- 1er strtok 66 6f 6f \0 20 20 62 61 72 09 71 75 75 78 20 77 69 7a 00 f o o b a r q u u x w i z got [foo] \end{verbatim} Donc, \texttt{strtok} a détecté le premier caractère de séparation, ici un espace, qui est juste après le premier mot de la ligne à analyser, et l'a remplacé par un '\symbol{92}0', le marqueur de fin de chaine. Le premier mot (foo) a bien été isolé. on peut constater que la chaine de départ est modifiée, ce qui risque de causer des soucis, mais on en parlera plus tard. \subsection{Le programme complet} \lstinputlisting[language=c]{code/C/demo-strtok.c} % ========================================================= \section{Erreurs classiques} Le C est un langage parsemé de fosses, de chausse-trapes et de pièges fourbes et sournois. Sans parler des UBs, hein\dots \begin{itemize} \item{Variables non initialisées.} \item{Sortir d'un tableau (par le haut ou par le bas).} \item{Dépassement de la taille d'une chaine.} \item{Libérer deux fois la mémoire.} \item{\textsl{file pointer} invalide.} \end{itemize} % ========================================================= \section{Random} \index{ramdom} \label{c-random} XXX \index{XXX} Un ordinateur est déterministe. % ========================================================= \section{Debug} \index{Debug} Des outils et astuces en page \pageref{chap:debug}. \begin{quote} splint is an annotation-assisted lightweight static checker. It is a tool for statically checking C programs for security vulnerabilities and coding mistakes. If additional effort is invested in adding annotations to programs, splint can perform stronger checking. \end{quote} % ========================================================= \section{Legalize} "The two forms of conforming implementation are hosted and freestanding. A conforming hosted implementation shall accept any strictly conforming program. A conforming freestanding implementation shall accept any strictly conforming program in which the use of the features specified in the library clause (Clause 7) is confined to the contents of the standard headers , , , , , , , , and . Additionally, a conforming freestanding implementation shall accept any strictly conforming program in which the use of the features specified in the header , except the following functions: strdup , strndup , strcoll , strxfrm , strerror ." (4p6) https://devblogs.microsoft.com/oldnewthing/20230109-00/?p=107685 % ========================================================= \section{Dessiner} % XXX insert blabla here \subsection{G2} \index{g2} \label{g2} \begin{quote} \textbf{g2} is a simple to use graphics library for 2D graphical applications written in \textit{ANSI C}. This library provides a comprehensive set of functions for simultaneous generation of graphical output on different types of devices. \end{quote} \lstinputlisting[language=c]{code/g2/un_dessin.c} % % XXX EXEMPLE TROP MINIMALISTE !!! % % ========================================================= % % Message-ID: % \section{Advanced} Direct from Usenet (\texttt{comp.lang.c}): \textsl{I did an experiment where is possible to create "sets" of warnings.} \begin{verbatim} #define SAFE_REGION \ _Pragma("GCC diagnostic push") \ _Pragma("GCC diagnostic error \"-Wenum-compare\"")\ _Pragma("GCC diagnostic error \"-Wparentheses\"")\ _Pragma("GCC diagnostic error \"-Wuninitialized\"") #define RESTORE \ _Pragma("GCC diagnostic pop") enum E1 { A }; enum E2 { B }; SAFE_REGION int main() { int a, b; if (a = b){} if (A == B){} } RESTORE \end{verbatim} \begin{quote} J'avoue avoir mis un certain temps à capter. Je vais attendre le \textsl{follow-up} de Bart pour avoir confirmation. \end{quote} % ========================================================= \section{La suite?} % Message-ID: <657f1dd4$0$10079$426a74cc@news.free.fr> % NNTP-Posting-Date: 17 Dec 2023 17:12:04 CET Étudier les différents modêles de mémoire partagée. % ========================================================= \section{Ailleurs dans cet ouvrage} Il y a plein d'autres exemples de code en C, sur des sujets divers comme Open Sound Control (page \pageref{chap:OSC}) ou libsndfile (page \pageref{chap:son}). Et pour les gens du système~: l'utilisation des signaux (page \pageref{get-signal}), le chargement dynamique d'un \textsl{plug-in} (page \pageref{ex_dlopen}), les \texttt{ioctl}, \dots % =========================================================