Section Outils version alpha pour 2020

Outils/bib.rst

@@ -6,13 +6,17 @@
 Bibliographie
 *************
 
+.. spelling::
 
-.. [DeveloppezMake] Introduction à Makefile, http://gl.developpez.com/tutoriel/outil/makefile/
+   Makefile
+   The
+   Make
+   Honeyford
+   Manual
 
+.. [DeveloppezMake] Introduction à Makefile, http://gl.developpez.com/tutoriel/outil/makefile/
 
 .. [GNUMake] The GNU Make Manual, http://www.gnu.org/software/make/manual/make.html
 
-
-
 .. [Honeyford2006] Honeyford, M., `Speed your code with the GNU profiler`, http://www.ibm.com/developerworks/library/l-gnuprof.html
 

Outils/cunit.rst

@@ -8,7 +8,7 @@ CUnit: librairie de tests
 -------------------------
 
 `CUnit <http://cunit.sourceforge.net>`_ est une librairie de tests unitaires
-en C. Cette librarie vous sera utile lors de développement de projets en C.
+en C. Cette librairie vous sera utile lors de développement de projets en C.
 
 Installation
 ^^^^^^^^^^^^
@@ -76,7 +76,7 @@ tests.
 Pour pouvoir concrètement exécuter un ensemble de tests, il est nécessaire
 de réaliser les différentes étapes suivantes:
 
-1. Ecrire les tests
+1. Programmer les tests
 2. Initialiser le catalogue
 3. Ajouter les suites de tests dans le catalogue
 4. Ajouter les tests dans les suites de tests
@@ -89,7 +89,7 @@ Tout d'abord, il est nécessaire d'écrire les tests. Aucune libraire ne peut
 les écrire pour vous. Toutefois, CUnit vient avec un certain nombre de macros
 permettant de vérifier les propriétés qui nous intéressent. Pour pouvoir
 utiliser ces macros, il est nécessaire d'importer ``CUnit.h``. La table
-suivante récapitule les principales macros. Il est important d'appeller ces
+suivante récapitule les principales macros. Il est important d'appeler ces
 macros lorsque l'on rédige les tests, ce sont ces appels qui détermineront si
 oui ou non, le test est fructueux.
 
@@ -155,12 +155,17 @@ vérification des tests. Par exemple,
             if (CUE_SUCCESS != CU_initialize_registry())
               return CU_get_error();
 
+.. spelling::
+
+   setup
+   teardown
+	      
 Pour ajouter les suites de tests au catalogue, il faut faire appel à la
 méthode ``CU_add_suite(const char* strName, CU_InitializeFunc pInit,
 CU_CleanupFunc pClean)``. Comme on peut le voir, cette méthode demande un nom
 (qui doit être unique pour un catalogue) ainsi que deux pointeurs de fonction.
 Ces pointeurs de fonction permettent d'exécuter du code avant (typiquement
-appelé 'setup') ou après (typiquement 'teardown') l'exécution des tests de la
+appelé `setup`) ou après (typiquement `teardown`) l'exécution des tests de la
 suite. Ces méthodes sont utiles pour initialiser un environnement d'exécution
 pour des tests le nécessitants (par exemple, s'assurer de la présence de
 fichier, initialiser certaines variables, etc.). Ces méthodes sont bien sûr

Outils/gcc.rst

@@ -8,11 +8,11 @@ GCC
 ---
 
 
-Comme cela a déja été dit, le compilateur fonctionne selon 4 étapes distinctes:
-	* Appel du préprocesseur ``cpp``: Supprime les commentaires, inclus les #includes et évalue les macros
+Comme cela a déjà été dit, le compilateur fonctionne selon 4 étapes distinctes:
+	* Appel du préprocesseur ``cpp``: Supprime les commentaires, inclus les `#include` et évalue les macros
 	* Appel du compilateur	 ``cc1``: Génère un fichier assembleur (.as)
 	* Appel de l'assembleur	 ``as``	: Génère le fichier objet (.o)
-	* Appel du linkeur	 ``ld``	: Génère l'exécutable
+	* Appel du de l'éditeur de liens ``ld``	: Génère l'exécutable
 
 
 Différentes options peuvent être utilisé avec gcc :
@@ -26,11 +26,16 @@ Différentes options peuvent être utilisé avec gcc :
 	* -On		: Indique le niveau d'optimisation où n est compris entre 0 et 3
 	* -Wall		: Active tout les warnings
 	* -Werror 	: Considère tout les warnings comme des erreurs
+	* --help        : Messages d'aide
 
-	* --help
+Notons que les trois premières options ne présentent pas d'intérêt pour ce cours.
 
-Notons que les trois premières options ne présentent pas d'interêt pour ce cour.
 
