.. meta:: :description lang=fr: Coloration syntaxique pour GNU Nano :description lang=en: Syntactical coloration for GNU Nano ######################################### Coloration syntaxique pour **GNU Nano** ######################################### .. include:: .special.rst .. warning:: Pour mes fichiers de coloration à jour, allez voir sur mon projet GitHub ``_. Cette page est un **vieux** tutoriel expliquant le fonctionnement de la coloration syntaxique pour l'éditeur `GNU Nano `_. .. note:: Liens directs vers les *vrais* fichiers de coloration Cette page est un *tutoriel*. Les fichiers intéressants sont dans le sous dossier ``_. En particulier : * `.nanorc `_; * `reST.nanorc `_ pour **reStructuredText** (fait entièrement par moi); * `caml.nanorc `_ pour **OCaml** (amélioré); * `python.nanorc `_ pour **Python** (amélioré); * `cu.nanorc `_ pour **CUDA** (grandement amélioré); Une archive est disponible ``_. Elle contient tous les fichiers ``.nanorc`` et ``$HOME/.nanorc/*.nanorc``. Un des sujets informatiques qui m'intéressait et m'amusait beaucoup, c'est la *coloration syntaxique*. Qu'est-ce que la coloration syntaxique ? ---------------------------------------- Il s'agit d'une notion *assez récente* : pour faciliter l'édition d'un **document**, il est plus facile de le *voir* dans différentes couleurs, et d'associer à chaque élément de la syntaxe du langage une couleur particulière. Par exemple, voici une capture d'écran, du logiciel **GNU/Nano**, utilisé pour éditer le code source de cette page. .. image:: .nanorc.png :scale: 100 % :align: center :alt: Un exemple de coloration de code rST avec GNU Nano .. sidebar:: À propos de Sublime Text ? Depuis près d'un an, j'utilise désormais l'éditeur `Sublime Text 3 (ST3) `_ pour écrire, coder ou éditer n'importe quel document *texte*. J'ai très récemment `écrit un tutoriel sur ST3 `_ ! -------------------------------------------------------------------------------- De quoi je parle ? ~~~~~~~~~~~~~~~~~~ Imaginez que vous rédigiez un devoir d'Histoire par exemple, avec un stylo et une feuille de papier. Ce devoir est constitué de paragraphes, eux-mêmes rassemblés en phrase. Et dans chaque phrase, on peut distinguer plusieurs *catégories*, plusieurs groupes de mots. Par exemple, les dates (1941, 1515, 1993), et les noms propres (De Gaulle, Delacroix). Voici un exemple de tel texte : :: De Gaulle was a man, who lived at least one month in London between 1941 and 1993. Delacroix was a painter, but he has no link at all with 1515 (yes this example is stupid). Et bien, maintenant, tentez d'imaginer que votre feuille se mette à *colorer* ces différents types, ou catégories, d'une couleur différentes pour chaque unités de sens (ou catégories) : * les dates en :green:`vert`, * les noms propres en :purple:`mauve`. Voici le même morceau de texte, mais un peu coloré : .. code-block:: erlang De Gaulle was a man, who lived at least one month in London between 1941 and 1993. Delacroix was a painter, but he has no link at all with 1515 (yes this example is stupid). **C'est ce qu'on appelle de la coloration catégoricale** (ou syntaxique). Imaginez bien qu'un outil qui serait conçu pour colorer automatiquement vos devoirs d'Histoire n'aurait pas un immense dictionnaire fixé à l'avance, associant à chaque mot sa couleur, mais plutôt une description : * les noms propres sont des mots commençant par une majuscule. * les dates sont de la forme ``i``, ``ii`` ou ``iii`` ou ``iiii``, avec ``i`` un chiffre entre 0 et 9 (éventuellement un ``-`` devant); Pourquoi syntaxique ? ~~~~~~~~~~~~~~~~~~~~~ Bien sûr, cela fait quelques années que je ne rédige plus de devoir d'Histoire, donc, me diriez-vous, quel rapport avec ce que je fais ? Et bien voilà le détail de l'analogie précédente : * le *devoir* que je rédige est un **morceau de code** (aussi appelé programme) que j'écrit, * le stylo plume et la feuille de papier forment un **éditeur de code**, * la famille *devoirs d'Histoire* est un **langage informatique**, * les dates et les noms propres sont des catégories ou des éléments propres à ce langage. Exemple ^^^^^^^ Par exemple, un tel *langage* peut être : * le langage que j'utilise pour générer cette page web, appelé ``reStructuredText``. * ou le langage de la page elle même : ``HTML``. Un exemple du paragraphe précédent, en ``reStructuredText``: .. code-block:: rst Par exemple, un tel *langage* peut être : * le langage que j'utilise pour générer cette page web, appelé ``reStructuredText``. * ou le langage de la page elle même : ``HTML``. Ou le code HTML produit par `Sphinx `_ : .. code-block:: html
Par exemple, un tel langage peut être :
  • le langage que j’utilise pour générer cette page web, appelé reStructuredText.
  • ou le langage de la page elle même : HTML.
  • J'espère que ces trois exemples (source rST, code HTML produit, et rendu visuel du paragraphe), illustrent bien le concept de **coloration syntaxique** d'un langage de programmation. ------------------------------------------------------------------------------ Définir une telle syntaxe ~~~~~~~~~~~~~~~~~~~~~~~~~ En général, on utilise une notion venue de nos cours de *langages formels* : les expressions régulières (ou rationelles), aussi raccourci en *regexp*. Par exemple, on peut définir : * les dates comme : ``[-?][0-9][0-9]*``. Le ``[-?]`` signifie qu'on peut mettre zéro ou un symbole ``-``. Le ``[0-9]`` signifie un *intervale*: un symbole entre ``0`` et ``9`` : un chiffre. Le ``[0-9]*`` signifie donc zéro ou un ou plus d'un chiffre (autant qu'on veut). * les noms propres comme ``[A-Z][a-zA-Z-']*``. On impose de commencer par une majuscule, et ensuite on prend n'importe quelle lettre, avec un tiret ``-``, ou un ``'``. Bien sûr, ces deux définitions sommaires réalisent : * des faux positifs, en colorant les mots de début de phrase par exemple; * des faux négatifs, en oubliant de colorer les noms propres qui contiennent des symboles spéciaux (``ç`` ou ``é`` notamment). Pour plus de détail, je vous renvoie à `cette page wikipédia `_. Comment **GNU/Nano** permet-il de définir de telles syntaxes ? -------------------------------------------------------------- **GNU/Nano** est un éditeur assez simpliste, bien moins développé que **Emacs**, **Vim** ou **Eclipse**. Et ainsi, il n'est peut être pas très approprié pour gérer des projets complets. Mais il peut être pratique pour rapidement éditer un fichier en console. **GNU/Nano** permet naturellement de colorer le code qu'on édite, comme le montre la capture d'écran en haut de *cette* page. Et si j'ai choisi **Nano** comme exemple, c'est parce qu'il est **très facile** de définir une **syntaxe** pour que Nano la colore comme on le souhaite. En fait, de tous les systèmes que auxquels j'ai touché, c'est le plus simple (celui de **Jota** est presque aussi simple). Un fichier **.nanorc** ~~~~~~~~~~~~~~~~~~~~~~ Tout ce dont aura besoin **Nano** pour colorer un certain type de fichiers est un *fichier de configuration*, avec comme extension **.nanorc** (mais ce n'est qu'une convention). Pour l'exemple des devoir d'histoire, laissez moi vous montrer comment concevoir un tel fichier **histoire.nanorc**. Le fichier complet est ici ``_. Il faut d'abord définir quelle syntaxe on explique : :: syntax "histoire" "\.histoire$" Le premier mot donne le nom de la syntaxe, et le second définit l'extension de nos devoirs d'Histoire. Ensuite, on définit les dates comme expliqué plus haut : :: color brightgreen "[0-9][0-9]*" color brigthgreen "-[0-9][0-9]*" On définit enfin les noms propres : :: color brightmagenta "[A-Z][A-Za-z]*" Quel résultat ? ~~~~~~~~~~~~~~~ L'image suivante montre le résultat : .. image:: exemple.histoire.png :scale: 100 % :align: center :alt: Un exemple de rendu pour cette syntaxe minimaliste On a donc obtenu **exactement** ce qu'on voulait. Il faut bien retenir la syntaxe des **.nanorc** : :: color une_couleur une_regexp Les couleurs disponibles sont :blue:`blue`, :red:`red`, :green:`green`, :yellow:`yellow`, :black:`black`, :magenta:`magenta`, :cyan:`cyan`, :white:`white` (white) (traditionnelement les 8 couleurs **ANSI**, notamment utilisées dans les terminaux ``UNIX`` et ``Linux``, cf. `ANSIColors-balises `_ ou sa version plus récente `ansicolortags `_). On peut les préfixer du mot ``bright`` pour indiquer une couleur plus claire. On peut aussi colorer le fond, en indiquant une seconde couleur : :: color couleur_texte,couleur_fond une_regexp On peut aussi utiliser la commande ``icolor`` pour capturer sans tenir compte de la casse. Les **regexps** utilisées suivent la syntaxe des *Perl regexps*, un standard dans le monde Unix (aussi utilisée par Bash pour les filtres de fichiers, ou par *grep* pour le motif de recherche). Une autre syntaxe possible est : :: color ma_couleur start=regexp1 end=regexp2 Pour savoir comment *charger* ce fichier ``histoire.nanorc`` au démarrage de **GNU/Nano**, la suite est utile. Comment utiliser ces fichiers **.nanorc** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pour les utiliser, il faut éditer le fichier ``$HOME/.nanorc``, qui doit contenir des lignes de la forme ``include "path/to/lang.nanorc"``. Il est conseillé de créer un dossier ``$HOME/.nano/`` d'y mettre les fichiers de coloration, et de rajouter une ligne dans son ``$HOME.nanorc`` pour inclure chaque fichier rajouté (ou alors d'utiliser ``_). Ainsi, dans notre exemple pour les devoirs d'Histoire, on peut copier le fichier ``histoire.nanorc`` dans ``$HOME/.nano``. Ensuite, il suffit de rajouter les deux lignes suivantes à son fichier ``$HOME/.nanorc`` : :: ## Pour les devoirs d'Histoire include "~/.nano/histoire.nanorc" ------------------------------------------------------------------------------------------------ Le dossier NanoSyntax/ ---------------------- `Ce dossier `_ contient de nombreux fichiers pour la coloration syntaxique via **GNU Nano**, l'éditeur *en ligne de commande* du projet **GNU**. `Ce fichier .nanorc `_ est un bon exemple de fichier de configuration. Le premier paragraphe fixe certaines options de **Nano**, comme l'utilisation du curseur, l'autorisation à suspendre l'édition (``Ctrl+Z``) etc Fichier jouet ~~~~~~~~~~~~~ Le fichier exemple ``histoire.nanorc`` est là ``_. .. image:: histoire.nanorc.png :scale: 100 % :align: center :alt: Nano permet de colorer correctement ses fichiers .nanorc Sources des différents fichiers ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Seuls `ocaml.nanorc `_, `reST.nanorc `_, `.nanorc `_, `python.nanorc `_ ont été modifiés par moi (ils sont sous licence GPL3, voir ``_ pour plus d'infos). Pour les autres, certains viennent des fichiers installés avec le paquet **nano**. D'autres viennent d'une collection de ``.nanorc`` trouvée sur `doc.ubuntu-fr.org `_. Le fichier ``octave.lang`` viens du *Wiki* officiel pour **GNU/Octave** `ici wiki.octave.org/Nano `_. Certains fichiers sont aussi trouvables sur le dépot `github scopatz/nanorc `_. Python ^^^^^^ En particulier, `python.nanorc `_ a été remanié (suite à la demande d'un collègue du **Cr@ns**). reStructuredText ^^^^^^^^^^^^^^^^ En particulier, `reST.nanorc `_ a été créé par moi uniquement pour `ce projet (nouvelles pages web, entièrement avec Sphinx) `_. Je continue de l'améliorer chaque fois que je découvre un nouvel élément de la syntaxe du joli langage qu'est le **reStructuredText**. STRIPS ^^^^^^ Pour mon stage de M1 (en 2013), j'ai travaillé sur le modèle **STRIPS** pour la modélisation d'un monde dynamique. J'ai utilisé ce `solveur strips `_. Et j'ai créé ce fichier `strips.nanorc `_ pour colorer les exemples de modélisations manipulées par le solveur. -------------------------------------------------------------------------------- .. note:: Slap editor ? `Slap `_ est un autre éditeur de code en console. De conception beaucoup plus récente, inspiré de `Sublime Text `_, `codé en Javascript et basé sur Node.js `_. Et il est assez génial ! Autres références ----------------- Si ce sujet vous intéresse, je vous invite à aller jeter un oeil à ces pages là: * `ce message sur la liste de diffusion "caml-list AT inria.fr" `_. * ``_, le même genre de travail, pour l'éditeur **Gedit**, éditeur de code officiel du projet **GNOME**. De nouvelles descriptions de langages pour ``OCaml``, ``Python``, ``rST``, ``CUDA``, ``scala``, ``Octave`` etc. Notamment, ce fichier `rst.lang `_, qui a été élaboré en même temps que `reST.nanorc `_ pour le ``rST``. * `Jota Text Editor `_ (et son fork `Jota + `_) est le meilleur éditeur de code sur téléphone ou tablette **Android**, dont j'ai réalisé une partie de la coloration syntaxique (``OCaml``, ``CUDA`` ainsi que de l'aide pour ``LaTeX``, et récemment ``rST``). Par exemple, ce fichier `mll.mly.mli.ml.conf `_ pour la syntaxe d'``OCaml``. Et ce fichier `rst.reST.rest.conf `_ est pour le ``reStructuredText`` ! Il a été ajouté à Jota depuis la v0.2.31 et à Jota + depuis la v0.3.10 ! Jota et Jota+ ont été téléchargés plus de 7 millions de fois à eux deux ! * `ColorML `_, est un (vieux) projet de parseur, pretty-printer *expérimental* en ``OCaml`` pour colorer du code ``OCaml`` et afficher le résultat dans un terminal. :red:`Plus maintenu mais fonctionne encore !` Me contacter ------------ Si vous avez des questions, des suggestions d'améliorations, ou des bugs (mauvaise coloration par exemple), `n'hésitez pas à me contacter `_ ! .. (c) Lilian Besson, 2011-2021, https://bitbucket.org/lbesson/web-sphinx/