====== Comment mettre en forme du code informatique? ======

Les logiciels qui affichent du code informatique utilisent des couleurs pour rendre les programmes plus lisibles.
Ceci permet de repérer visuellement les mots-clefs du langage, les noms de variables, etc.
Il est possible de faire la même chose avec LaTeX, pour que la structure du code soit soulignée
par la mise en forme. C'est très utile pour les livres sur la programmation, mais aussi pour les travaux des étudiants en informatique.

<note important>
[[4_domaines_specialises:informatique:inclure_un_fichier_en_mode_verbatim|L'inclusion de code «verbatim»]] est traitée ailleurs,
ainsi que [[4_domaines_specialises:informatique:ecrire_du_pseudocode|le problème de la mise en forme des algorithmes]].
</note>

===== Avec l'extension “listings” =====

L'extension [[ctanpkg>listings]] est souvent considérée comme la meilleure solution
pour une sortie mise en forme (elle se charge d'analyser les sources des programmes et
d'utiliser différentes polices de caractères pour en mettre la structure en évidence),
mais il existe plusieurs autres extensions bien établies qui s'appuient sur une sorte de pré-compilateur.
Vous pouvez utiliser [[ctanpkg>listings]] pour mettre en page des extraits que vous incluez dans votre source:

<WRAP column 40ex>
<code latex>
  \usepackage{listings}
  \lstset{language=C}
...
\begin{document}
\begin{lstlisting}
#include <stdio.h>

int main(int argc, char ** argv)
{
  printf("Bonjour tout le monde !\n");
  return 0;
}
\end{lstlisting}
\end{document}
</code>
</WRAP>
<WRAP column>
<latexdoc>
\documentclass{article}
  \usepackage{lmodern}
  \usepackage{listings}
  \lstset{language=C}
  \pagestyle{empty}

\begin{document}
\begin{lstlisting}
#include <stdio.h>

int main(int argc, char ** argv)
{
  printf("Bonjour tout le monde !\n");
  return 0;
}
\end{lstlisting}
\end{document}
</latexdoc>
</WRAP>
<WRAP clear />

mais vous pouvez aussi l'utiliser pour mettre en forme des fichiers entiers:
<WRAP 40ex>
<code latex>
  \usepackage{listings}
  \lstset{language=C}
...
\begin{document}
\lstinputlisting{main.c}
\end{document}
</code>
</WRAP>
<WRAP clear />

Ces exemples très simples peuvent être colorés de diverses façons et, bien sûr,
l'extension comprend beaucoup d'autres langages que le ''C''...


$\Reponse$  Le package [[ctanpkg>listings]] permet de gérer la mise en page
de code source avec notamment la mise en relief de mots-clefs.
L'utilisation de ce package ne nécessite pas de programme annexe,
//i.e.// autre que (La)TeX. On inclut directement le source avec
une commande adéquate (sur une ligne, dans un environnement ou
directement le fichier source). Ce package permet de définir
facilement son propre langage, en le faisant éventuellement hériter
d'un autre, avec des mots-clefs spécifiques, etc.

Cependant, il ne doit pas être souvent utile de définir son langage, vu la
liste sans cesse croissante de langages prédéfinis (''ABAP'', ''ACSL'',
''Ada'', ''Algol'', ''Assembler'', ''Basic'', ''C'', ''C++'', ''Caml'',
''Cobol'', ''Clean'', ''Comal 80'', ''Delphi'', ''Eiffel'', ''Elan'',
''erlang'', ''Fortran'', ''Fortran'', ''GCL'', ''Haskell'', ''HTML'',
''IDL'', ''Java'', ''Lisp'', ''Logo'',''make'', ''Mathematica'', ''Matlab'',
''Mercury'', ''MetaPost'', ''Miranda'', ''Mizar'', ''ML'', ''Modula-2'',
''MuPAD'', ''NASTRAN'', ''Oberon-2'', ''OCL'', ''Octave'', ''Pascal'',
''Perl'', ''PHP'', ''PL/I'', ''POV'', ''Prolog'', ''Python'', ''R'',
''Reduce'', ''Ruby'', ''S'', ''SAS'', ''Scilab'', scripts shell (''csh'', ''ksh'', etc.),
''SHELXL'', ''Simula'', ''SQL'', ''tcl'', <latex>\TeX</latex>,
''VBScript'', ''Verilog'', ''VHDL'', ''VRML'', ''XML'').

L'exemple ci-dessous montre comment il est simple de présenter
du code source avec [[ctanpkg>listings]], ici du Pascal:

<WRAP column 55ex>
<code latex>
\documentclass{article}
  \usepackage{listings}

\begin{document}

\lstset{language=Pascal,literate={:=}{{$\gets$}}1
  {<=}{{$\leq$}}1 {>=}{{$\geq$}}1 {<>}{{$\neq$}}1}

\begin{lstlisting}
program Toto;
  var i : integer;
begin
  if (i<=0) then i := 1;
  if (i>=0) then i := 0;
  if (i<>0) then i := 0;
end.
\end{lstlisting}
\end{document}
</code>
</WRAP>
<WRAP column 30ex>
<latexdoc>
\documentclass{article}
  \usepackage[latin1]{inputenc}
  \usepackage[T1]{fontenc}
  \usepackage{listings}

\begin{document}
\thispagestyle{empty}

\lstset{language=Pascal,literate={:=}{{$\gets$}}1
  {<=}{{$\leq$}}1 {>=}{{$\geq$}}1 {<>}{{$\neq$}}1}

\begin{lstlisting}
program Toto;
  var i : integer;
begin
  if (i<=0) then i := 1;
  if (i>=0) then i := 0;
  if (i<>0) then i := 0;
end.
\end{lstlisting}
\end{document}
</latexdoc>
</WRAP>
<WRAP clear />

<note>
Moyennant quelques paramètres à ajouter, il est tout à fait possible de faire en sorte
que ces packages reconnaissent les fontes 8(nbsp)bits. On peut lui faire comprendre par exemple que,
lorsqu'il rencontre la chaîne « ''mathonesuperior'' », il doit la transformer en ''$\mathonesuperior$''.
</note>

Pendant longtemps, l'extension [[ctanpkg>listings]] a été vue comme la panacée en la matière.
Mais ces dernières années, des alternatives viables sont apparues.

===== Avec l'extension “highlight” =====

[[ctanpkg>highlight|Highlight]] est intéressante si vous avez besoin de plus d'un format de sortie pour votre programme.
En effet, en plus de la sortie (La)TeX, [[ctanpkg>highlight]] pourra produire des représentations (X)HTML, RTF et XSL-FO
de votre code-source. [[http://www.andre-simon.de/doku/highlight/en/highlight.php|Le manuel (en anglais)]] vous sera d'une grande aide
si vous devez écrire le fichier de paramètres pour un nouveau langage, ou modifier la mise en forme d'un langage déjà défini.


===== Avec l'extension “minted” =====

L'extension [[ctanpkg>minted]] est une autre alternative qui permet créer de nouvelles définitions de langage.
Il nécessite que le code soit traité à l'aide d'un script externe, écrit en Python, ''[[https://pygments.org/|Pygments]]''.
Pygments, à son tour, a besoin d'un [[wpfr>Analyse_lexicale|analyseur lexical]] qui connaît le langage que vous voulez utiliser;
il en existe de nombreux, pour les langages les plus utilisés, et il y a aussi des conseils pour écrire le vôtre
sur le site web de ''[[https://pygments.org/docs/lexerdevelopment/|Pygments]]''.

L'usage de [[ctanpkg>minted]] peut être aussi simple que ceci:

<WRAP 40ex>
<code latex>
\begin{minted}{⟨language⟩}
...
\end{minted}
</code>
</WRAP>
<WRAP clear />

qui traite le code du programme à la volée, au moment de la compilation.

<note important>
Cela demande que [[2_programmation:compilation:write18|l'appel aux programmes externes]] soit autorisé.
</note>


$\Reponse$  Le package [[ctanpkg>minted]] est sans doute la solution la plus moderne et flexible.
Il fait appel au package [[ctanpkg>fancyvrb]], mais aussi au programme externe ''[[https://pygments.org/|Pygment]]''
que vous devrez installer séparément.

FIXME Un exemple d'utilisation est donné sur
[[https://bioinfo-fr.net/latex-la-mise-en-forme-du-texte-et-des-paragraphes#crayon-5f0e18eb47226674652384|https://bioinfo-fr.net/]], et un [[https://zestedesavoir.com/tutoriels/1848/presenter-du-code-source-dans-un-document-latex/|tutoriel très détaillé]] existe aussi.


===== Avec l'extension “showexpl” =====

Dans un autre ordre d'idées, le paquetage [[ctanpkg>showexpl]] prend en charge la mise en forme de code (La)TeX et de sa sortie compilée,
dans des «volets» situés en regard l'un de l'autre. C'est notamment utile pour les manuels (La)TeX, ou pour les articles
sur (La)TeX. Le paquetage utilise des [[ctanpkg>listings]] pour le volet (La)TeX, et insère le résultat de la compilation dans une simple boîte,
pour l'autre volet.

===== Autres solutions =====

$\Reponse$  L'extension [[ctanpkg>lgrind]] (qui fournit un exécutable et un fichier de style, ''lgrind.sty'')
permet, entre autres, de formater du code source d'un langage donné en
<latex>\LaTeX</latex>. Parmi les langages reconnus, on trouve : ''Ada'',
''assembleur'', ''BASIC'', ''Batch'', ''C'', ''C++'', ''FORTRAN'',
''GnuPlot'', ''Icon'', ''IDL'', ''ISP'', ''Java'', ''Kimwitu++'',
''ABAP'', ''LaTeX'', ''LDL'', ''Lex'', ''Linda'', ''Lisp'', ''MATLAB'',
''ML'', ''Mercury'', ''model'', ''Modula-2'', ''Pascal'', ''Perl'',
scripts shell, ''PostScript'', ''Prolog'', ''RATFOR'', ''RLaB'', ''Russell'',
''SAS'', ''Scheme'', ''SICStus'', ''src'', ''SQL'', ''Tcl/Tk'', ''VisualBasic'', ''yacc''.

Le programme ''lgrind'' permet à partir du code source de générer du code <latex>\LaTeX</latex>
respectant l'indentation.  Il transforme le source en question, par exemple ''monfichier.c'',
en ''monfichier.tex'', que l'on inclut directement dans son fichier <latex>\LaTeX</latex>,
à l'aide d'une commande appropriée (voir
«[[3_composition/texte/document/decouper_un_document_en_plusieurs_fichiers|Comment découper un document en plusieurs fichiers?]]»).
L'inconvénient est qu'évidemment, il y a un fichier ''.tex'' qui est généré en plus.

L'exemple ci-dessous présente le code <latex>\LaTeX</latex> produit par
''lgrind'' pour le même code souce Pascal que dans l'exemple précédent
(aux changements de ligne près).

<note>
  * Utiliser au-moins la version 3.6;
  * on peut paramétrer [[ctanpkg>lgrind]] avec le fichier ''lgrindef''.
  * Par défaut, l'auteur a jugé utile de transformer la lettre «à» en $\alpha$. Il suffit donc de commenter cette option à la fin de ce fichier pour éviter cela.
</note>


Résultat produit par ''lgrind'':

<code latex>
\documentclass{article}
  \usepackage[latin1]{inputenc}
  \usepackage[T1]{fontenc}

  \usepackage[procnames,noindent]{lgrind}
  \usepackage{fancyhdr,a4wide}
  \usepackage{german}
  \usepackage{makeidx}
  \pagestyle{fancy}

\makeindex

\begin{document}
\thispagestyle{empty}

\renewcommand{\footrulewidth}{0.4pt}
\fancyhead[C]{\lgrindhead}
\fancyhead[LO,RE]{\lgrindfilesize~Bytes\\%
\lgrindmodtime}
\fancyhead[RO,LE]{\bfseries \lgrindfilename\\%
\lgrindmodday.\lgrindmodmonth.\lgrindmodyear}
\fancyfoot[C]{\bfseries\thepage}
\setlength{\headheight}{24pt}
\begin{lgrind}
\BGfont
\File{toto.p}{2004}{2}{18}{16:08}{119}
\L{\LB{\K{program}_\V{Toto};}}
\L{\LB{}\Tab{2}{\K{var}_\V{i}_:_\V{integer};}}
\L{\LB{\K{begin}}}
\L{\LB{}\Tab{2}%
{\K{if}_(\V{i}\<=\N{0})_\K{then}_\V{i}_:=_\N{1};}}
\L{\LB{}\Tab{2}%
{\K{if}_(\V{i}\>=\N{0})_\K{then}_\V{i}_:=_\N{0};}}
\L{\LB{}\Tab{2}%
{\K{if}_(\V{i}\<\>\N{0})_\K{then}_\V{i}_:=_\N{0};}}
\L{\LB{\K{end.}}}
\end{lgrind}
\printindex
\end{document}
</code>



$\Reponse$  Le package [[ctanpkg>tinyc2l]] est un convertisseur de code ''C'', ''C++'' ou ''Java''
en <latex>\LaTeX</latex>. Il numérote les lignes, traduit ''!='' en $\neq$, gère les commentaires,
les en-têtes de procédures, etc. Il supporte plusieurs fichiers d'entrée et gère automatiquement les
changements de section et la génération d'index.


===== Solutions anciennes =====

$\Reponse$  Le package [[ctanpkg>c++2latex|c++2latex]], sous licence GPL, est capable de
convertir des fichiers C, C++ ou JAVA en <latex>\LaTeXe</latex>.
Les lignes peuvent être numérotées. Une ancienne version est disponible sur le CTAN: [[http://tug.ctan.org/support/C++2LaTeX-1_1pl1/]],
et ses mises à jour sont [[http://www.arnoldarts.de/cpp2latex/|sur le site web de l'auteur]].


$\Reponse$  ''cvt2ltx'', disponible sur [[ftp://axp3.sv.fh-mannheim.de/cvt2latex/cvt2ltx.zip]]
est une famille de convertisseurs code source vers <latex>\LaTeX</latex> pour les langages
C, C++, IDL et Perl.

FIXME Est-il intéressant de parler de cvt2ltx ? Je n'ai même pas réussi à le compiler.

Voici quelques autres systèmes plus anciens (et moins «puissants»):

  * Le système [[ctanpkg>lgrind]] est un précompilateur bien établi, avec toutes les facilités dont on peut avoir besoin et un vaste répertoire de langages supportés; il est dérivé du système [[ctanpkg>tgrind]], encore plus ancien, dont la sortie était basée sur Plain TeX.
  * Le système [[ctanpkg>tinyc2l]] est un peu plus récent: les utilisateurs sont encore encouragés à écrire leurs propres pilotes pour les langages qu'il ne supporte pas encore, mais le « //tiny// » dans son nom indique à juste titre qu'il ne s'agit pas d'un système spécialement élaboré.
  * [[http://www.arnoldarts.de/cpp2latex/|C++2LaTeX]] est clairement orienté vers une utilisation avec ''C'' et ''C++''.
  * Un système extrêmement simple est [[ctanpkg>c2latex]], avec lequel vous écrivez votre source LaTeX dans les commentaires de votre programme ''C'' (un peu dans la logique du //[[5_fichiers:web:literate_programming|literate programming]]//). Le programme convertit ensuite votre programme en un fichier LaTeX prêt à être compilé. Le programme est censé être "auto-documenté".


-----
//Source:// [[faquk>FAQ-codelist|Code listings in LaTeX]]

{{htmlmetatags>metatag-keywords=(LaTeX,langages de programmation,mise en forme de code,coloration syntaxiquenformater un programme,formater du code,verbatim,insérer du code-source)
metatag-og:title=(Comment mettre en forme du code informatique?)
metatag-og:site_name=(FAQ LaTeX francophone)
}}