+.. spelling::
+
+   help
+
+   
 
 
 

Outils/gdb.rst

 .. -*- coding: utf-8 -*-
-.. Copyright |copy| 2012 by `Olivier Bonaventure <http://inl.info.ucl.ac.be/obo>`_, Christoph Paasch, Grégory Detal et Nicolas Houtain
+.. Copyright |copy| 2012, 2020 by `Olivier Bonaventure <http://inl.info.ucl.ac.be/obo>`_, Christoph Paasch, Grégory Detal et Nicolas Houtain
 .. Ce fichier est distribué sous une licence `creative commons <http://creativecommons.org/licenses/by-sa/3.0/>`_
 
+.. spelling::
+
+   breakpoint
+   Breakpoint
+   breakpoints
+   frame
+   display
+   displays
+   débugger
+   
 .. _gdb-ref:
 
 GDB
@@ -18,7 +28,7 @@ Liste des commandes
 
 L'option -g de `gcc(1)`_ place dans l'exécutable les informations sur les noms de variables, mais aussi tout le code source.
 
-Lancez gdb avec la commande ``gdb my_program``. Ceci va vous ouvrir la console de ``gdb`` qui vous permet de lancer, le programme et de l'analyser. Pour démarrer le programme, tapez ``run``. gdb va arrêter l'exécution au premier problème trouvé. Votre programme tourne encore pour l'instant. Arrètez-le avec la commande ``kill``.
+Lancez gdb avec la commande ``gdb my_program``. Ceci va vous ouvrir la console de ``gdb`` qui vous permet de lancer, le programme et de l'analyser. Pour démarrer le programme, tapez ``run``. gdb va arrêter l'exécution au premier problème trouvé. Votre programme tourne encore pour l'instant. Arrêtez-le avec la commande ``kill``.
 
 Breakpoint
 ^^^^^^^^^^
@@ -82,7 +92,7 @@ Automatisation
 
 Lors d'un débuggage long et fastidieux, il est parfois nécessaire d'exécuter certaines commandes à chaque breakpoint.
 
-	* ``commands [numerobreakpoint]`` definit une liste de commandes associées à un breakpoint. Celles ci seront exécutées quand on s'arrêtera sur ce breakpoint. Il suffit de taper les commandes à effectuer les unes après les autres et de terminer par ``end``. Si vous ne fournissez pas de numéro, les commandes sont assignées au dernier breakpoint créé.
+	* ``commands [numerobreakpoint]`` définit une liste de commandes associées à un breakpoint. Celles ci seront exécutées quand on s'arrêtera sur ce breakpoint. Il suffit de taper les commandes à effectuer les unes après les autres et de terminer par ``end``. Si vous ne fournissez pas de numéro, les commandes sont assignées au dernier breakpoint créé.
 	* ``display [variablename]`` affiche la variable à chaque breakpoint.
 
 Gestion des Signaux
@@ -95,9 +105,9 @@ Il est possible de gérer le comportement de `gdb(1)`_ lorsque des signaux sont
 Localiser un signal
 """""""""""""""""""
 
-Avec `gdb(1)`_, il est possible de localiser un signal et de débugguer certaines erreurs comme une erreur de segmentation. En effet, lorsque `gdb(1)`_ interrompt le programme en cours après l'interception d'un signal d'erreur comme ``SIGSEGV``, il est possible de trouver la ligne du programme à laquelle le signal a été intercepté en tapant le mot-clé ``where`` une fois le programme interrompu (il est cependant nécessaire d'avoir compilé le programme avec l'option ``-g`` de ``gcc`` pour trouver la ligne précise). Ensuite, grâce aux commandes expliquées plus tôt, il est possible de vérifier les valeurs des variables lors de l'interception du signal pour trouver l'origine du problème.
+Avec `gdb(1)`_, il est possible de localiser un signal et de débugger certaines erreurs comme une erreur de segmentation. En effet, lorsque `gdb(1)`_ interrompt le programme en cours après l'interception d'un signal d'erreur comme ``SIGSEGV``, il est possible de trouver la ligne du programme à laquelle le signal a été intercepté en tapant le mot-clé ``where`` une fois le programme interrompu (il est cependant nécessaire d'avoir compilé le programme avec l'option ``-g`` de ``gcc`` pour trouver la ligne précise). Ensuite, grâce aux commandes expliquées plus tôt, il est possible de vérifier les valeurs des variables lors de l'interception du signal pour trouver l'origine du problème.
 
-En plus de localiser facilement les erreurs de segmentation dans un programme, vous pourrez annalyser plus aisément les problèmes de deadlock des threads. En effet, lorsque le programme est lancé sur le shell et que vous remarquez un deadlock, vous pouvez appuyer sur ``CTRL + C`` pour lancer le signal ``SIGINT`` au programme. Cela permettra de trouver les endroits où bloquent les différents threads du programme à l'aide des commandes décrites dans la section de débuggage des threads ci-dessous.
+En plus de localiser facilement les erreurs de segmentation dans un programme, vous pourrez analyser plus aisément les problèmes de deadlock des threads. En effet, lorsque le programme est lancé sur le shell et que vous remarquez un deadlock, vous pouvez appuyer sur ``CTRL + C`` pour lancer le signal ``SIGINT`` au programme. Cela permettra de trouver les endroits où bloquent les différents threads du programme à l'aide des commandes décrites dans la section de débuggage des threads ci-dessous.
 
 Extraction de code assembleur
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -105,13 +115,16 @@ Extraction de code assembleur
 	* ``disas`` 		affiche le code assembleur
 	* ``disas /m blah`` 	met en correspondance le code assembleur et le code source
 
-Pour arrêter la console de gdb, tappez ``quit``.
+Pour arrêter la console de gdb, tapez ``quit``.
 
 
 Illustration avec des exemples
 ------------------------------
 
-.. A titre d'exemple, télécharger l'archive :download:`src/gdb.c`. L'archive contient un Makefile qui vous permettra de compiler plusieurs programmes.
+.. spelling::
+   calc
+   factTmp
+   tab
 
 Premier programme
 ^^^^^^^^^^^^^^^^^
@@ -156,8 +169,10 @@ Premier programme
 Deuxième programme
 ^^^^^^^^^^^^^^^^^^
 
-	Le deuxième programme est appelé :download:`src/recursive.c`. Celui ne présente aucun bug et se déroulera normalement. Toutefois, il est intéressant d'utiliser `gdb(1)`_ pour bien comprendre les différents contextes au sein d'un programme. Mettez un break sur la fonction factTmp avec ``break factTmp`` et ajoutez automatiquement à ce breakpoint la commande ``backtrace``, via ``commands``. Ensuite, lancez le programme.
-	``backtrace`` vous permet de visualiser les appels de fonction effectués. Nous pouvons voir que la fonction factTmp a été appellée par factTerminal, elle même appellée par la fonction main.
+
+
+	Le deuxième programme est appelé :download:`src/recursive.c`. Celui ne présente aucun bug et se déroulera normalement. Toutefois, il est intéressant d'utiliser `gdb(1)`_ pour bien comprendre les différents contextes au sein d'un programme. Mettez un break sur la fonction ``factTmp avec`` ``break factTmp`` et ajoutez automatiquement à ce breakpoint la commande ``backtrace``, via ``commands``. Ensuite, lancez le programme.
+	``backtrace`` vous permet de visualiser les appels de fonction effectués. Nous pouvons voir que la fonction ``factTmp`` a été appelée par ``factTerminal``, elle même appelée par la fonction ``main``.
 
 	.. code-block:: console
 
@@ -165,10 +180,10 @@ Deuxième programme
 			#1  0x000000000040057d in factTerminal (a=6) at recursive.c:17
 			#2  0x0000000000400598 in main (argc=1, argv=0x7fffffffe1b8) at recursive.c:23
 
-	Essayez d'afficher les variable ``globalVar`` puis ``localVar``. Vous remarquerez qu'il n'est pas possible d'afficher ``localVar`` puisque cette variable ne fait pas partie de l'environement contextuel de factTmp. Pour afficher cette variable, il faut remonter la liste des appels. ``up`` permettra de remonter les appels pour pouvoir afficher ``localVar``.
+	Essayez d'afficher les variable ``globalVar`` puis ``localVar``. Vous remarquerez qu'il n'est pas possible d'afficher ``localVar`` puisque cette variable ne fait pas partie de l'environnement contextuel de factTmp. Pour afficher cette variable, il faut remonter la liste des appels. ``up`` permettra de remonter les appels pour pouvoir afficher ``localVar``.
 	Une fois la variable affichée, redescendez avec ``down`` et continuez 4 fois le programme après le breakpoint. Vous remarquerez que la liste des appels s'allonge à chaque appel récursif, ce qui est tout à fait normal.
 
-        Naviguez dans les appels recursifs de factTmp en affichant les valeur de ``globalTmp``, ``tmp``, ``acc`` et ``nbr``. Il est important de bien comprendre que la variable statique ``globalTmp`` est commune à tous les appels de la fonction ``factTmp`` et un changement de cette variable dans un des appels récursifs modifie la variable des autres appels. A contrario, la variable local ainsi que les arguments sont propres à chaque appel.
+        Naviguez dans les appels récursifs de factTmp en affichant les valeur de ``globalTmp``, ``tmp``, ``acc`` et ``nbr``. Il est important de bien comprendre que la variable statique ``globalTmp`` est commune à tous les appels de la fonction ``factTmp`` et un changement de cette variable dans un des appels récursifs modifie la variable des autres appels. A contrario, la variable local ainsi que les arguments sont propres à chaque appel.
 
 	Vous pouvez maintenant terminer le programme.
 
@@ -200,7 +215,7 @@ Débuggage des threads avec GDB
 
 `gdb(1)`_ est aussi utile pour débugger des programmes avec des threads. Il permet de faire les opérations suivantes sur les threads:
 
-        * Etre notifié lors de la création d'un nouveau thread.
+        * Recevoir une notification lors de la création d'un nouveau thread.
         * Afficher la liste complète des threads avec ``info threads``.
         * Placer un breakpoint dans un thread. En effet, si vous placez un breakpoint dans une certaine fonction, et un thread passe lors de son exécution à travers ce breakpoint, ``gdb`` va mettre l'exécution de tous les threads en pause et changer le contexte de la console `gdb(1)`_ vers ce thread.
         * Lorsque les threads sont en pause, vous pouvez manuellement donner la main à un thread en faisant ``thread [thread_no]`` avec ``thread_no`` étant l'indice du thread comme indiqué par ``info threads``

Outils/gprof.rst

@@ -2,6 +2,10 @@
 .. Copyright |copy| 2012 by `Olivier Bonaventure <http://inl.info.ucl.ac.be/obo>`_, Christoph Paasch et Grégory Detal
 .. Ce fichier est distribué sous une licence `creative commons <http://creativecommons.org/licenses/by-sa/3.0/>`_
 
+.. spelling::
+
+   Profiling
+   
 .. _gprof:
 
 Profiling de code

Outils/intro-outils.rst

@@ -5,8 +5,14 @@
 Introduction
 ============
 
-Outre des compétences théoriques qui sont abordées dans d'autres parties de ce document, la maitrise d'une système informatique implique également une excellente connaissance des outils informatiques qui sont inclus dans ce système. Cette connaissance se construit bien entendu en utilisant activement ces logiciels. Cette section comprend les informations de bases sur quelques logiciels importants qui sont utilisés dans le cadre du cours. Elle est volontairement réduite car de nombreux logiciels pourraient faire l'objet de livres complets. Les étudiants sont invités à proposer des améliorations à cette section sous la forme de patches via https://github.com/obonaventure/SystemesInformatiques
+Outre des compétences théoriques qui sont abordées dans d'autres parties de ce document, la maîtrise d'une système informatique implique également une excellente connaissance des outils informatiques qui sont inclus dans ce système. Cette connaissance se construit bien entendu en utilisant activement ces logiciels. Cette section comprend les informations de bases sur quelques logiciels importants qui sont utilisés dans le cadre du cours. Elle est volontairement réduite car de nombreux logiciels pourraient faire l'objet de livres complets. Les étudiants sont invités à proposer des améliorations à cette section sous la forme de patches via https://github.com/UCL-INFI/SyllabusC
 
+.. spelling::
+
+   Editeurs
+   emacs
+   Tetris
+   
 
 Editeurs
 ========

Outils/make.rst

@@ -2,6 +2,14 @@
 .. Copyright |copy| 2012 by `Olivier Bonaventure <http://inl.info.ucl.ac.be/obo>`_, Christoph Paasch et Grégory Detal
 .. Ce fichier est distribué sous une licence `creative commons <http://creativecommons.org/licenses/by-sa/3.0/>`_
 
+.. spelling::
+
+   Makefile
+   Makefiles
+   Make
+   make
+   
+   
 .. _make:
 
 Introduction aux Makefiles
@@ -60,7 +68,7 @@ Comme ``text.txt`` dépend de ``name.txt``, il faut que ce dernier soit défini
         Salut,
         Tintin
 
-Lorsqu'une dépendance change, ``make`` le détecte et ré-exécute les commandes associées à la cible. Dans le cas suivant, le fichier ``name.txt`` est modifié, ce qui force la regénération du fichier ``text.txt``.
+Lorsqu'une dépendance change, ``make`` le détecte et ré-exécute les commandes associées à la cible. Dans le cas suivant, le fichier ``name.txt`` est modifié, ce qui force une nouvelle génération du fichier ``text.txt``.
 
     .. code-block:: console
 
@@ -113,6 +121,10 @@ Vous pouvez donc très bien utiliser la variable ``$(HOME)`` indiquant le réper
 
 Il existe six différentes manières d'assigner une valeur à une variable. Nous ne nous intéresserons qu'à quatre d'entre elles.
 
+.. spelling::
+
+   value
+
     .. code-block:: make
 
         VARIABLE = value
@@ -186,7 +198,7 @@ Une bonne pratique est de déclarer dans ``.PHONY`` toutes les règles de nettoy
         clean:
             rm -f *.o
 
-Cela est aussi pratique pour forcer une re-compilation.
+Cela est aussi pratique pour forcer une nouvelle compilation.
 
     .. code-block:: make
 
@@ -213,7 +225,7 @@ Cette syntaxe est semblable au script shell.
         build:
             gcc -o foo foo.c # commentaire en fin de ligne
 
-Débugger les erreurs de vos Makefiles peut sembler difficile lorsque vous êtes baignés dans un flux d'instructions. Vous pouvez néanmoins régler leur verbosité.
+Corriger les erreurs de vos Makefiles peut sembler difficile lorsque vous êtes baignés dans un flux d'instructions. Vous pouvez néanmoins régler leur verbosité.
 Il est possible de rendre silencieuse une commande en plaçant une arobase devant. Ceci indique juste à Make de ne pas imprimer la ligne de commande. La sortie
 standard de cette commande restera visible.
 

Outils/shell.rst

@@ -13,7 +13,12 @@ Dans le cadre de ce cours nous utiliserons l'interpréteur `bash(1)`_. Cet exéc
 
 Le shell est un outil très puissant. Il permet d'effectuer de nombreuses opérations qui peuvent difficilement être réalisées manuellement ou via une interface graphique.
 
+.. spelling::
 
+   tab
+   regex
+   gz
+   
 .. note:: Astuce : utilisez la complétion
 
  Lors de la frappe d'un nom de fichier, d'un chemin d'accès ou même d'une commande tapez sur la touche ``<tab>`` pour "compléter" le mot que vous écrivez. Si rien ne se passe tapez deux fois <tab> pour obtenir la liste des possibilités.
@@ -32,6 +37,10 @@ Expressions régulières
 
 Avant de commencer à voir les commandes utiles avec le shell, il est important de définir ce qu'est une expression régulière (`regex(3)`). Les expressions régulières caractérisent des chaînes de caractères et elles sont utiles pour de nombreuses commandes. Nous l'utiliserons notamment pour faire une recherche dans un fichier.
 
+.. spelling::
+
+   er
+
 Dans une regex, certains caractères ont une signification particulière :
 
          =============   ====================================   ====================================================
@@ -80,9 +89,13 @@ La commande `ls(1)`_ permet de connaître l'ensemble des fichiers et répertoire
 	
     * ``-F`` : 	Positionne à la fin des noms de fichier un ``/`` pour les répertoires et ``*`` pour les fichiers exécutables
     * ``-a`` : 	Affiche tous les fichiers, y compris les fichiers cachés (ceux qui commencent par le caractère ``.`` )
-    * ``-d`` : 	Evite de lister le contenu d'un répertoire : si `rep` est un répertoire, ``ls -l`` `rep` listera le contenu du répertoire `rep`, alors que ``ls -ld`` `rep` listera la description du répertoire
+    * ``-d`` : 	Ne liste pas le contenu d'un répertoire : si `rep` est un répertoire, ``ls -l`` `rep` listera le contenu du répertoire `rep`, alors que ``ls -ld`` `rep` listera la description du répertoire
     * ``-l`` : 	Description complète du contenu d'un répertoire (une ligne par fichier)
 
+.. spelling::
+
+   filename
+      
 Avec l'option ``-l``, le premier caractère de la ligne indique le type du fichier. Le caractère ``-`` correspond à un fichier standard et ``d`` à un répertoire. Il est aussi possible de connaître le contenu d'un autre répertoire que le répertoire courant en fournissant le nom de ce répertoire comme argument à la commande ``ls``. 
 
 	.. code-block:: console
@@ -97,6 +110,12 @@ Avec l'option ``-l``, le premier caractère de la ligne indique le type du fichi
 Manipulation de fichiers
 ------------------------
 
+.. spelling::
+
+   irf
+   opt
+   
+
 Créer et détruire 
 ^^^^^^^^^^^^^^^^^
 
@@ -105,25 +124,37 @@ Créer et détruire
 	* `echo(1)`_ mon_texte > filename	crée un fichier avec "mon_texte" dedans.
 	
 	`rm(1)`_ [-irf] files	    	efface les fichiers
-				    	* -i : 	intéractif, demande une confirmation sur chaque fichier
+				    	* -i : 	interactif, demande une confirmation sur chaque fichier
 				    	* -f : 	force la suppression du fichier
 				    	* -r :  efface un répertoire et son contenu
 
 Visualiser
 ^^^^^^^^^^
 
+.. spelling::
+
+   vET
+   vE
+   cat
+   ctrl
+   sX
+   s'XXX
+   
+
 	* `cat(1)`_ [-opt] f1 f2		concatène et affiche les deux fichiers.
 	* `cat(1)`_ [-opt] file			affiche le fichier sur la sortie standard.
 
 					* -v : convertit les caractères spéciaux en caractères affichables
 					* -n : numérote les lignes
 					* -b : numérote seulement les lignes non vides
-					* -E : affiche le symbôle $ à la fin de chaque ligne
+					* -E : affiche le symbole $ à la fin de chaque ligne
 					* -T : affiche les caractères de tabulation comme ^I
 					* -A : équivalent à -vET
 					* -e : équivalent à -vE
 					* -t : équivalent à -vT
 
+
+					  
 	Avec cat, il est possible d'écrire depuis la console dans un fichier. 
 	Appuyez sur ctrl+D au début d'une ligne pour terminer la saisie
 
@@ -170,8 +201,8 @@ Modifier
 					* -a : change uniquement la date d'accès du fichier
 
 `split(1)`_ [-opt] file [out]	coupe le fichier en plusieurs petites parties
-					* -b nbr : decoupe selon un nombre d'octets
-					* -n nbr : decoupe selon un nombre de lignes
+					* -b nbr : découpe selon un nombre d'octets
+					* -n nbr : découpe selon un nombre de lignes
 
 Extraction de données
 ^^^^^^^^^^^^^^^^^^^^^
@@ -179,9 +210,9 @@ Extraction de données
 `grep(1)`_ [-opt] regex file	recherche l'expression dans les fichiers.
 					* -i : ignore la casse
 				    	* -v : affiche les lignes ne contenant pas l'expression. 
-					* -c : compte les lignes ne contenant pas la chaine
+					* -c : compte les lignes ne contenant pas la chaîne
 					* -n : numérote chaque ligne contenant la chaîne
-					* -x : affiche les lignes correspondant exactement à la chaine
+					* -x : affiche les lignes correspondant exactement à la chaîne
 
 `uniq(1)`_ [-opt] filename	affiche le fichier en supprimant les lignes qui se répètent successivement.
 					* -u : Affiche seulement les lignes n'apparaissant qu'une seule fois
@@ -200,7 +231,7 @@ Extraction de données
 					* -n : compare selon la valeur arithmétique
 					* -k : spécifie la colonne utilisée pour le tri
 
-	uniq et sort sont souvent utilisés ensemble. Par exemple, cette commande trie les lignes de file.txt selon leur nombre d'apparitions.
+	`uniq(1)`_  et `sort(1)`_ sont souvent utilisés ensemble. Par exemple, cette commande trie les lignes de `file.txt` selon leur nombre d'apparitions.
 	
 	.. code-block:: console
 	
@@ -282,6 +313,10 @@ Extraction de données
 
 Obtenir des informations
 ^^^^^^^^^^^^^^^^^^^^^^^^
+.. spelling::
+
+   src
+   dst
 
 `wc(1)`_ [-opt] filename	donne sur stdout des informations au sujet de l'entrée standard ou d'une liste de fichiers. 
 				Première colonne est le nombre de lignes, deuxième le nombre de mots et en dernier le nombre d'octets.
@@ -310,13 +345,13 @@ Copier
 		$ cp test.txt btest.txt ../
 		$ cp -r repertoire ../repertoirebis
 
-Déplacer ou renomer
-^^^^^^^^^^^^^^^^^^^
+Déplacer ou renommer
+^^^^^^^^^^^^^^^^^^^^
 
 `mv(1)`_ [-opt] src dst    	renomme ou déplace src en dst.
 					* -f : écrase les fichiers existants
 					* -i : demande confirmation avant d'écraser un fichier existant
-					* -n : n'écrase aucun fichier déja existant
+					* -n : n'écrase aucun fichier déjà existant
 		
 			Note : Si la destination est un répertoire, alors la source peut être une liste de fichiers. 
 
@@ -329,12 +364,36 @@ Déplacer ou renomer
 Rechercher
 ^^^^^^^^^^
 
+.. spelling::
+
+   rep
+   group
+   mtime
+   atime
+   ctime
+   print
+   find
+   dev
+   null
+   expr
+   xargs
+   supertab
+   block
+   testdirectory
+   grep
+   tarname
+   tar
+   owner
+   tt
+   bz
+   pid
+
 Pour les critères de recherche :
 		* critère1 critère2 		= et logique
 		* !critère 			= non logique
 		* critère1 -a critère2	 	= ou logique
 
-`find(1)`_ chemin regex	 	recherche les fichiers/répertoires caractérisés par nom, à partir du répertoire rep et affiche le résultat.
+`find(1)`_ chemin regex	 	recherche les fichiers/répertoires caractérisés par nom, à partir du répertoire `rep` et affiche le résultat.
 			    		* -name  : sur le nom du fichier
 			    		* -perm  : sur les droits d'accès du fichier
 			    		* -links : sur le nombre de liens du fichier
@@ -435,7 +494,7 @@ Pour chaque fichier, il y a trois classes d'utilisateurs
 Les permissions accordées à ces trois classes sont :
 	* r : 	lecture
 	* w : 	écriture
-	* x : 	exécution (Un fichier peut être executé et un répertoire peut devenir répertoire courant)
+	* x : 	exécution (Un fichier peut être exécuté et un répertoire peut devenir répertoire courant)
 
 
 `chmod(1)`_ mode files    	change les permissions du ou des fichiers/répertoires.
@@ -534,9 +593,16 @@ Gestion des processus
 		$ lsof -i -a -p 2735	  =  Les connexions ouvertes par le processus 2735
 
 
-`kill(1)`_ pid			supprime le processus specifié. Si malgré la commande, le processus n'est pas détruit, essayez kill -9 pid.
+`kill(1)`_ pid			supprime le processus spécifié. Si malgré la commande, le processus n'est pas détruit, essayez kill -9 pid.
 
 
+.. spelling::
+
+   pid
+   cmd
+   wc
+   root
+
 Symboles utiles
 ---------------
 
@@ -599,11 +665,11 @@ Informations générales
 
 `su(1)`_			passe en mode "root", c'est à dire administrateur
 
-`whatis(1)`_ cmd		explique briévement l'utilité d'une commande
+`whatis(1)`_ cmd		explique brièvement l'utilité d'une commande
 
-`apropos(1)`_ [-opt] motclé	recherche dans les man pages les commandes correspondants aux mots clés.
+`apropos(1)`_ [-opt] mot-clé	recherche dans les man pages les commandes correspondants aux mots clés.
 				* -a : Affiche seulement les résultats répondant à tout les mots clés. 
-				       L'inverse est le fonctionnement par défault
+				       L'inverse est le fonctionnement par défaut
 
 `date(1)`_			donne l'heure, selon l'horloge de votre ordinateur
 
@@ -616,6 +682,26 @@ Informations générales
 Informations système
 ^^^^^^^^^^^^^^^^^^^^
 
+.. spelling::
+
+   node
+   prog
+   cmdfile
+   sed
+   num
+   mtf
+   sbst
+   goto
+   eo
+   awk
+   program
+   while
+   kill
+   txt
+   name
+   nbr
+   
+
 `time(1posix)`_ programme		permet de calculer le temps d'exécution d'un programme
 
 `df(1)`_ [-opt] [file]		indique l'espace disque utilisé et disponible sur tous les systèmes de fichiers. 
@@ -901,7 +987,7 @@ Après il ne reste plus qu'à l'exécuter et observer le résultat.
 Les variables
 ^^^^^^^^^^^^^
 
-Bash permet l'utilisation de variables dans les scripts. Il peut s'agir de simples variables ou de tableaux. Bash n'est pas un langage typé, les Int ou les String n'existent pas, toutes les variables sont traitées de la même façon. Pour illustrer ceci nous allons écrire le script `variables.sh <https://raw.github.com/HappyRave/SystInfo1/master/valgrind/variables.sh>`_
+Bash permet l'utilisation de variables dans les scripts. Il peut s'agir de simples variables ou de tableaux. Bash n'est pas un langage typé, les entiers ou les String n'existent pas, toutes les variables sont traitées de la même façon. Pour illustrer ceci nous allons écrire le script `variables.sh <https://raw.github.com/HappyRave/SystInfo1/master/valgrind/variables.sh>`_
 
     .. code-block:: bash
 
@@ -927,7 +1013,7 @@ Ce script produit comme résultat
       Hello,1252
       Hello,12 52
 
-Il est interressant de visiter cette page : http://michel.mauny.net/sii/variables-shell.html
+Il est intéressant de visiter cette page : http://michel.mauny.net/sii/variables-shell.html
 
 Les structures de contrôle
 ^^^^^^^^^^^^^^^^^^^^^^^^^^

Outils/ssh.rst

@@ -8,9 +8,15 @@
 SSH
 ---
 
+.. spelling::
+
+   ssh
+   intel
+   sirius
+
 `ssh(1)`_ est un outil qui permet de se connecter depuis l'Internet à la console d'une autre machine et donc d'y exécuter des commandes. Dans l'infrastructure INGI vous pouvez vous connecter via ssh aux différents machines des salles en utilisant votre login et mot de passe INGI. Pour savoir les noms de machines, visitez le `student-wiki <http://wiki.student.info.ucl.ac.be/Matériel/Matériel>`_.
 
-Depuis l'extérieur vous devez passer via ``sirius.info.ucl.ac.be`` pour ensuite pouvoir vous connecter sur les machines des salles. 
+Depuis l'extérieur vous devez passer via ``studssh.info.ucl.ac.be`` pour ensuite pouvoir vous connecter sur les machines des salles. 
 
 Quelques exemples d'utilisation de `ssh(1)`_ qui vous seront utiles:
 
@@ -89,4 +95,9 @@ Nous pouvons aussi utiliser `rsync <http://linux.about.com/library/cmd/blcmdl1_r
 
       rsync -avz [hostname]:src/bar /data/tmp
 
-Maintenant tout les fichiers de la machine hôte, dans le dossier src/bar vont être copiés vers le répertoire local /data/tmp.
+Maintenant tout les fichiers de la machine hôte, dans le dossier ``src/bar`` vont être copiés vers le répertoire local ``/data/tmp``
+
+
+.. spelling::
+
+   src

Outils/valgrind.rst

 .. -*- coding: utf-8 -*-
-.. Copyright |copy| 2012 by `Olivier Bonaventure <http://inl.info.ucl.ac.be/obo>`_, Christoph Paasch, Grégory Detal et Maxime De Mol
+.. Copyright |copy| 2012, 2020 by `Olivier Bonaventure <http://inl.info.ucl.ac.be/obo>`_, Christoph Paasch, Grégory Detal et Maxime De Mol
 .. Ce fichier est distribué sous une licence `creative commons <http://creativecommons.org/licenses/by-sa/3.0/>`_
 
 .. _valgrind-ref:
@@ -16,15 +16,26 @@ Le site http://www.cprogramming.com/debugging/ vous donne des techniques de déb
 
 Valgrind permet de détecter des erreurs liées à la gestion de la mémoire dans vos programmes. Pour utiliser valgrind, lancez la commande `valgrind(1)`_ avec votre exécutable comme argument:
 
-	.. code-block:: console
+.. spelling::
 
-		valgrind --leak-check=yes [my binary]
+   ième
+   memory
+   leak
+   leaks
+   free
+   segfaults
+   faults
+   Fault
+   
+   .. code-block:: console
+
+      valgrind --leak-check=yes [my binary]
 
 Parmi les erreurs que valgrind est capable de détecter nous avons:
  
 	* Mémoire non-désallouée: Lors d'un appel à `malloc(3)`_, vous obtenez un pointeur vers une zone de mémoire allouée. Si vous "perdez" la valeur de ce pointeur, vous n'avez plus le moyen de libérer cette zone de mémoire. Essayez `valgrind(1)`_ avec le petit programme :download:`src/nofree.c`
 	* Désallouer deux fois la même zone de mémoire: Si vous appelez deux fois `free(3)`_ sur la même zone de mémoire, `valgrind(1)`_ va détecter cette erreur. Essayez-le avec le petit programme  :download:`src/twofree.c`
-	* Accès en dehors des limites d'une zone mémoire: Si vous allouez une zone de mémoire d'une certaine taille (par exemple un table de 10 chars) et que vous accèdez à une adresse qui excède cette zone (par exemple vous accèdez au 11ième élément) vous aurez probablement une ``Segmentation fault``. Valgrind permet de détecter ces erreurs et indique l'endroit dans votre code où vous faites cet accès. Essayez-le avec le petit programme :download:`src/outofbounds.c`
+	* Accès en dehors des limites d'une zone mémoire: Si vous allouez une zone de mémoire d'une certaine taille (par exemple un table de 10 chars) et que vous accédez à une adresse qui excède cette zone (par exemple vous accédez au 11ième élément) vous aurez probablement une ``Segmentation fault``. Valgrind permet de détecter ces erreurs et indique l'endroit dans votre code où vous faites cet accès. Essayez-le avec le petit programme :download:`src/outofbounds.c`
 
 On vous encourage à lancer `valgrind(1)`_ sur votre projet pour vérifier que vous n'avez pas introduit de memory-leaks sans le vouloir. `valgrind(1)`_ ne remplace pas une écriture attentive du code mais peut permettre de détecter rapidement certaines erreurs courantes. Vous trouverez plus de détails sur les liens suivants:
  
@@ -84,7 +95,7 @@ La phrase que nous voulons voir après chaque exécution de `valgrind(1)`_ est:
 
 Ce qui indique qu'aucun memory leak ne peut avoir lieu dans notre programme.
 
-Detecter les memory leaks
+Détecter les memory leaks
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 A présent nous allons montrer comment détecter des fuites de mémoire dans un programme à l'aide de `valgrind(1)`_. Testons le programme :download:`src/nofree.c`:

dict.txt

@@ -89,3 +89,9 @@ monothreadé
 multithreadé
 pthread
 malloc
+débuggage
+valgrind
+tmp
+stdin
+stdout
+gdb