% -*- coding: utf-8 ; -*-
\documentclass[dvipsnames,svgnames]{article}

\usepackage{fontspec}

\usepackage{polyglossia}
\setmainlanguage{french}

\usepackage[footnotehyper]{piton}
\PitonOptions
  {
    splittable = 4 ,
    math-comments,
    begin-escape = ? ,
    end-escape = ? ,
    begin-escape-math = \( , 
    end-escape-math = \) ,
    detected-commands =  { \highLight , \footnote , \emph , \textsl , \textbackslash } ,
    vertical-detected-commands = \newpage ,
    raw-detected-commands = { \NomTable , \rowcolor } ,
  }


\ExplSyntaxOn

\dim_new:N \l__pantigny_width_dim 

\keys_define:nn { pantigny }
  { width .dim_set:N = \l__pantigny_width_dim }

\NewPitonEnvironment { Code } { O { } }
  {
    \SetPitonStyle{ Number = , Comment = , String = }
    \PitonOptions{language = minimal}
    \char_set_catcode_other:N |
    \cs_set_eq:NN \emph \emphase
    \dim_zero:N \l__pantigny_width_dim 
    \keys_set:nn { pantigny } { #1 }
    \color{gray}
    \dim_compare:nNnT \l__pantigny_width_dim > \c_zero_dim 
      { 
        \PitonOptions { width = \l__pantigny_width_dim } 
        \begin{minipage}[c]{\l__pantigny_width_dim} 
      }
  }
  { \dim_compare:nNnT \l__pantigny_width_dim > \c_zero_dim 
      { \end{minipage} }
  }

\ExplSyntaxOff  


\usepackage[executable=python3.exe]{pyluatex}

\usepackage{xcolor}

\usepackage{geometry}
\geometry{left=2.8cm,right=2.8cm,top=2.5cm,bottom=2.5cm,papersize={21cm,29.7cm}}

\usepackage{enumitem}
\usepackage{verbatim}
\usepackage{amsmath}
\usepackage{tabularx}
\usepackage{booktabs}
\usepackage[framemethod=tikz]{mdframed}
\usepackage{tcolorbox}
\tcbuselibrary{skins,breakable}
\tcbset{enhanced}

\usepackage{luacolor,lua-ul}
\usepackage{caption}

% We use \MakeShortVerb of shortvrb and not \DefineShortVerb of fancyvrb
% because we don't want the contents of short verbatim colored in gray
\usepackage{shortvrb}
\MakeShortVerb{\|}

\usepackage{varwidth}

\skip\footins = 2\bigskipamount

\usepackage{fancyvrb}
\fvset{commandchars=\~\#\@,formatcom=\color{gray}}
\def\emphase{\bgroup\color{RoyalPurple}\let\next=}


\usepackage{titlesec}
\titlespacing*{\section}{0pt}{6.5ex plus 1ex minus .2ex}{4.3ex plus .2ex}
\titlespacing*{\subsection}{0pt}{4.5ex plus 1ex minus .2ex}{2ex plus .2ex}

\def\interitem{\vspace{7mm plus 2 mm minus 3mm}}          


\usepackage[hyperfootnotes = false]{hyperref}
\usepackage{bookmark}

\hypersetup
  {
    pdfinfo = 
      {
        Title = L’extension piton ,
        Subject = Une extension LaTeX ,
        Author = F. Pantigny 
      }
  } 

\usepackage{makeidx}
\makeindex

\usepackage{underscore}

\NewDocumentCommand{\Definition}{m}
  {{\setlength{\fboxsep}{1pt}\colorbox{gray!20}{\ttfamily \vphantom{gl}#1}}}

\NewDocumentCommand{\DefinitionCommand}{m}
  {{\setlength{\fboxsep}{1pt}\colorbox{gray!20}{\ttfamily
        \vphantom{gl}\textbackslash #1}}}


\NewDocumentCommand{\indexcommand}{m}{\index{#1@\texttt{\textbackslash #1}}}

\NewDocumentCommand{\indexenv}{m}{\index{#1@\texttt{\{#1\}}}}


\NewDocumentCommand {\pkg} {m} {\textsf{#1}}
\NewDocumentCommand {\cls} {m} {\textsf{#1}}

\setlength{\parindent}{0pt}

\newcommand{\CC}{{C\nolinebreak[4]\hspace{-.05em}\raisebox{.4ex}{\tiny\bfseries ++}}}

\begin{document}



\UseName{VerbatimFootnotes}


\title{L'extension LaTeX \pkg{piton}\thanks{Ce document correspond à la 
version~\PitonFileVersion\space de \pkg{piton}, à la date du~\PitonFileDate.}} 
\author{F. Pantigny \\ \texttt{fpantigny@wanadoo.fr}}

\maketitle

\begin{abstract}
L'extension \pkg{piton} propose des outils pour composer des codes informatiques avec
coloration syntaxique. Elle nécessite l'emploi de la LuaLaTeX car le travail principal est
fait en utilisant la bibliothèque Lua LPEG.
\end{abstract}


\section{Présentation}



L'extension \pkg{piton} utilise la librairie Lua nommée LPEG\footnote{LPEG est
  une librairie de capture de motifs (\emph{pattern-matching} en anglais) pour
  Lua, écrite en C, fondée sur les PEG (\emph{parsing expression grammars}):
  \url{http://www.inf.puc-rio.br/~roberto/lpeg/}} pour «parser» des listings
informatiques avec coloriage syntaxique. Comme elle utilise le Lua de LuaLaTeX,
elle fonctionne uniquement avec |lualatex| (et ne va pas fonctionner avec les
autres moteurs de compilation LaTeX, que ce soit |latex|, |pdflatex| ou
|xelatex|). Elle n'utilise aucun programme extérieur et donc, a fortiori, elle
ne requiert pas l'utilisation de |--shell-escape| lors de la compilation. La
compilation est très rapide puisque tout le travail du parseur est fait par la
librairie LPEG, écrite en C.

\medskip
Voici un exemple de code Python composé avec l'environnement |{Piton}|
proposé par \pkg{piton}.


\medskip
\begin{Piton}
from math import pi

def arctan(x,n:int=10):
    """Calcule la valeur mathématique de arctan(x)

    n est le nombre de termes de la somme
    """
    if x < 0:
        return -arctan(-x) # appel récursif
    elif x > 1: 
        return pi/2 - arctan(1/x) 
        #> (on a utilisé le fait que $\arctan(x)+\arctan(1/x)=\pi/2$ pour $x>0$)\footnote{Cet échappement vers LaTeX a été obtenu en débutant par \ttfamily\#>.} 
    else: 
        s = 0
        for k in range(n):
            s += (-1)**k/(2*k+1)*x**(2*k+1)
        return s
\end{Piton}

\medskip
Les principaux concurrents de l'extension \pkg{piton} sont certainement les extensions
bien connues \pkg{listings} et \pkg{minted}.


\medskip
Le nom de cette extension (\pkg{piton}) a été choisi un peu arbitrairement en référence
aux pitons d'alpinisme qui servent à gravir les montagnes.


L'extension \pkg{piton} se compose de deux fichiers : |piton.sty| et |piton.lua| (le
fichier LaTeX |piton.sty| chargé par |\usepackage| va à son tour charger le fichier
|piton.lua|). Les deux fichiers doivent être présents dans un répertoire où LaTeX pourra
les trouver, de préférence dans une arborescence |texmf|. Le mieux reste néanmoins
d'installer \pkg{piton} avec une distribution TeX comme MiKTeX, TeX~Live ou MacTeX.

\medskip
On remarquera que le caractère \emph{quote} (U+0027 : \verb|'|) n'est jamais converti
par \pkg{piton} en l'apostrophe U+2019. Il n'y a pas besoin de charger l'extension
\pkg{upquote}.



\section{Utilisation de l'extension}

L'extension \pkg{piton} doit être utilisée avec \textbf{LuaLaTeX exclusivement}
: si un autre moteur de compilation (comme |latex|, |pdflatex| ou |xelatex|) est
utilisé, une erreur fatale sera levée.


\subsection{Choix du langage}

Les langages informatiques pris en charge par \pkg{piton} se classent en deux catégories :
\begin{itemize}
\item les langages reconnus nativement par \pkg{piton} qui sont au
nombre de quatre : Python, OCaml, SQL, C (ou plutôt \CC) plus deux
langages minimalistes nommés |minimal|\footnote{Le langage |minimal|
  peut servir pour formater du pseudo-code :
  cf.~p.~\pageref{minimal}.} et |verbatim|;
\item les langages définis par l'utilisateur avec la commande |\NewPitonLanguage| décrite
p.~\pageref{NewPitonLanguage} (les parseurs de ces langages ne pourront jamais être aussi
précis que ceux proposés nativement par \pkg{piton)}.
\end{itemize}


\smallskip
Par défaut, le langage est Python.

\smallskip
\index{language (clé)}
On peut changer de langage avec la clé \Definition{language} de |\PitonOptions| : 

\smallskip
|\PitonOptions{language = OCaml}|

\smallskip
En fait, le nom des langages, pour \pkg{piton}, est toujours \textbf{insensible à la
  casse}. Dans cet exemple, on aurait tout aussi bien pu écrire |Ocaml| ou |ocaml|.

\smallskip
Pour les développeurs, précisons que le nom du langage courant est stocké (en minuscules)
dans la variable publique L3 nommée |\l_piton_language_str|.

\smallskip
Dans la suite de ce document, on parlera préférentiellement de Python mais les
fonctionnalités s'appliquent aussi aux autres langages.



\subsection{Chargement de l'extension}


L'extension \pkg{piton} se charge simplement avec |\usepackage{piton}|.

\smallskip
Elle utilise et charge l'extension \pkg{xcolor}. Elle n'utilise pas de programme
extérieur. 

\subsection{Les commandes et environnements à la disposition de l'utilisateur}

\indexenv{Piton}

L'extension \pkg{piton} fournit plusieurs outils pour composer du code informatique : la
commande |\piton|, l'environnement |{Piton}| et la commande |\PitonInputFile|.

\begin{itemize} 
\item La commande \DefinitionCommand{piton} doit être utilisée
pour composer de petits éléments de code à l'intérieur d'un paragraphe. Par exemple :

{\color{gray}\verb|\piton{def carré(x): return x*x}|}\qquad 
\piton{def carré(x): return x*x}

La syntaxe et les particularités de la commande sont détaillées ci-après.


\item L'environnement \Definition{\{Piton\}} doit être utilisé pour composer des
codes de plusieurs lignes. Comme cet environnement prend son argument selon un
mode verbatim, il ne peut pas être utilisé dans l'argument d'une commande LaTeX.
Pour les besoins de personnalisation, il est possible de définir de nouveaux
environnements similaires à |{Piton}| en utilisant la commande
\DefinitionCommand{NewPitonEnvironment} ou ses variantes :
cf.~partie~\ref{NewPitonEnvironment} p.~\pageref{NewPitonEnvironment}.

\item La commande \DefinitionCommand{PitonInputFile} doit être utilisée pour insérer et
composer un fichier externe : cf.~partie~\ref{PitonInputFile},
p.~\pageref{PitonInputFile}.
\end{itemize}


\subsection{La double syntaxe de la commande \texttt{\textbackslash piton}}

\indexcommand{piton}

La commande |\piton| possède en fait une double syntaxe. Elle est peut être utilisée comme
une commande standard de LaTeX prenant son argument entre accolades (|\piton{...}|), ou
bien selon la syntaxe de la commande
\texttt{\textbackslash verb} de LaTeX où l'argument est délimité entre deux caractères 
identiques (par ex. : \verb!\piton|...|! ou \verb!\piton+...+!).
On détaille maintenant ces deux syntaxes.

\bigskip
\begin{itemize}
\item {\color{blue} \textsf{Syntaxe} \verb|\piton{...}|}

\nobreak
Quand son argument est donné entre accolades, la commande |\piton| ne prend \emph{pas} son
argument en mode verbatim. Les points suivants doivent être remarqués :

\begin{itemize}
\item plusieurs espaces successives sont remplacées par une unique espace, ainsi que les
retours à la ligne

{\color{cyan} mais la commande |\|␣ est fournie pour forcer l'insertion d'une espace} ;

\item il n'est pas possible d'utiliser le caractère |%| à l'intérieur, 

{\color{cyan} mais la commande |\%| est fournie pour insérer un |%|} ;

\item les accolades doivent apparaître par paires correctement imbriquées, 

{\color{cyan} mais les commandes |\{| et |\}| sont aussi fournies pour insérer des
  accolades individuelles} ;

\item les commandes LaTeX\footnote{Cela s'applique aux commandes commençant par
  une contre-oblique |\| mais également aux caractères actifs, c'est-à-dire ceux
  de catcode~13.} de l'argument de |\piton| sont complètement développées (au sens de TeX)
  sans être exécutées

{\color{cyan} et on peut donc utiliser |\\| pour insérer une contre-oblique}.
\end{itemize}

Les autres caractères (y compris |#|, |^|, |_|, |&|, |$| % $
et |@|) doivent être insérés sans contre-oblique.

\bigskip
\begin{tabular}{>{\color{gray}}w{l}{75mm}@{\hspace*{1cm}}l}
\omit Exemples : \hfil \\
\noalign{\vskip1mm}
\verb|\piton{ma_chaîne = '\\n'}| & 
\piton{ma_chaîne = '\\n' } \\
\verb|\piton{def pair(n): return n\%2==0}| & 
\piton{def pair(n): return n\%2==0 } \\
\verb|\piton{c="#"    # une affectation }| & 
\piton{c="#"     # une affectation } \\
\verb|\piton{c="#" \ \ \ # une affectation }| & 
\piton{c="#" \ \ \ # une affectation } \\
\verb|\piton{my_dict = {'a': 3, 'b': 4}}| &
\piton{my_dict = {'a': 3, 'b': 4}}
\end{tabular}

\bigskip
La commande |\piton| avec son argument entre accolades peut être utilisée dans les
arguments des autres commandes LaTeX.\footnote{La commande |\piton| peut par exemple être
utilisée dans une note de bas de page. Exemple : \piton{x = 123}.}

En revanche, comme son argument subit un développement (au sens de TeX), il faut prendre 
soin à ne pas utiliser dans son argument de commandes fragiles (c'est-à-dire des commandes
qui ne sont ni \emph{protected} ni \emph{fully expandable}).

\bigskip
\item {\color{blue} \textsf{Syntaxe} \verb!\piton|...|!}

\nobreak
Quand la commande |\piton| prend son argument entre deux caractères identiques (tous les
caractères sont autorisés sauf |%|, 
|\|, |#|, |{|, |}| et l'espace), cet argument est pris \emph{en mode verbatim}. De ce
fait, avec cette syntaxe, la commande |\piton| ne peut \emph{pas} être utilisée dans
l'argument d'une autre fonction. 

\medskip
\begin{tabular}{>{\color{gray}}w{l}{75mm}@{\hspace*{1cm}}l}
\omit Exemples : \hfil \\
\noalign{\vskip1mm}
\verb!\piton|ma_chaîne = '\n'|! & 
\piton|ma_chaîne = '\n'| \\
\verb|\piton!def pair(n): return n%2==0!| & 
\piton!def pair(n): return n%2==0! \\
\verb|\piton+c="#"    # une affectation +| & 
\piton+c="#"     # une affectation + \\
\verb|\piton?my_dict = {'a': 3, 'b': 4}?| &
\piton!my_dict = {'a': 3, 'b': 4}!
\end{tabular}

\end{itemize}



\section{Personnalisation}


\subsection{Les clés de la commande \texttt{\textbackslash PitonOptions}}


\indexcommand{PitonOptions}

La commande |\PitonOptions| prend en argument une liste de couples \textsl{clé=valeur}. La
portée des réglages effectués par cette commande est le groupe TeX courant.\footnote{On
  rappelle que tout environnement LaTeX est, en particulier, un groupe.}

Ces clés peuvent aussi être appliquées à un environnement |{Piton}| individuel (entre
crochets).

\begin{itemize}
\item La clé \Definition{language} spécifie le langage informatique considéré (la casse
n'est pas prise en compte). On peut choisir l'un des six langages prédéfinis (|Python|,
|OCaml|, |C|, |SQL|, |minimal| et |verbatim|) ou bien le nom d'un langage défini par
l'utilisateur avec |\NewPitonLanguage| (voir partie~\ref{NewPitonLanguage},
p.~\pageref{NewPitonLanguage}). 

La valeur initiale est |Python|.

\item \index{font-command} La clé \Definition{font-command} contient des
instructions de fonte qui seront insérées au début de chaque élément formaté par
\pkg{piton}, que ce soit avec la commande |\piton|, l'environnement |{Piton}| ou
bien la commande |\PitonInputFile| (il n'y a que les «commentaires LaTeX» pour
lesquels ces instructions de fonte ne sont pas utilisées).

La valeur initiale de ce paramètre |font-command| est |\ttfamily|, ce qui fait,
que, par défaut, \pkg{piton} utilise la fonte mono-chasse courante.

Cette clé possède aussi une syntaxe additive avec, c'est-à-dire que l'on peut
écrire : |font-command +=| $\langle$\textsl{instructions}$\rangle$. Les
tokens $\langle$\textsl{instructions}$\rangle$ sont alors ajoutées à droite
de la valeur courante du paramètre.


\item \index{gobble}\label{gobble} La clé \Definition{gobble} prend comme valeur
un entier positif $n$ : les $n$ premiers caractères de chaque ligne sont alors
retirés (avant formatage du code) dans les environnements |{Piton}|. Ces $n$
caractères ne sont pas nécessairement des espaces.

Quand la clé |gobble| est utilisée sans valeur, elle se comporte comme la clé
|auto-gobble|, que l'on décrit maintenant.

\item \index{auto-gobble}\index{gobble!auto-gobble} Quand la clé
\Definition{auto-gobble} est activée, l'extension \pkg{piton} détermine la
valeur minimale $n$ du nombre d'espaces successifs débutant chaque ligne (non
vide) de l'environnement |{Piton}| et applique |gobble| avec cette valeur
de~$n$.

\item \index{env-gobble}\index{gobble!env-gobble} Quand la clé
\Definition{env-gobble} est activée, \pkg{piton} analyse la dernière ligne de
l'environnement, c'est-à-dire celle qui contient le \texttt{\textbackslash
  end\{Piton\}} et détermine si cette ligne ne comporte que des espaces suivis
par \texttt{\textbackslash end\{Piton\}}. Si c'est le cas, \pkg{piton} calcule
le nombre $n$ de ces espaces et applique |gobble| avec cette valeur de~$n$. Le
nom de cette clé vient de \emph{environment gobble}: le nombre d'espaces à
retirer ne dépend que de la position des délimiteurs |\begin{Piton}| et
\texttt{\textbackslash end\{Piton\}} de l'environnement.


\item \index{line-numbers} La clé \Definition{line-numbers} active la
numérotation des lignes (en débordement à gauche) dans les environnements
|{Piton}| et dans les listings produits par la commande |\PitonInputFile|.

Cette clé propose en fait plusieurs sous-clés.
\begin{itemize}
\item La clé \Definition{line-numbers/skip-empty-lines} demande que les lignes
vides (qui ne contiennent que des espaces) soient considérées comme non
existantes en ce qui concerne la numérotation des lignes (si la clé |/absolute|,
décrite plus bas, est active, la clé |/skip-empty-lines| n'a pas d'effet dans
|\PitonInputFile|). La valeur initiale de cette clé est |true| (et non
|false|).\footnote{Avec le langage Python, les lignes vides des
  \emph{docstrings} sont prises en compte.}


\item La clé \Definition{line-numbers/label-empty-lines} demande que les labels
(les numéros) des lignes vides soient affichés. Si la clé |/skip-empty-lines|
est active, la clé |/label-empty-lines| est sans effet. La valeur initiale de
cette clé est |true|.\footnote{Quand la clé |split-on-empty-lines| est activée,
  les labels des lignes vides ne sont jamais imprimés.}

\item La clé \Definition{line-numbers/step} doit être utilisée quand on ne veut
pas faire afficher tous les numéros de ligne. Si $n$ est la valeur de cette clé,
les numéros ne seront affichés que de~$n$ en~$n$. Bien sûr, la valeur initiale
vaut~$1$.

\item La clé \Definition{line-numbers/absolute} demande, pour les listings
générés par |\PitonInputFile|, que les numéros de lignes affichés soient absolus
(c'est-à-dire ceux du fichier d'origine). Elle n'a d'intérêt que si on n'insère
qu'une partie du fichier (cf. partie~\ref{part-of-a-file},
p.~\pageref{part-of-a-file}). La clé |/absolute| est sans effet dans les
environnements |{Piton}|.

\item La clé \Definition{line-numbers/resume} reprend la numérotation là où elle
avait été laissée au dernier listing. En fait, la clé |line-numbers/resume| a un
alias, qui est |resume| tout court (car on peut être amené à l'utiliser
souvent).

\item La clé \Definition{line-numbers/start} impose que la numérotation commence
à ce numéro.

\item La clé \Definition{line-numbers/sep} est la distance horizontale entre les
numéros de lignes (insérés par |line-numbers|) et les lignes du code
informatique. La valeur initiale est 0.7~em.

\item La clé \Definition{line-numbers/format} est une liste de tokens qui est
insérée avant le numéro de ligne pour le formater. Il est possible de mettre
\emph{en dernière position} de cette liste une commande LaTeX à un argument
comme |\fbox|.

La valeur initiale est |\footnotesize \color{gray}|.


\item \colorbox{yellow!50}{\textbf{Nouveau 4.11}}

\nobreak
La clé \Definition{line-numbers/position} indique la position des numéros : à
gauche, avec la valeur |left| ou bien à droite avec la valeur |right|. La valeur
initiale est |left|.


\item \colorbox{yellow!50}{\textbf{Nouveau 4.13}}

\nobreak
Avec la clé \Definition{line-numbers/lmmono10-drawn}, les numéros de lines
utilisent la fonte \emph{Latin Modern Mono 10} mais les chiffres sont dessinés
et non affichés comme du texte. Ainsi, lors d'un copier-coller, les lecteurs de
\textsc{pdf} ne captureront pas ces numéros de lignes.

\end{itemize}

Pour la commodité, un dispositif de factorisation du préfixe |line-numbers| est
disponible, c'est-à-dire que l'on peut écrire, par exemple :

\begin{Code}
\PitonOptions
  {
    line-numbers = 
      { 
        skip-empty-lines = false ,
        label-empty-lines = false ,
        sep = 1 em ,
        format = \footnotesize \color{blue}
      }
  }
\end{Code}

Attention : le code précédent ne suffit pas à activer l'affichage des numéros de
ligne. Pour cela, il faut encore utiliser la clé |line-numbers| de manière absolue
(c'est-à-dire sans valeur).

\item \index{left-margin} La clé \Definition{left-margin} fixe une marge sur la
gauche. Cette clé peut être utile, en particulier, en conjonction avec la clé
|line-numbers| si on ne souhaite pas que les numéros de ligne soient dans une
position en débordement sur la gauche.


Il est possible de donner à la clé |left-margin| la valeur spéciale~|auto|. Avec
cette valeur, une marge est insérée automatiquement pour les numéros de ligne
quand la clé |line-numbers| est utilisée. Voir un exemple à la partie
\ref{example-numbering} p.~\pageref{example-numbering}.

\item \index{right-margin}
\colorbox{yellow!50}{\textbf{New 4.11}}

\nobreak
La clé \Definition{right-margin} est similaire à la
clé précédente, mais pour la marge de droite.

\item \index{background-color} \label{background-color} La clé
\Definition{background-color} fixe la couleur de fond des environnements
|{Piton}| et des listings produits par |\PitonInputFile| (ce fond a une largeur
que l'on peut fixer avec la clé |width| ou la clé |max-width| décrites
ci-dessous).

La clé |background-color| accepte une couleur définie
«à la volée», c'est-à-dire que l'on peut écrire par exemple
|background-color = [cmyk]{0.1,0.05,0,0}|

\smallskip
La clé |background-color| accepte aussi en argument une \emph{liste} de
couleurs. Les lignes sont alors coloriées de manière cyclique avec ces couleurs.

\smallskip
Dans cette liste, la couleur spéciale \Definition{none} désigne une absence de couleur.

\emph{Exemple} : |\PitonOptions{background-color = {gray!5,none}}|

\item \index{rounded-corners} 
On peut utiliser \Definition{rounded-corners} pour demander des coins arrondis
pour les fonds colorés spécifiés par |background-color|. La valeur initiale de
ce paramètre est $0$~pt, ce qui fait que les coins ne sont pas arrondis. Si on
utilise la clé |rounded-corners|, l'extension \pkg{tikz} doit être chargée car
ces coins arrondis sont tracés avec \pkg{tikz}. Si \pkg{tikz} n'est pas chargé,
une erreur sera levée à la première utilisation de la clé |rounded-corners|.

La valeur par défaut de |rounded-corners| vaut $4$~pt.\footnote{Cette valeur par
  défaut est la valeur initiale des \emph{rounded corners} de \pkg{tikz}.}


\item \index{prompt-background-color} Avec la clé
\Definition{prompt-background-color}, \pkg{piton} ajoute un fond coloré aux
lignes débutant par le prompt «|>>>|» (et sa continuation «|...|»)
caractéristique des consoles Python avec boucle \textsc{repl}
(\emph{read-eval-print loop}). Pour un exemple d'utilisation de cette clé, voir
la partie \ref{python} p.~\pageref{python}.

La valeurs initiale est : |gray!15|


\item \index{width (clé)} \label{width} La clé \Definition{width} fixe la largeur du
listing produit. La valeur initiale de ce paramètre est la valeur courante de
|\linewidth| (paramètre LaTeX qui indique la largeur courante des lignes de texte).

Ce paramètre est utilisé pour :
\begin{itemize}
\item couper les lignes trop longues (sauf, bien sûr, quand la clé |break-lines| est
mise à |false|: cf. p.~\pageref{line-breaks}) ;
\item les fonds colorés spécifiés par les clés |background-color| et
|prompt-background-color| ;
\item les fonds colorés tracés par la clé |\rowcolor|
(cf.~p.~\pageref{rowcolor});
\item la largeur de la boîte LaTeX créée par la clé |box| (cf. p.~\pageref{box}) ;
\item la largeur de la boîte graphique créée par la clé |tcolorbox|
(cf. p.~\pageref{tcolorbox}).
\end{itemize}

\item \index{max-width (clé)} 
La clé \Definition{max-width} est similaire à la clé |width| mais elle fixe la
largeur maximale des lignes. Si les lignes du listings sont toutes plus courtes
que la valeur fournie à |max-width|, la largeur (qui sera transmise au paramètre
|width|) sera la largeur maximale des lignes du listing, c'est-à-dire la largeur naturelle
du listing.

Pour la lisibilité du code, |width=min| est un raccourci pour |max-width=\linewidth|.

\item \index{show-spaces-in-strings} En activant la clé
\Definition{show-spaces-in-strings}, les espaces dans les chaînes de
caractères\footnote{Pour le langage Python, cela ne s'applique que pour les chaînes
  courtes, c'est-à-dire celles délimitées par~\verb|'| ou~\verb|"| et, en particulier,
  cela ne s'applique pas pour les \emph{doc strings}. En OCaml, cela ne s'applique pas
  pour les \emph{quoted strings}.} sont matérialisés par le caractère ␣ (U+2423 :
\textsc{open box}). Bien sûr, le caractère U+2423 doit être présent
dans la fonte mono-chasse utilisée.\footnote{La valeur initiale de |font-command| est
  |\ttfamily| ce qui fait que, par défaut, l'extension \pkg{piton} utilise simplement la
  fonte mono-chasse courante.}

\nobreak
\begingroup
\PitonOptions{show-spaces-in-strings}
Exemple : \piton{my_string = 'Très bonne réponse'}
\endgroup

\item \index{show-spaces} Avec la clé \Definition{show-spaces}, tous les espaces
sont matérialisés par le caractère ␣ (et aucune coupure de ligne ne peut plus
intervenir sur ces espaces matérialisés, même quand la clé
|break-lines|\footnote{cf. \ref{line-breaks} p.~\pageref{line-breaks}.} est
active). Il faut néanmoins remarquer que les espaces en fin de ligne sont tous
supprimés par \pkg{piton} --- et ne seront donc pas représentés par~␣. Pour leur
part, quand la clé |show-spaces| est active, les tabulations de début de ligne
sont représentées par des flèches.
\end{itemize}

\bigskip
\begin{small}
\begin{Verbatim}
~emphase#\begin{Piton}[language=C,line-numbers,gobble,background-color=gray!15@
~emphase#              rounded-corners,width=min,splittable=4]@
    void bubbleSort(int arr[], int n) {
        int temp;
        int swapped;
        for (int i = 0; i < n-1; i++) {
            swapped = 0;
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = 1; 
                }
            }
            if (!swapped) break;
        }
    }   
~emphase#~textbackslash#@end{Piton}@
\end{Verbatim}
\end{small}


\begin{Piton}[language=C,line-numbers,gobble,
  background-color = gray!15,rounded-corners,width=min]
    void bubbleSort(int arr[], int n) {
        int temp;
        int swapped;
        for (int i = 0; i < n-1; i++) {
            swapped = 0;
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = 1; 
                }
            }
            if (!swapped) break;
        }
    }   
\end{Piton}


\bigskip
La commande |\PitonOptions| propose d'autres clés qui seront décrites plus loin (voir en
particulier la coupure des pages et des lignes p.~\pageref{breakable}).



\subsection{Les styles}

\label{styles}
\index{styles (concept de \pkg{piton})}

\subsubsection{Notion de style}

L'extension \pkg{piton} fournit la commande |\SetPitonStyle| pour personnaliser les
différents styles utilisés pour formater les éléments syntaxiques des listings
informatiques. Ces personnalisations ont une portée qui correspond au groupe TeX
courant.\footnote{On rappelle que tout environnement LaTeX est, en particulier, un
  groupe.}

\bigskip
\indexcommand{SetPitonStyle} La commande |\SetPitonStyle| prend en argument une liste de
couples \textsl{clé=valeur}. Les clés sont les noms des styles et les valeurs sont les
instructions LaTeX de formatage correspondantes.

\bigskip
Ces instructions LaTeX doivent être des instructions de formatage du type de |\bfseries|,
|\slshape|, |\color{...}|, etc. (les commandes de ce type sont parfois
qualifiées de \emph{semi-globales}). Il est aussi possible de mettre, \emph{à la fin de la liste
  d'instructions}, une commande LaTeX prenant exactement un argument.

\bigskip
Voici un exemple qui change le style utilisé pour le nom d'une fonction Python, au moment
de sa définition (c'est-à-dire après le mot-clé |def|). Elle utilise la commande
|\highLight| de \pkg{lua-ul} (qui nécessite lui-même le chargement de \pkg{luacolor}).

\medskip
\begin{Code}
\SetPitonStyle
  { Name.Function = \bfseries \highLight[red!30] }
\end{Code}

Ici, |\highLight[red!30]| doit être considéré comme le nom d'une fonction LaTeX qui prend
exactement un argument, puisque, habituellement, elle est utilisée avec
|\highLight[red!30]{|\texttt{\slshape text}|}|.

\medskip
\begingroup
\SetPitonStyle 
  { Name.Function = \bfseries \highLight[red!30] }
Avec ce réglage, on obtient : \piton{def cube(x) : return x * x * x }
\endgroup

\bigskip
L'usage des différents styles suivant le langage informatique considéré est décrit dans la
partie \ref{Semantic}, à partir de la page \pageref{Semantic}.


\bigskip
\indexcommand{PitonStyle} La commande \DefinitionCommand{PitonStyle} prend en argument le
nom d'un style et permet de récupérer la valeur (en tant que liste d'instructions LaTeX)
de ce style. Cette commande est «complètement développable» au sens de TeX.

\smallskip
Par exemple, on peut écrire, dans le texte courant, |{\PitonStyle{Keyword}{function}}| et
on aura le mot {\PitonStyle{Keyword}{function}} formaté comme un mot-clé.

\smallskip
La syntaxe |{\PitonStyle{|\textsl{\texttt{style}}|}{...}}| est nécessaire pour pouvoir
tenir compte à la fois des commandes semi-globales et des commandes à argument
potentiellement présentes dans la valeur courante du style \texttt{\textsl{style}}.


\subsubsection{Styles locaux et globaux}

Un style peut être défini de manière globale avec la commande |\SetPitonStyle|. Cela veut
dire qu'il s'appliquera par défaut à tous les langages informatiques qui utilisent ce
style.

\medskip
Par exemple, avec la commande 
\begin{Verbatim}
\SetPitonStyle{Comment = \color{gray}}
\end{Verbatim}
tous les commentaires (que ce soit en Python, en C, en OCaml, etc. ou dans un langage
défini avec |\NewPitonLanguage|) seront composés en gris.

\bigskip
Mais il est aussi possible de définir un style localement pour un certain langage
informatique en passant le nom du langage en argument optionnel (entre crochets) de la
commande |\SetPitonStyle|.\footnote{On rappelle que, dans \pkg{piton}, les noms des
  langages informatiques ne sont pas sensibles à la casse.}

\medskip
Par exemple, avec la commande 
\begin{Verbatim}
\SetPitonStyle~emphase#[SQL]@{Keyword = \color[HTML]{006699} \bfseries \MakeUppercase}
\end{Verbatim}
les mots-clés dans les listings SQL seront composés en lettres capitales, même s'ils
s'apparaissent en minuscules dans le fichier source LaTeX (on rappelle que, en SQL, les
mot-clés ne sont pas sensibles à la casse et donc forcer leur mise en capitales peut être
envisagé).

\medskip
Comme on s'en doute, si un langage informatique utilise un certain style et que ce style
n'est pas défini localement pour ce langage, c'est la version globale qui est utilisée.
Cette notion de globalité n'a pas de rapport avec la notion de liaison locale de TeX
(notion de groupe TeX).\footnote{Du point de vue des groupes de TeX, les liaisons faites
  par |\SetPitonStyle| sont toujours locales.}

\medskip
Les styles fournis par défaut par \pkg{piton} sont tous définis globalement.


\bigskip
\subsubsection{La commande \textbackslash rowcolor}

\label{rowcolor}
\indexcommand{rowcolor}

\nobreak
\medskip
L'extension \pkg{piton} fournit la commande \DefinitionCommand{rowcolor} qui impose un
fond coloré à la ligne courante (\emph{toute la ligne} et pas seulement la partie
contenant du texte) et que l'on peut utiliser dans les styles.

\smallskip
La commande |\rowcolor| a une syntaxe similaire à la commande classique |\color|. Par
exemple, il est possible d'écrire |\rowcolor[rgb]{0.8,1,0.8}|.

\smallskip
La commande |\rowcolor| est protégée contre le développement TeX.

\smallskip
Voici un exemple pour le langage Python où on modifie le style |String.Doc|
des \emph{documentation strings} pour avoir un fond coloré gris.


\medskip
% Ici, ne pas utiliser {Code}
\begin{Verbatim}
~emphase#\SetPitonStyle{String.Doc = \rowcolor{gray!15}\color{black!80}}@
\begin{Piton}[width=min]
def square(x):
    """Calcule le carré de x
       Deuxième ligne de la documentation"""
    return x*x
\end{Piton}
\end{Verbatim}


\bigskip
\begingroup
\SetPitonStyle{String.Doc = \rowcolor{gray!15}\color{black!80}}
\begin{Piton}[width=min]
def square(x):
    """Calcule le carré de x
       Deuxième ligne de la documentation"""
    return x*x
\end{Piton}
\endgroup

\bigskip
Si la commande |\rowcolor| apparaît (via un style de \pkg{piton}) dans une commande
|\piton|, elle est sans effet (comme on s'en doute).


\bigskip
\subsubsection{Le style UserFunction}

\index{UserFunction (style)}

\bigskip
Il existe un style spécial nommé |UserFunction|. Ce style s'applique aux noms des
fonctions précédemment définies par l'utilisateur (par exemple, avec le langage Python,
ces noms de fonctions sont ceux qui apparaissent après le mot-clé \piton{def} dans un
listing Python précédent). La valeur initiale de ce style est |\PitonStyle{Identifier}|,
ce qui fait que ces noms de fonctions sont formatés comme les autres identificateurs
(c'est-à-dire, par défaut, sans formatage particulier, si ce n'est celui donné par
|font-command|).

Néanmoins, il est possible de changer la valeur de ce style, comme tous les autres styles,
avec la commande |\SetPitonStyle|.

\medskip
Dans l'exemple suivant, on règle les styles |Name.Function| et |UserFunction| de manière à
ce que, quand on clique sur le nom d'une fonction Python précédemment définie par
l'utilisateur, on soit renvoyé vers la définition (informatique) de cette fonction. Cette
programmation utilise les fonctions |\hypertarget| et |\hyperlink| de \pkg{hyperref}.

\begingroup

\NewDocumentCommand{\MyDefFunction}{m}{\hypertarget{piton:#1}{\color[HTML]{CC00FF}{#1}}}
\NewDocumentCommand{\MyUserFunction}{m}{\hyperlink{piton:#1}{#1}}

\SetPitonStyle
  {
    Name.Function = \MyDefFunction ,
    UserFunction = \MyUserFunction
  }

\medskip
\begin{Code}
\NewDocumentCommand{\MyDefFunction}{m}
   {\hypertarget{piton:#1}{\color[HTML]{CC00FF}{#1}}}
\NewDocumentCommand{\MyUserFunction}{m}{\hyperlink{piton:#1}{#1}}

\SetPitonStyle{Name.Function = \MyDefFunction, \emph{UserFunction} = \MyUserFunction}
\end{Code}

\smallskip

\begin{Piton}
def transpose(v,i,j):
    x = v[i]
    v[i] = v[j]
    v[j] = x 

def passe(v):
    for in in range(0,len(v)-1):
        if v[i] > v[i+1]:
            transpose(v,i,i+1)
\end{Piton}

\medskip
(Certains lecteurs de \textsc{pdf} affichent un cadre autour du mot |transpose| cliquable
et d'autres non.)


\endgroup

\PitonClearUserFunctions[Python]

\bigskip
\begin{small}
Bien sûr, la liste des noms de fonctions Python précédemment définies est gardée en
mémoire de LuaLaTeX (de manière globale, c'est-à-dire indépendamment des groupes TeX).
L'extension \pkg{piton} fournit une commande qui permet de vider cette liste : c'est la
commande \DefinitionCommand{PitonClearUserFunctions}. Quand elle est utilisée sans
argument, cette commande s'applique à tous les langages informatiques utilisées par
l'utilisateur mais on peut spécifier en argument optionnel (entre crochets) une liste de
langages informatiques auxquels elle s'appliquera.\footnote{On rappelle que, dans
  \pkg{piton}, les noms des langages informatiques ne sont pas sensibles à la casse. }
\end{small}





\subsection{Définition de nouveaux environnements}

\label{NewPitonEnvironment}
\indexcommand{NewPitonEnvironment}
\indexcommand{RenewPitonEnvironment}
\indexcommand{DeclarePitonEnvironment}
\indexcommand{ProvidePitonEnvironment}

Comme l'environnement |{Piton}| a besoin d'absorber son contenu d'une manière spéciale (à
peu près comme du texte verbatim), il n'est pas possible de définir de nouveaux
environnements directement au-dessus de l'environnement |{Piton}| avec les commandes
classiques |\newenvironment| (de LaTeX standard) et |\NewDocumentEnvironment| (de LaTeX3).

Il est possible d'utiliser |\NewEnvironmentCopy| sur l'environment |{Piton}| mais
l'utilité est limitée.

C'est pourquoi \pkg{piton} propose une commande \DefinitionCommand{NewPitonEnvironment}.
Cette commande a la même syntaxe que la commande classique
|\NewDocumentEnvironment|.\footnote{Néanmoins, le spécificateur d'argument~|b|, qui sert à
  capter le corps de l'environnement comme un argument LaTeX, n'est pas autorisé
  (bien entendu).}

\medskip
Il existe aussi les commandes suivantes similaires à celles de LaTeX3 :
\DefinitionCommand{RenewPitonEnvironment},
\DefinitionCommand{DeclarePitonEnvironment} et \DefinitionCommand{ProvidePitonEnvironment}.



\bigskip
Par exemple, avec l'instruction suivante, un nouvel environnement |{Python}| sera défini
avec le même comportement que l'environnement |{Piton}|:

\medskip
\begin{Code}
\emph{\NewPitonEnvironment}{Python}{O{}}{\PitonOptions{#1}}{}
\end{Code}

\bigskip
Si on souhaite un environnement |{Python}| qui compose le code inclus dans une boîte de
\pkg{mdframed}, on peut écrire :

\begin{footnotesize}
\begin{Verbatim}
\usepackage[framemethod=tikz]{mdframed} % dans le préambule
\end{Verbatim}
\end{footnotesize}

\medskip
\begin{Code}
\emph{\NewPitonEnvironment}{Python}{}
  {\begin{mdframed}[roundcorner=3mm]}
  {\end{mdframed}}
\end{Code}

\bigskip
Avec ce nouvel environnement |{Python}|, on peut écrire : 

\medskip
\begin{Code}
\emph{\begin{Python}}
def carré(x):
    """Calcule le carré de x"""
    return x*x
\emph{\end{Python}}
\end{Code}

\NewPitonEnvironment{Python}{}
  {\begin{mdframed}[roundcorner=3mm]}
  {\end{mdframed}}

\begin{Python}
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Python}

\bigskip
On peut faire une construction similaire avec une boîte graphique de \pkg{tcolorbox}.
Néanmoins, pour permettre une meilleure cohérence entre \pkg{tcolorbox} et \pkg{piton},
l'extension \pkg{piton} propose la clé |tcolorbox| : cf.~p.~\pageref{tcolorbox}.

\section{Définition de nouveaux langages avec la syntaxe de listings}

\indexcommand{NewPitonLanguage}
\label{NewPitonLanguage}
\index{listings@\pkg{listings} (extension)}

\medskip
L'extension \pkg{listings} est une célèbre extension LaTeX pour formater des codes informatiques.   

\medskip
Elle propose une commande |\lstdefinelanguage| pour définir de nouveaux langages. Cette
commande est aussi utilisée en interne par \pkg{listings} pour sa définition des languages
(en fait, pour cela, \pkg{listings} utilise une commande nommée |\lst@definelanguage| mais
celle-ci a la même syntaxe que |\lstdefinelanguage|).

\medskip
L'extension \pkg{piton} propose une commande \DefinitionCommand{NewPitonLanguage} pour
définir de nouveaux langages (utilisables avec les outils de \pkg{piton}) avec quasiment
la même syntaxe que |\lstdefinelanguage|.

\medskip
Précisons tout de suite que l'extension \pkg{piton} n'utilise \emph{pas} cette commande
pour définir les langages qu'elle propose nativement (Python, C, OCaml, SQL, |minimal| et
|verbatim|), ce qui permet de proposer des parseurs plus puissants. 

\medskip
Par exemple, dans le fichier |lstlang1.sty|, qui est un des fichiers de definition des
langages proposés par défaut par \pkg{listings}, on trouve les instructions suivantes
(dans la version 1.10a).

\begin{Verbatim}[formatcom=\small\color{gray}]
\lst~@definelanguage{Java}%
  {morekeywords={abstract,boolean,break,byte,case,catch,char,class,%
      const,continue,default,do,double,else,extends,false,final,%
      finally,float,for,goto,if,implements,import,instanceof,int,%
      interface,label,long,native,new,null,package,private,protected,%
      public,return,short,static,super,switch,synchronized,this,throw,%
      throws,transient,true,try,void,volatile,while},%
   sensitive,%
   morecomment=[l]//,%
   morecomment=[s]{/*}{*/},%
   morestring=[b]",%
   morestring=[b]',%
  }[keywords,comments,strings]
\end{Verbatim}

\medskip
Pour définir un language nommé |Java| pour \pkg{piton}, il suffit d'écrire le code
suivant, {\bfseries où le dernier argument de |\lst@definelanguage|, qui est entre
  crochets, a été supprimé} (en fait, les symboles \verb+%+ pourraient être supprimés sans
problème).

\medskip
\begin{small}
\begin{Verbatim}
~emphase#\NewPitonLanguage@{Java}%
  {morekeywords={abstract,boolean,break,byte,case,catch,char,class,%
      const,continue,default,do,double,else,extends,false,final,%
      finally,float,for,goto,if,implements,import,instanceof,int,%
      interface,label,long,native,new,null,package,private,protected,%
      public,return,short,static,super,switch,synchronized,this,throw,%
      throws,transient,true,try,void,volatile,while},%
   sensitive,%
   morecomment=[l]//,%
   morecomment=[s]{/*}{*/},%
   morestring=[b]",%
   morestring=[b]',%
  }
\end{Verbatim}
\end{small}

\NewPitonLanguage{Java}
  {morekeywords={abstract,boolean,break,byte,case,catch,char,class,
      const,continue,default,do,double,else,extends,false,final,
      finally,float,for,goto,if,implements,import,instanceof,int,
      interface,label,long,native,new,null,package,private,protected,
      public,return,short,static,super,switch,synchronized,this,throw,
      throws,transient,true,try,void,volatile,while},
   sensitive,
   morecomment=[l]//,
   morecomment=[s]{/*}{*/},
   morestring=[b]",
   morestring=[b]',
  }


\medskip
On peut alors utiliser le language Java comme n'importe quel autre langage prédéfini de
\pkg{piton}.

Voici un exemple de code Java formaté dans un environnement~|{Piton}| avec la
clé~|language=Java|.\footnote{On rappelle que, pour \pkg{piton}, les noms de langages
  informatiques ne sont pas sensibles à la casse, ce qui fait que l'on aurait pu aussi
  bien utiliser : |language=java|.}

\bigskip
\begingroup
\small
\PitonOptions{splittable-on-empty-lines}
\begin{Piton}[language = Java]
public class Cipher { // cryptage par le chiffre de César
    public static void main(String[] args) {
        String str = "The quick brown fox Jumped over the lazy Dog";
        System.out.println( Cipher.encode( str, 12 ));
        System.out.println( Cipher.decode( Cipher.encode( str, 12), 12 ));
    }

    public static String decode(String enc, int offset) {
        return encode(enc, 26-offset);
    }

    public static String encode(String enc, int offset) {
        offset = offset % 26 + 26;
        StringBuilder encoded = new StringBuilder();
        for (char i : enc.toCharArray()) {
            if (Character.isLetter(i)) {
                if (Character.isUpperCase(i)) {
                    encoded.append((char) ('A' + (i - 'A' + offset) % 26 ));
                } else {
                    encoded.append((char) ('a' + (i - 'a' + offset) % 26 ));
                }
            } else {
                encoded.append(i);
            }
        }
        return encoded.toString();
    }
}
\end{Piton}
\endgroup

\bigskip
Les clés de la commande |\lstdefinelanguage| de \pkg{listings} prises en charge par
|\NewPitonLanguage| sont : |morekeywords|, |otherkeywords|, |sensitive|, |keywordsprefix|,
|moretexcs|, |morestring| (avec les lettres |b|, |d|, |s| et |m|), |morecomment| (avec les
lettres |i|, |l|, |s|, |n| et |f|\footnote{Pour la lettre |f|, seule une spécification de commentaire commençant en  première colonne est autorisée.})), |moredelim| (avec les lettres |i|, |l|, |s|, |*| et |**|),
|moredirectives|, |tag|, |alsodigit|, |alsoletter| et |alsoother|.

Pour la description de ces clés, on renvoie à la documentation de \pkg{listings} (taper
|texdoc| |listings| dans un terminal).

\bigskip
Par exemple, pour formater du code LaTeX, on pourra créer le language suivant : 
%
{\color{gray}
\begin{verbatim}
\NewPitonLanguage{LaTeX}{keywordsprefix = \ , alsoother = @_ }
\end{verbatim}
} 

Initialement, les caractères |@| et |_| sont considérés comme des lettres (au sens de \pkg{listings})
car de nombreux langages de programmation les autorisent dans les mots-clés et les identificateurs. Avec
\verb|alsoother = @_|, on les retire de la catégorie des lettres.

\section{Importation et exportation de listings}

\subsection{Importation d'un listing fourni par un fichier externe}

\label{PitonInputFile}

\subsubsection{La commande \textbackslash PitonInputFile}

\indexcommand{PitonInputFile}

La commande \DefinitionCommand{PitonInputFile} permet d'insérer tout ou partie d'un
fichier extérieur dont le nom est passé en argument. Il existe aussi des commandes
\DefinitionCommand{PitonInputFileT}, \DefinitionCommand{PitonInputFileF} et
\DefinitionCommand{PitonInputFileTF} avec des arguments correspondant aux lettres |T| et
|F|, arguments qui seront exécutés dans le cas où le fichier a été trouvé (lettre |T|) ou
pas (lettre |F|).

\smallskip
La syntaxe des chemins (absolus et relatifs) est la suivante : 
\begin{itemize}
\item Les chemins commençant par |/| sont des chemins absolus.

\emph{Exemple} : |\PitonInputFile{/Users/joe/Documents/programme.py}|

\item Les chemins ne commençant pas par |/| sont relatifs au répertoire courant.

\emph{Exemple} : |\PitonInputFile{les_listings/programme.py}|
\end{itemize}


\index{path}
La clé \Definition{path} de la commande |\PitonOptions| permet de spécifier une
\emph{liste} de chemins où sera recherché le fichier à inclure (dans cette liste, les
chemins sont séparés par des virgules). Comme précédemment, les chemins absolus doivent
débuter par une oblique~|/|.


\subsubsection{Insertion d'une partie d'un fichier}

\label{part-of-a-file}
\indexcommand{PitonInputFile}

En fait, il existe des mécanismes permettant de n'insérer qu'une partie du fichier en
question.
\begin{itemize}
\item On peut spécifier la partie à insérer par les numéros de lignes (dans le fichier
d'origine).
\item On peut aussi spécifier la partie à insérer par des marqueurs textuels.
\end{itemize}
Dans les deux cas, si on souhaite numéroter les lignes avec les numéros des lignes du
fichier d'origine, il convient d'utiliser la clé |line-numbers/absolute|.

\bigskip
\textbf{Avec les numéros de lignes absolus}

\nobreak
La commande |\PitonInputFile| propose les clés \Definition{first-line} et
\Definition{last-line} qui permettent de n'insérer que la partie du fichier comprise entre
les lignes correspondantes. Ne pas confondre avec la clé |line-numbers/start| qui demande
un numérotage des lignes commençant à la valeur donnée à cette clé (en un sens
|line-numbers/start| concerne la sortie alors que |first-line| et |last-line| concernent
l'entrée).

\bigskip
\textbf{Avec des marqueurs textuels}

\index{marker/beginning}
\index{marker/end}

\nobreak
Pour utiliser cette technique, il convient d'abord de spécifier le format des marqueurs
marquant le début et la fin de la partie du fichier à inclure. Cela se fait avec les deux
clés \Definition{marker/beginning} et \Definition{marker/end} (usuellement dans la
commande |\PitonOptions|).

\medskip
Prenons d'abord un exemple.

\medskip
Supposons que le fichier à inclure contienne des solutions à des exercices de
programmation sur le modèle suivant :

\begin{small}
\begin{Code}
#[Exercice 1] Version itérative
def fibo(n):
    if n==0: return 0 
    else:
        u=0
        v=1
        for i in range(n-1):
            w = u+v
            u = v
            v = w
        return v
#<Exercice 1>
\end{Code}
\end{small}

Les marqueurs de début de début et de fin sont les chaînes |#[Exercice 1]| et 
|#<Exercice 1>|. La chaîne «|Exercice 1|» sera appelée le \emph{label} de l'exercice (ou
de la partie du fichier à inclure).

Pour spécifier des marqueurs de cette sorte dans \pkg{piton}, on utilisera les clés
|marker/beginning| et |marker/end| de la manière suivante (le caractère |#| des
commentaires de Python doit être inséré sous la forme échappée |\#|).

\smallskip
\begin{Code}
\PitonOptions{ \emph{marker/beginning} = \#[#1] , \emph{marker/end} = \#<#1> } 
\end{Code}

\smallskip
Comme on le voit, |marker/beginning| est une expression correspondant à la fonction
mathématique qui, au nom du label (par exemple |Exercice 1|), associe le marqueur de début
(dans l'exemple |#[Exercice 1]|). La chaîne |#1| correspond aux occurrences de l'argument
de cette fonction (c'est la syntaxe habituelle de TeX). De même pour |marker/end|.\footnote{Du point de vue de LaTeX, les deux fonctions passées en argument doivent être \emph{fully expandable}.}


\bigskip
Pour insérer une partie marquée d'un fichier, il suffit alors d'utiliser la clé
\Definition{range} de |\PitonInputFile|.

\smallskip
\begin{Verbatim}
\PitonInputFile[~emphase#range = Exercice 1@]{~textsl#nom_du_fichier@}
\end{Verbatim}

\medskip
\begin{Piton}
def fibo(n):
    if n==0: return 0 
    else:
        u=0
        v=1
        for i in range(n-1):
            w = u+v
            u = v
            v = w
        return v
\end{Piton}

\vspace{1cm} \index{marker/include-lines} La clé \Definition{marker/include-lines} demande
que les lignes contenant les marqueurs soient également insérées.

\begin{Verbatim}
\PitonInputFile[~emphase#marker/include-lines@,range = Exercice 1]{~textsl#nom_du_fichier@}
\end{Verbatim}

\begin{Piton}
#[Exercice 1] Version itérative
def fibo(n):
    if n==0: return 0 
    else:
        u=0
        v=1
        for i in range(n-1):
            w = u+v
            u = v
            v = w
        return v
#<Exercice 1>
\end{Piton}


\bigskip
\index{begin-range} \index{end-range} Il existe en fait aussi les clés
\Definition{begin-range} et \Definition{end-range} pour insérer plusieurs contenus marqués
simultanément.

Par exemple, pour insérer les solutions des exercices 3 à 5, on pourra écrire (à condition
que le fichier soit structuré correctement!):

\begin{Verbatim}
\PitonInputFile[~emphase#begin-range = Exercice 3, end-range = Exercice 5@]{~textsl#nom_du_fichier@}
\end{Verbatim}


\subsection{Exportation de listings}

À côté de la commande |\PitonInputFile| qui permet d'insérer dans le \textsc{pdf} 
tout ou partie d'un fichier extérieur, \pkg{piton} propose des outils pour exporter
des listings inclus dans le fichier source LaTeX vers le disque ou bien en pièces jointes
du \textsc{pdf} généré.

\begin{itemize}
\item \index{write (clé)} La clé \Definition{write} prend en argument un nom de
fichier (avec l'extension) et écrit le contenu\footnote{En fait, il ne s'agit
  pas exactement du contenu de l'environnement mais de la valeur renvoyée par
  l'instruction Lua |piton.get_last_code()| qui en est une version sans les
  surcharges de formatage LaTeX (voir la partie \ref{API}, p.~\pageref{API}).}
de l'environnement courant dans ce fichier. À la première utilisation du fichier
par \pkg{piton} (au cours d'une compilation avec LuaLaTeX), celui-ci est effacé.
L'écriture du fichier ne se fait en fait qu'à la fin de la compilation avec LuaLaTeX.

Pour la lisibilité, \pkg{piton} fournit la clé \Definition{no-write} (sans valeur) comme
alias de |write=|.

\item \index{path-write} La clé \Definition{path-write} indique un chemin où
seront écrits les fichiers écrits par l'emploi de la clé |write| précédente.

\item \index{join (clé)} 
La clé \Definition{join} est similaire à la clé |write| mais les fichiers créés sont
\emph{joints} (comme «pièces jointes») dans le \textsc{pdf}. Attention :
certains lecteurs de \textsc{pdf} ne proposent pas d'outil permettant d'accéder à
ces fichiers joints.


Pour la lisibilité, \pkg{piton} fournit la clé \Definition{no-join} (sans valeur) comme
alias de |join=|.


\item \index{print (clé)}
La clé \Definition{print} contrôle l'affichage effectif du contenu des
environnements |{Piton}| dans le \textsc{pdf}. Bien entendu, la valeur initiale de cette
clé est |true|. Néanmoins, dans certains circonstances, il peut être utile
d'utiliser |print=false| (dans le cas, par exemple, où la clé |write|, ou bien
la clé |join|, est utilisée).

\item \index{paperclip (clé)}
La clé \Definition{paperclip} va, pour chaque environnement |{Piton}|, ajouter dans la marge
droite une annotation \textsc{pdf} liée à un fichier joint dans le \textsc{pdf} correspondant
au listing de l'environnement.

La valeur fournie à la clé |paperclip| est le nom qui sera donné au fichier joint. Si aucune
valeur n'est fournie, le fichier sera nommé \texttt{listing_\textsl{i}.txt} où \textsl{i}
est un compteur géré par \pkg{piton} incrémenté à chaque utilisation de la clé |paperclip|
sans valeur.

\medskip
\begin{Code}
\begin{Piton}[\emph{paperclip},background-color=gray!15]
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Piton}    
\end{Code}

\medskip
\begin{Piton}[paperclip,background-color=gray!15]
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Piton}    


\item \index{annotation (clé)}
La clé \Definition{annotation} va, pour chaque environnement |{Piton}|, ajouter
dans la marge droite une annotation \textsc{pdf} de type note contenant
directement le listing de l'environnement |{Piton}|.

\medskip
\begin{Code}
\begin{Piton}[\emph{annotation},background-color=gray!15]
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Piton}    
\end{Code}

\medskip
\begin{Piton}[annotation,background-color=gray!15]
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Piton}    


\end{itemize}

\section{Fonctionnalités avancées}

\subsection{La clé «box»}

\index{box (clé)}
\label{box}


\nobreak
\smallskip
Si on souhaite composer un listing dans une boîte de LaTeX, on doit utiliser la clé
\Definition{box}. Cette clé prend comme valeur |c|, |t| ou |b| correspondant
au paramètre de position verticale (comme dans un environnement |{minipage}| de LaTeX, qui
crée aussi une boîte LaTeX). La valeur par défaut est |c| (comme pour |{minipage}|).

\smallskip
L'emploi de la clé |box| active |width=min| (sauf, bien sûr, si on utilise
explicitement |width| ou |max-width|). Pour les clés |width| et |max-width|,
cf.~p.~\pageref{width}.


\smallskip
\begin{Code}
\begin{center}
\PitonOptions{\emph{box},background-color=gray!15}
\begin{Piton}
def square(x):
    return x*x
\end{Piton}
\hspace{1cm}
\begin{Piton}
def cube(x):
    return x*x*x
\end{Piton}
\end{center}
\end{Code}

\begin{center}
\PitonOptions{box,background-color=gray!15}
\begin{Piton}
def square(x):
    return x*x
\end{Piton}
\hspace{1cm}
\begin{Piton}
def cube(x):
    return x*x*x
\end{Piton}
\end{center}

\vspace{1cm} Il est possible d'utiliser la clé |box| avec une valeur numérique pour |width|
(5~cm dans l'exemple qui suit).

\begin{Code}
\begin{center}
\PitonOptions{\emph{box,width=5cm},background-color=gray!15}
\begin{Piton}
def square(x):
    return x*x
\end{Piton}
\hspace{1cm}
\begin{Piton}
def cube(x):
    return x*x*x
\end{Piton}
\end{center}
\end{Code}

\begin{center}
\PitonOptions{box,width=5cm,background-color=gray!15}
\begin{Piton}
def square(x):
    return x*x
\end{Piton}
\hspace{1cm}
\begin{Piton}
def cube(x):
    return x*x*x
\end{Piton}
\end{center}


\vspace{1cm}
Voici un exemple avec la clé |max-width|, égale à 7~cm pour les deux listings.

\begin{Code}
\begin{center}
\PitonOptions{\emph{box=t,max-width=7cm},background-color=gray!15}
\begin{Piton}
def square(x):
    return x*x
\end{Piton}
\hspace{1cm}
\begin{Piton}
def P(x):
    return 24*x**8 - 7*x**7 + 12*x**6 -4*x**5 + 4*x**3 + x**2 - 5*x + 2
\end{Piton}
\end{center}
\end{Code}

\begin{center}
\PitonOptions{box=t,max-width=7cm,background-color=gray!15}
\begin{Piton}
def square(x):
    return x*x
\end{Piton}
\hspace{1cm}
\begin{Piton}
def P(x):
    return 24*x**8 - 7*x**7 + 12*x**6 -4*x**5 + 4*x**3 + x**2 - 5*x + 2
\end{Piton}
\end{center}


\subsection{La clé «tcolorbox»}

\label{tcolorbox}
\index{tcolorbox (clé)}

L'extension \pkg{piton} propose une clé \Definition{tcolorbox} qui facilite
l'utilisation de l'extension \pkg{tcolorbox} en coordination avec l'extension
\pkg{piton}. Néanmoins, l'extension \pkg{piton} ne charge \emph{pas} \pkg{tcolorbox}
et l'utilisateur final doit l'avoir chargée. Il doit aussi avoir chargé la
librairie |breakable| de \pkg{tcolorbox} avec |\tcbuselibrary{breakable}| dans le
préambule du document LaTeX. Si ce n'est pas le cas, une erreur sera levée à la première
utilisation de la clé |tcolorbox|.


\bigskip
Quand la clé |tcolorbox| est utilisée, le listing formaté par \pkg{piton} est
inclus dans un environnement |{tcolorbox}|. Cela s'applique aussi bien à la
commande |\PitonInputFile| qu'à un environnement |{Piton}| (ou, plus
généralement, à un environnement défini par |\NewPitonEnvironment|:
cf.~p.~\pageref{NewPitonEnvironment}). Dans le cas où la clé |splittable| de
\pkg{piton} est utilisée (cf. p.~\pageref{coupure-de-pages}), la boîte graphique
créée par \pkg{tcolorbox} sera sécable par un saut de page.

\bigskip
Dans le présent document, on a, de plus, chargé, dans le préambule du document LaTeX,
la librairie |skins| de \pkg{tcolorbox} et activé la \emph{skin} |enhanced| pour avoir
une meilleure apparence au niveau du saut de page.

\begin{footnotesize}
\begin{Verbatim}
\tcbuselibrary{skins,breakable} % dans le préambule
\tcbset{enhanced}               % dans le préambule
\end{Verbatim}
\end{footnotesize}

\smallskip
\begin{Code}
\begin{Piton}\emph{[tcolorbox,splittable=3]}
def carré(x):
    """Calcule le carré de x"""
    return x*x
...
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Piton}
\end{Code}

\begin{Piton}[tcolorbox,splittable=3]
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Piton}


Bien sûr, si on veut changer la couleur du fond, on n'utilise pas
|background-color| de \pkg{piton} mais les outils fournis par \pkg{tcolorbox}
(la clé |colback| pour la couleur du fond).


\bigskip
Si on souhaite ajuster la largeur de la boîte graphique au contenu, il suffit
d'utiliser la clé |width=min| fournie par \pkg{piton} (cf. p.~\pageref{width}).
On peut aussi utiliser |width| ou |max-width| avec une valeur numérique.
L'environnement est sécable si la clé |splittable| est utilisée
(cf. p.~\pageref{coupure-de-pages}).

\smallskip
\begin{Code}
\begin{Piton}\emph{[tcolorbox,width=min,splittable=3]}
def carré(x):
    """Calcule le carré de x"""
    return x*x
...
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Piton}
\end{Code}

\smallskip
\begin{Piton}[tcolorbox,width=min,splittable=3]
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Piton}



\bigskip
Si on souhaite que le résultat soit produit dans une boîte LaTeX (en dépit de son nom,
un environnement de \pkg{tcolorbox} n'est pas nécessairement une boîte LaTeX),
il suffit d'utiliser, conjointement avec la clé |tcolorbox|, la clé |box| fournie
par \pkg{piton} (cf. p.~\pageref{box}). Bien sûr, la boîte LaTeX ainsi créée ne sera \emph{pas}
sécable par un saut de page (comme toutes les boîtes de LaTeX), même si la clé |splittable|
(cf.~p.~\pageref{splittable}) est active.

On rappelle que l'emploi de la clé |box| active |width=min| (sauf si on utilise
explicitement |width| ou |max-width|).

\smallskip
\begin{Code}
\begin{center}
\PitonOptions{\emph{tcolorbox,box=t}}
\begin{Piton}
def square(x):
    return x*x
\end{Piton}
\hspace{1cm}
\begin{Piton}
def cube(x):
    """Le cube de x"""
    return x*x*x
\end{Piton}
\end{center}
\end{Code}

\begin{center}
\PitonOptions{tcolorbox,box=t}%
\begin{Piton}
def square(x):
    return x*x
\end{Piton}
\hspace{1cm}
\begin{Piton}
def cube(x):
    """Le cube de x"""
    return x*x*x
\end{Piton}
\end{center}

\bigskip
Pour  un exemple plus sophistiqué d'utilisation de la clé |tcolorbox|, voir l'exemple fourni
à la page~\pageref{examples-tcolorbox}.




\subsection{Coupure des lignes et des pages}

\label{breakable}

\subsubsection{Coupure des lignes}

\label{line-breaks}

Il existe des clés pour contrôler les coupures de ligne (les points de coupure
possibles sont les espaces, y compris les espaces qui sont dans les chaînes de
caractères des langages informatiques).
\begin{itemize}
\item \index{break-lines!break-lines-in-piton} Avec la clé
\Definition{break-lines-in-piton}, les coupures de ligne sont autorisées dans la commande
|\piton{...}| (mais pas dans la commande \verb+\piton|...|+, c'est-à-dire avec la syntaxe
verbatim).

\item \index{break-lines!break-lines-in-Piton} Avec la clé
\Definition{break-lines-in-Piton}, les coupures de ligne sont autorisées dans
l'environnement |{Piton}| (d'où la lettre |P| capitale dans le nom) et les
listings produits par |\PitonInputFile|. {\bfseries La valeur initiale de ce paramètre est
|true| (et non |false|).}

\item \index{break-lines} La clé \Definition{break-lines} est la conjonction des deux clés
précédentes.
\end{itemize}

\medskip
L'extension \pkg{piton} fournit aussi plusieurs clés pour contrôler l'apparence des
coupures de ligne autorisées par |break-lines-in-Piton|.

\begin{itemize}
\item \index{indent-broken-lines} Avec la clé \Definition{indent-broken-lines},
l'indentation de la ligne coupée est respectée à chaque retour à la ligne (à condition que
la fonte utilisée soit une fonte mono-chasse, ce qui est le cas par défaut puisque la
valeur initiale de |font-command| est |\ttfamily|).

\item \index{end-of-broken-line} La clé \Definition{end-of-broken-line} correspond au
symbole placé à la fin d'une ligne coupée. Sa valeur initiale est :
|\hspace*{0.5em}\textbackslash|.

\item \index{continuation-symbol} La clé \Definition{continuation-symbol} correspond au
symbole placé à chaque retour de ligne dans la marge gauche. Sa valeur initiale est :
|+\;| (la commande |\;| insère un petit espace horizontal).

\item \index{continuation-symbol-on-indentation} La clé
\Definition{continuation-symbol-on-indentation} correspond au symbole placé à chaque
retour de ligne au niveau de l'indentation (uniquement dans le cas où la clé
|indent-broken-lines| est active). Sa valeur initiale est : |$\hookrightarrow\;$|.
\end{itemize}

\bigskip
Le code suivant a été composé avec le réglage suivant :  

\begin{Verbatim}
\PitonOptions{width=12cm,indent-broken-lines,background-color=gray!15}
\end{Verbatim}


\begin{center}
\PitonOptions{width=12cm,indent-broken-lines,background-color=gray!15}
\begin{Piton}
def dict_of_liste(liste):
    """Convertit une liste de subrs et de descriptions de glyphes en dictionnaire"""
    dict = {}
    for liste_lettre in liste:
        if (liste_lettre[0][0:3] == 'dup'): # si c'est un subr
            nom = liste_lettre[0][4:-3]
            print("On traite le subr de numéro " + nom)
        else:
            nom = liste_lettre[0][1:-3] # si c'est un glyphe
            print("On traite le glyphe du caractère " + nom)
        dict[nom] = [traite_ligne_Postscript(k) for k in liste_lettre[1:-1]]
    return dict
\end{Piton}
\end{center}


\bigskip
Avec la clé \Definition{break-strings-anywhere}, les chaînes de caractères pourront être
coupées n'importe où (et pas seulement sur les espaces). 


\bigskip
Avec la clé \Definition{break-numbers-anywhere}, les nombres peuvent être coupés n'importe où.


\subsubsection{Coupure des pages}

\label{splittable}
\label{coupure-de-pages}
\index{splittable}
\index{splittable-on-empty-lines}


Par défaut, les listings produits par l'environnement |{Piton}| et par la commande
|\PitonInputFile| sont insécables.


Néanmoins, \pkg{piton} propose les clés |splittable-on-empty-lines| et |splittable| pour
autoriser de telles coupures.

\begin{itemize}
\item La clé \Definition{splittable-on-empty-lines} autorise les coupures sur les lignes
vides du listing. Les lignes considérées comme vides sont celles qui ne comportent que des
espaces (et il aurait peut-être été plus habile de parler de lignes blanches). 

\medskip
\item La clé |splittable-on-empty-lines| peut bien sûr être insuffisante et c'est pourquoi
\pkg{piton} propose la clé \Definition{splittable}.

Quand la clé |splittable| est utilisée avec la valeur numérique $n$ (qui doit être un
entier naturel non nul) le listing pourra être coupé n'importe où avec cette exception
qu'aucune coupure ne pourra avoir lieu entre les $n$~premières lignes, ni entre les
$n$~dernières.\footnote{Remarquer que l'on parle des lignes du listing d'origine, une
  telle ligne pouvant être composée sur plusieurs lignes dans le \textsc{pdf} final (quand la
  clé |break-lines-in-Piton| est active).}

Par exemple, |splittable = 4| pourrait être un réglage raisonnable.

Employée sans argument, la clé |splittable| est équivalente à |splittable = 1|, et les
listings sont alors sécables n'importe où (ce n'est pas recommandable).

La valeur initiale de la clé |splittable| vaut 100, ce qui fait que les listings ne sont
pas sécables. 
\end{itemize}

\medskip
\begin{tcolorbox}[breakable]
Même avec une couleur de fond (fixée avec |background-color|), les sauts de page sont
possibles, à partir du moment où |splittable-on-empty-lines| ou |splittable| est
utilisée.

\medskip
Avec la clé |splittable|, un environnement |{Piton}| est sécable même dans un
environnement de \pkg{tcolorbox} (à partir du moment où la clé |breakable| de
\pkg{tcolorbox} est utilisée). On précise cela parce que, en revanche, un
environnement de \pkg{tcolorbox} inclus dans un autre environnement de
\pkg{tcolorbox} n'est pas sécable, même quand les deux utilisent la clé
|breakable| de \pkg{tcolorbox}.

\medskip
On illustre ce point avec le code suivant (l'environnement |{tcolorbox}| dans lequel nous
nous trouvons utilise la clé |breakable|).

\medskip
\begin{Code}
\begin{Piton}\emph{[background-color=gray!30,rounded-corners,
  width=min,splittable=4]}
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
...    
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Piton}
\end{Code}

\bigskip
\begin{Piton}[background-color=gray!30,rounded-corners,width=min,splittable=4]
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x 
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Piton}

\end{tcolorbox}

\bigskip
\subsection{Découpe d'un listing en sous-listings}

\index{split-on-empty-lines}
\label{split-on-empty-lines}
\index{split-separation}
\index{env-used-by-split}

L'exension \pkg{piton} fournit la clé \Definition{split-on-empty-lines}, qui ne doit pas
être confondue avec la clé |splittable-on-empty-lines| définie précédemment. 

\smallskip
Pour comprendre le fonctionnement de la clé |split-on-empty-lines|, il faut imaginer que
l'on a à composer un fichier informatique qui contient une succession de définitions de
fonctions informatiques. Dans la plupart des langages informatiques, ces définitions
successives sont séparées par des lignes vides (ou plutôt des lignes blanches,
c'est-à-dire des lignes qui ne contiennent que des espaces). 

\smallskip
La clé |split-on-empty-lines| coupe le listing au niveau des lignes vides. Les lignes
vides successives sont supprimées et remplacées par le contenu du paramètre correspondant
à la clé \Definition{split-separation}.
\begin{itemize}
\item Ce paramètre doit contenir du matériel à insérer en \emph{mode vertical} de TeX. On
peut, par exemple, mettre la primitive TeX |\hrule|.

\item La valeur initiale de ce paramètre est
|\vspace{\baselineskip}\vspace{-1.25pt}|, ce qui, au final, correspond à une
ligne vide dans le \textsc{pdf} produit (cet espace vertical est supprimé s'il tombe au
niveau d'un saut de page).

\item L'extension \pkg{piton} propose en fait aussi la clé \Definition{split-separation~+} qui ajoute
du contenu à droite de |split-separation|. Le nom de cette clé contient un espace
de manière à pouvoir écrire, par exemple : |split-separation += \hrule|.
\end{itemize}

Chaque morceau du code informatique est formaté (de manière autonome) dans un
environnement dont le nom est donné par la clé \Definition{env-used-by-split}.
La valeur initiale de ce paramètre est, sans surprise, |Piton| et les différents
morceaux sont donc composés dans des environnements |{Piton}|. Si on décide de
donner une autre valeur à la clé |env-used-by-split|, on doit bien sûr donner le
nom d'un environnement créé par |\NewPitonEnvironment|
(cf.~partie~\ref{NewPitonEnvironment}, p.~\pageref{NewPitonEnvironment}).

\smallskip
Chaque morceau du listing de départ étant composé dans son environnement, il dispose de sa
propre numérotation des lignes (si la clé |line-numbers| est active) et de son propre fond
coloré (si la clé |background-color| est utilisée), séparé des fonds des autres morceaux.
Si elle est active, la clé |splittable| s'applique de manière autonome dans chaque
morceau. Bien sûr, des sauts de page peuvent intervenir entre les différents morceaux du
code, quelle que soit la valeur de la clé |splittable|.

\bigskip
\begin{Code}
\begin{Piton}[\emph{split-on-empty-lines},background-color=gray!15,line-numbers]
def carré(x):
    """Calcule le carré de x"""
    return x*x

def cube(x):
    """Calcule le cube de x"""
    return x*x*x
\end{Piton}
\end{Code}

\medskip
\begin{Piton}[split-on-empty-lines,background-color=gray!15,line-numbers]
def carré(x):
    """Calcule le carré de x"""
    return x*x

def cube(x):
    """Calcule le cube de x"""
    return x*x*x
\end{Piton}


\vspace{5mm}
Si on souhaite au contraire une continuité de numérotation, on peut ajouter
|\PitonOptions{resume}| au paramètre |split-separation| :

\bigskip
\begin{Code}
\begin{Piton}[
   split-on-empty-lines,
   \emph{split-separation += \PitonOptions{resume}} ,
   background-color=gray!15,
   line-numbers
 ]
def carré(x):
    """Calcule le carré de x"""
    return x*x

def cube(x):
    """Calcule le cube de x"""
    return x*x*x
\end{Piton}
\end{Code}

\medskip
\begin{Piton}[
   split-on-empty-lines,
   split-separation += \PitonOptions{resume} ,
   background-color=gray!15,
   line-numbers
 ]
def carré(x):
    """Calcule le carré de x"""
    return x*x

def cube(x):
    """Calcule le cube de x"""
    return x*x*x
\end{Piton}


\bigskip
\textbf{Attention} : Comme chaque morceau est traité de manière indépendante, les
commandes spécifiées par |detected-commands| ou |raw-detected-commands|
(cf.~p.~\pageref{detected-commands}) et les commandes et environnements de Beamer
automatiquement détectés par \pkg{piton} ne doivent pas enjamber les lignes vides du
listing de départ.



\bigskip
\subsection{Mise en évidence d'identificateurs}

\indexcommand{SetPitonIdentifier}
\label{SetPitonIdentifier}

La commande \DefinitionCommand{SetPitonIdentifier} permet de changer automatiquement le
formatage de certains identificateurs en se fondant sur leur nom.

\smallskip
Cette commande prend trois arguments : un optionnel et deux obligatoires.

\begin{itemize}
\item L'argument optionnel (entre crochets) indique le langage (informatique) concerné ;
si cet argument est absent, les réglages faits par |\SetPitonIdentifier| s'appliqueront à
tous les langages.\footnote{On rappelle que, dans \pkg{piton}, les noms des langages
  informatiques ne sont pas sensibles à la casse.}

\item Le premier argument obligatoire est une liste de noms d'identificateurs séparés par
des virgules.

\item Le deuxième argument obligatoire est une liste d'instructions LaTeX de formatage du
même type que pour les styles précédemment définis (cf. \ref{styles},
p.~\pageref{styles}).


\end{itemize}

\emph{Attention} : Seuls les identificateurs peuvent voir leur formatage affecté. Les
mots-clés et les noms de fonctions prédéfinies ne seront pas affectés, même s'ils figurent
dans le premier argument de |\SetPitonIdentifier|.

\medskip
\begin{Code}
\emph{\SetPitonIdentifier{l1,l2}{\color{red}}}
\begin{Piton}
def tri(l):
    """Tri par segmentation"""
    if len(l) <= 1:
        return l
    else:
        a = l[0]
        l1 = [ x for x in l[1:] if x < a  ]
        l2 = [ x for x in l[1:] if x >= a ]
        return tri(l1) + [a] + tri(l2)
\end{Piton}
\end{Code}


\bigskip

\begingroup

\SetPitonIdentifier{l1,l2}{\color{red}}

\begin{Piton}
def tri(l):
    """Tri par segmentation"""
    if len(l) <= 1:
        return l
    else:
        a = l[0]
        l1 = [ x for x in l[1:] if x < a  ]
        l2 = [ x for x in l[1:] if x >= a ]
        return tri(l1) + [a] + tri(l2)
\end{Piton}

\endgroup

\bigskip
Avec la commande |\SetPitonIdentifiers|, on peut ajouter à un langage informatique de
nouvelles fonctions prédéfinies (ou de nouveaux mots-clés, etc.) qui seront détectées par
\pkg{piton}.

\medskip
\begin{Code}
\emph{\SetPitonIdentifier[Python]}
  {cos, sin, tan, floor, ceil, trunc, pow, exp, ln, factorial}
  {\PitonStyle{Name.Builtin}}

\begin{Piton}
from math import *
cos(pi/2) 
factorial(5)
ceil(-2.3) 
floor(5.4) 
\end{Piton}
\end{Code}



\medskip
\begingroup

\SetPitonIdentifier[Python]
  {cos, sin, tan, floor, ceil, trunc, pow, exp, ln, factorial}
  {\PitonStyle{Name.Builtin}}
 
\begin{Piton}
from math import *
cos(pi/2) 
factorial(5)
ceil(-2.3) 
floor(5.4) 
\end{Piton}


\endgroup



\subsection{Les échappements vers LaTeX}

\index{echappements@échappements vers LaTeX}
\label{LaTeX-escapes}

L'extension \pkg{piton} propose plusieurs mécanismes d'échappement vers LaTeX :
\begin{itemize}
\item Il est possible d'avoir des commentaires entièrement composés en LaTeX.
\item Il est possible d'avoir, dans les commentaires, les éléments entre
\texttt{\$} composés en mode mathématique de LaTeX.
\item Il est possible de demander à \pkg{piton} de détecter directement certaines
commandes LaTeX avec leur argument.
\item Il est possible d'insérer du code LaTeX à n'importe quel endroit d'un listing.
\end{itemize}
Ces mécanismes vont être détaillés dans les sous-parties suivantes.

\smallskip
À remarquer également que, dans le cas où \pkg{piton} est utilisée dans la classe
\cls{beamer}, \pkg{piton} détecte la plupart des commandes et environnements de Beamer :
voir la sous-section \ref{beamer}, p.~\pageref{beamer}.



\subsubsection{Les «commentaires LaTeX»}

\index{comment-latex}
\index{commentaires LaTeX}

Dans ce document, on appelle «commentaire LaTeX» des commentaires qui débutent par |#>|.
Tout ce qui suit ces deux caractères, et jusqu'à la fin de la ligne, sera composé comme du
code LaTeX standard.

Il y a deux outils pour personnaliser ces commentaires.

\begin{itemize}
\item Il est possible de changer le marquage syntaxique utilisé (qui vaut
initialement~|#>|). Pour ce faire, il existe une clé \Definition{comment-latex},
\emph{disponible uniquement dans le préambule du document}, qui permet de choisir les
caractères qui (précédés par~|#|) serviront de marqueur syntaxique.

Par exemple, avec le réglage suivant (fait dans le préambule du document) :

|\PitonOptions{comment-latex = LaTeX}|

les commentaires LaTeX commenceront par~|#LaTeX|.

Si on donne la valeur nulle à la clé |comment-latex|, tous les commentaires Python
(débutant par~|#|) seront en fait des «commentaires LaTeX».

\smallskip
\item Il est possible de changer le formatage du commentaire LaTeX lui-même en changeant
le style \pkg{piton} |Comment.LaTeX|.

Par exemple, avec |\SetPitonStyle{Comment.LaTeX = \normalfont\color{blue}}|, les
commentaires LaTeX seront composés en bleu.

Si on souhaite qu'un croisillon (|#|) soit affiché en début de commentaire dans le
\textsc{pdf}, on peut régler |Comment.LaTeX| de la manière suivante :

\begin{Verbatim}
\SetPitonStyle{Comment.LaTeX = \color{gray}\~#\normalfont\space }
\end{Verbatim}

Pour d'autres exemples de personnalisation des commentaires LaTeX, voir la partie \ref{example-comments}
p.~\pageref{example-comments}. 
\end{itemize}


\bigskip
\indexcommand{zlabel}
\indexcommand{zcref}
\index{label-as-zlabel}
Si l'utilisateur a demandé l'affichage des numéros de ligne avec |line-numbers|, il est
possible de faire référence à ce numéro de ligne avec la commande |\label| placée dans un
commentaire LaTeX.\footnote{Cette fonctionnalité est implémentée en redéfinissant, dans
  les environnements |{Piton}|, la commande |\label|. Il peut donc y avoir des
  incompatibilités avec les extensions qui redéfinissent (globalement) cette commande
  |\label| (comme \pkg{varioref}, \pkg{refcheck}, \pkg{showlabels}, etc.)}
De même, la commande |\zlabel| du paquetage \pkg{zref} peut être utilisée.\footnote{
  Y compris la commande |\zcref| de \pkg{zref-clever}.}
La clé |label-as-zlabel| qui est disponible dans |\PitonOptions| dans le préambule du document
permet d'utiliser |\label| à la place de |\zlabel| dans les commentaires LaTeX (ce qui est
le comportement par défaut de \pkg{zref} en général).

\subsubsection{La clé «math-comments»}

\index{math-comments}

Il est possible de demander que, dans les commentaires, les éléments placés
entre symboles \texttt{\$} soient composés en mode mathématique de LaTeX (le
reste du commentaire restant composé en verbatim).

La clé \Definition{math-comments} (\emph{qui ne peut être activée que dans le préambule du
  document}) active ce comportement.

\bigskip
Dans l'exemple suivant, on suppose que |\PitonOptions{math-comments}| a été utilisé dans
le préambule du document.

\begin{Verbatim}
\begin{Piton}
def carré(x):
    return x*x ~# renvoie $x^2$
\end{Piton}
\end{Verbatim}

\begin{Piton}
def carré(x):
    return x*x # renvoie $x^2$
\end{Piton}



\subsubsection{La clé «detected-commands» et ses variantes}

\index{detected-commands (clé)}
\index{raw-detected-commands (clé)}
\index{vertical-detected-commands (clé)}
\label{detected-commands}
\label{raw-detected-commands}
\label{vertical-detected-commands}

La clé \Definition{detected-commands} de |\PitonOptions| permet de spécifier une liste de
noms de commandes LaTeX qui seront directement détectées par \pkg{piton}.

\begin{itemize}
\item Cette clé |detected-commands| ne peut être utilisée que dans le préambule du
document.

\item Les noms de commandes LaTeX peuvent apparaître \emph{avec} ou \emph{sans}
la contre-oblique (ex. : |detected-commands = { \emph , textbf }|).

\item Ces commandes doivent être des commandes LaTeX à un seul argument obligatoire entre
accolades (et ces accolades doivent apparaître explicitement dans le listing).

\item Ces commandes doivent être des commandes qui s'exécutent en mode horizontal de LaTeX
(à l'intérieur d'une ligne de code).

\item Ces commandes doivent être \textbf{protégées}\footnote{On rappelle que, par défaut,
  |\NewDocumentCommand| crée des commandes protégées au contraire de la commande
  historique |\newcommand| de LaTeX (et de |\def| de TeX).} contre le développement au
sens de TeX (car la commande |\piton| développe son argument avant de le passer à Lua pour
analyse syntaxique).
\end{itemize}

\medskip
Dans l'exemple suivant, qui est une programmation récursive en C de la
factorielle, on décide de surligner en jaune l'appel récursif. La commande
|\highLight| de \pkg{lua-ul}\footnote{L'extension \pkg{lua-ul} requiert
  elle-même l'extension \pkg{luacolor}.} permet de le faire facilement.

\begin{footnotesize}
\begin{Verbatim}
\PitonOptions{~emphase#detected-commands@ = \highLight} % dans le préambule
\end{Verbatim}
\end{footnotesize}

\begin{Verbatim}
\begin{Piton}[language=C]
int factorielle(int n)
  {
    if (n > 0) ~emphase#\highLight{return n * factorielle(n - 1)}@ ;
    else return 1;
  }
\end{Piton}
\end{Verbatim}

\begin{Piton}[language=C]
int factorielle(int n)
  {
    if (n > 0) \highLight{return n * factorielle(n - 1)} ;
    else return 1;
  }
\end{Piton}

\bigskip
La clé \Definition{raw-detected-commands} est similaire à la clé |detected-commands| mais
\pkg{piton} ne fera pas d'analyse syntaxique des arguments des commandes LaTeX ainsi
détectées.

S'il y a un retour à la ligne dans un argument d'une commande faisant l'objet d'un
|raw-detected-commands|, celui-ci sera remplacé par une espace comme le fait LaTeX par
défaut. 

\medskip
Supposons, par exemple, que l'on souhaite, dans le texte courant d'un document
traitant des bases de données, introduire des spécifications de tables
\textsc{sql} par le nom de la table, suivi, entre parenthèses, par les noms de
ses champs (ex. : |client (non, prénom)|).

Si on insère cet élément dans une commande |\piton|, le mot \emph{client} ne va pas
être reconnu comme un nom de table mais comme un nom de champ. On peut définir
une commande personnelle |\NomTable|
à appliquer à la main aux noms des tables. Pour cela, on la déclare avec
|raw-detected-commands| pour que son argument ne soit pas réanalysé par \pkg{piton}
(cette réanalyse entraînerait son formatage comme un nom de champ).


\medskip
Dans le préambule du document LaTeX, on insère les lignes suivantes :
\begin{Verbatim}
\NewDocumentCommand{\NomTable}{m}{{\PitonStyle{Name.Table}{~#1}}}
\PitonOptions{language=SQL, ~emphase#raw-detected-commands = \NomTable@}
\end{Verbatim}

Dans le corps du document, l'instruction :

\begin{Verbatim}
Exemple : \piton{\NomTable{client} (nom, prénom)}
\end{Verbatim}

\NewDocumentCommand{\NomTable}{m}{{\PitonStyle{Name.Table}{#1}}}

donne alors le résultat suivant :

\smallskip
\begingroup
\PitonOptions{language=SQL}%
Exemple : \piton{\NomTable{client} (nom, prénom)}
\endgroup


\bigskip
La clé \Definition{vertical-detected-commands} est similaire à la clé
|raw-detected-commands| mais les commandes ainsi détectées doivent être des
commandes LaTeX (à un argument) qui s'exécutent en mode vertical entre les lignes
du listing.

\smallskip
On peut par exemple demander la détection de |\newpage| par

\begin{Verbatim}
\PitonOptions{~emphase#vertical-detected-commands@ = \newpage}
\end{Verbatim}

et demander dans un listing un saut de page obligatoire par |\newpage{}| (la paire
d'accolades |{}| est obligatoire car les commandes détectées par \pkg{piton} sont censées
être des commandes LaTeX à un seul argument obligatoire).

\medskip
\begin{Code}
\begin{Piton}
def carré(x):
    return x*x   \emph{\textbackslash{}newpage{}}
def cube(x):
    return x*x*x
\end{Piton}    
\end{Code}

\medskip
On peut aussi envisager de demander la détection de la commande |\vspace|.

\subsubsection{Le mécanisme «escape»}

\index{begin-escape}
\index{end-escape}
\label{escape}

Il est aussi possible de surcharger les listings informatiques pour y insérer du code
LaTeX à peu près n'importe où (mais entre deux lexèmes, bien entendu). Cette
fonctionnalité n'est pas activée par défaut par \pkg{piton}. Pour l'utiliser, il faut
spécifier les deux délimiteurs marquant l'échappement (le premier le commençant et le
deuxième le terminant) en utilisant les clés \Definition{begin-escape} et
\Definition{end-escape} (\emph{qui ne sont accessibles que dans le préambule du
  document}). Les deux délimiteurs peuvent être identiques.

\medskip
On reprend l'exemple précédent de la factorielle et on souhaite surligner en rose
l'instruction qui contient l'appel récursif. La commande |\highLight| de \pkg{lua-ul}
permet de le faire avec la syntaxe |\highLight[LightPink]{...}|. Du fait de la présence de
l'argument optionnel entre crochets, on ne peut pas utiliser la clé |detected-commands|
comme précédemment mais on peut utiliser le mécanisme «escape» qui est plus général.

\smallskip
\begin{small}
\begin{Verbatim}
\PitonOptions{~emphase#begin-escape=!,end-escape=!@} % dans le préambule du document LaTeX
\end{Verbatim}
\end{small}

\medskip
\begin{Verbatim}
\begin{Piton}
def fact(n):
    if n==0:
        return 1
    else:
        ~emphase#!\highLight[LightPink]{!@return n*fact(n-1)~emphase#!}!@
\end{Piton}
\end{Verbatim}

\medskip
\begin{Piton}
def fact(n):
    if n==0:
        return 1
    else:
        ?\highLight[LightPink]{?return n*fact(n-1)?}?
\end{Piton}



\bigskip
\emph{Attention} : Le mécanisme «escape» n'est pas actif dans les chaînes de caractères ni
dans les commentaires (pour avoir un commentaire entièrement en échappement vers LaTeX,
c'est-à-dire ce qui est appelé dans ce document «commentaire LaTeX», il suffit de le faire
débuter par |#>|).


\subsubsection{Le mécanisme «escape-math»}

\index{escape-math}
\index{begin-escape-math}
\index{end-escape-math}

Le mécanisme «escape-math» est très similaire au mécanisme «escape» puisque la seule
différence est que les éléments en échappement LaTeX y sont composés en mode mathématique.

On active ce mécanisme avec les clés \Definition{begin-escape-math} et
\Definition{end-escape-math} (\emph{qui ne sont accessibles que dans le préambule du
  document}).

\medskip
Malgré la proximité technique, les usages du mécanisme «escape-math» sont en fait assez
différents de ceux du mécanisme «escape». En effet, comme le contenu en échappement est
composé en mode mathématique, il est, en particulier, composé dans un groupe TeX et ne
pourra donc pas servir à changer le formatage d'autres unités lexicales.

\medskip
Dans les langages où le caractère |$| ne joue pas un rôle syntaxique important, on peut
assez naturellement vouloir activer le mécanisme «escape-math» avec le caractère |$|:
\begin{Verbatim}
\PitonOptions{~emphase#begin-escape-math=$,end-escape-math=$@}
\end{Verbatim}
Remarquer que le caractère |$| ne doit \emph{pas} être protégé par une contre-oblique. % $

\bigskip
Néanmoins, il est sans doute plus prudent d'utiliser |\(| et |\)|, qui sont des
délimiteurs du mode mathématique proposés par LaTeX.
\begin{Verbatim}
\PitonOptions{~emphase#begin-escape-math=\(,end-escape-math=\)@}
\end{Verbatim}

\bigskip
Voici un exemple d'utilisation typique :

\begin{Verbatim}
\begin{Piton}[line-numbers]
def arctan(x,n=10):
    if ~emphase#\(x < 0\)@
        return ~emphase#\(-\arctan(-x)\)@
    elif ~emphase#\(x > 1\)@ : 
        return ~emphase#\(\pi/2 - \arctan(1/x)\)@
    else: 
        s = ~emphase#\(0\)@
        for ~emphase#\(k\)@ in range(~emphase#\(n\)@): s += ~emphase#\(\smash{\frac{(-1)^k}{2k+1} x^{2k+1}}\)@
        return s
\end{Piton}
\end{Verbatim}


\bigskip

\begin{Piton}[line-numbers]
def arctan(x,n=10):
    if \(x < 0\) :
        return \(-\arctan(-x)\) 
    elif \(x > 1\) : 
        return \(\pi/2 - \arctan(1/x)\) 
    else: 
        s = \(0\)
        for \(k\) in range(\(n\)): s += \(\smash{\frac{(-1)^k}{2k+1} x^{2k+1}}\)
        return s
\end{Piton}


\subsection{Comportement dans la classe Beamer}

\label{beamer}

\index{Beamer@\cls{Beamer} (classe)}

\emph{Première remarque}

\nobreak
Remarquons que, comme l'environnement |{Piton}| prend son argument selon un mode verbatim,
il convient, ce qui n'est pas surprenant, de l'utiliser dans des environnements |{frame}|
de Beamer protégés par la clé |fragile|, c'est-à-dire débutant par
|\begin{frame}[fragile]|.\footnote{On rappelle que pour un environnement |{frame}| de
  Beamer qui utilise la clé |fragile|, l'instruction |\end{frame}| doit être seule sur une
  ligne (à l'exception d'éventuels espaces en début de ligne).}

Rappelons également que si le \emph{frame} ne contient qu'une seule diapo (\emph{slide}),
il vaut mieux écrire : |\begin{frame}[fragile=singleslide]|

\medskip
Quand l'extension \pkg{piton} est utilisée dans la classe
\cls{beamer}\footnote{L'extension \pkg{piton} détecte la classe \cls{beamer} et
  l'extension \pkg{beamerarticle} si elle est chargée précédemment, mais il est aussi
  possible, si le besoin s'en faisait sentir, d'activer ce comportement avec la clé
  |beamer| au chargement de \pkg{piton} : |\usepackage[beamer]{piton}|}, le comportement
de \pkg{piton} est légèrement modifié, comme décrit maintenant.

\subsubsection{\{Piton\} et \textbackslash PitonInputFile sont ``overlay-aware''}

Quand \pkg{piton} est utilisé avec Beamer, la command |\PitonInputFile| et
l'environnement |{Piton}| (mais pas les environnements créés par
|\NewPitonEnvironment|) acceptent l'argument optionnel |<...>| de Beamer pour
indiquer les «\emph{overlays}» concernés. Cela est fait via un environnement |{actionenv}|
de Beamer.

On peut par exemple écrire :

\begin{Verbatim}
\begin{Piton}~emphase#<2-5>@
...
\end{Piton}
\end{Verbatim}

ou aussi 

\begin{Verbatim}
\PitonInputFile~emphase#<2-5>@{mon_fichier.py}
\end{Verbatim}



\subsubsection{Commandes de Beamer reconnues dans \{Piton\} et \textbackslash PitonInputFile}

\index{detected-beamer-commands}

Quand \pkg{piton} est utilisé dans la classe \cls{beamer}, les commandes suivantes de
\cls{beamer} (classées selon leur nombre d'arguments obligatoires) sont directement
reconnues dans les environnements |{Piton}| (ainsi que dans les listings composés par la
commande |\PitonInputFile|, même si c'est sans doute moins utile).
%
\begin{itemize}
\item aucun argument obligatoire : |\pause|\footnote{On remarquera que, bien sûr, on peut
aussi utiliser |\pause| dans un «commentaire LaTeX», c'est-à-dire en écrivant 
|#> \pause|. Ainsi, si le code Python est copié, il est   interprétable par Python.} ;  
\item un argument obligatoire : |\action|, |\alert|, |\invisible|, |\only|, |\uncover| et
|\visible| ; \newline 
La clé \Definition{detected-beamer-commands} permet de rajouter à cette liste de nouveaux
noms de commandes (les noms de commandes ne doivent \emph{pas} être précédés de la
contre-oblique) ;  
\item deux arguments obligatoires : |\alt| ;
\item trois arguments obligatoires : |\temporal|.
\end{itemize}

\medskip
Ces commandes doivent être utilisées précédées et suivies d'un espace. Les accolades dans
les arguments obligatoires de ces commandes doivent être équilibrées (cependant, les
accolades présentes dans des chaînes courtes\footnote{Les chaînes courtes de Python sont
  les chaînes (string) délimitées par les caractères \texttt{'} ou \texttt{"} non triplés.
  En Python, les chaînes de caractères courtes ne peuvent pas s'étendre sur plusieurs
  lignes de code.} de Python ne sont pas prises en compte).

\medskip
Concernant les fonctions |\alt| et |\temporal|, aucun retour à la ligne ne doit se trouver
dans les arguments de ces fonctions.



\medskip
Voici un exemple complet de fichier :

\medskip
\begin{small}
\begin{Code}
\documentclass{beamer}
\usepackage{piton}
\begin{document}
\begin{frame}[fragile]
\begin{Piton}
def string_of_list(l):
    """Convertit une liste de nombres en chaîne"""
    \emph{\only<2->{s = "{" + str(l[0])}}
    \emph{\only<3->{for x in l[1:]: s = s + "," + str(x)}}
    \emph{\only<4->{s = s + "}"}}
    return s
\end{Piton}
\end{frame}
\end{document}
\end{Code}
\end{small}

\medskip
Dans cet exemple, les accolades des deux chaînes de caractères Python |"{"| et
  |"}"| sont correctement interprétées (sans aucun caractère d'échappement).


\bigskip
\subsubsection{Environnements de Beamer reconnus dans \{Piton\} et \textbackslash PitonInputFile}

Quand \pkg{piton} est utilisé dans la classe \pkg{beamer}, les environnements suivants de
Beamer sont directement reconnus dans les environnements |{Piton}| (ainsi que dans les
listings composés par la commande |\PitonInputFile| même si c'est sans doute moins utile)
: |{actionenv}|, |{alertenv}|, |{invisibleenv}|, |{onlyenv}|, |{uncoverenv}| et
|{visibleenv}|.

\smallskip
\index{detected-beamer-environments} 
On peut ajouter de nouveaux environnements à cette liste d'environnements reconnus avec la
clé \Definition{detected-beamer-environments}.

\medskip
Il y a néanmoins une restriction : ces environnements doivent englober des \emph{lignes
  entières de code}. Les instructions |\begin{...}| et |\end{...}| doivent être
seules sur leurs lignes.


\medskip
On peut par exemple écrire :

\medskip
\begin{small}
\begin{Code}
\documentclass{beamer}
\usepackage{piton}
\begin{document}
\begin{frame}[fragile]
\begin{Piton}
def carré(x):
    """Calcule le carré de l'argument"""
\emph{\begin{uncoverenv}<2>}
    return x*x
\emph{\end{uncoverenv}}
\end{Piton}
\end{frame}
\end{document}
\end{Code}
\end{small}


\vspace{1cm} 
\textbf{Remarque à propos de la commande \textbackslash alert et de
  l'environnement \{alertenv\} de Beamer}

\nobreak
\smallskip
Beamer propose un moyen aisé de changer la couleur utilisée par l'environnement
|{alertenv}| (et par suite la commande |\alert| qui s'appuie dessus). Par exemple, on peut
écrire:

\begin{Verbatim}
\setbeamercolor{~emphase#alerted text@}{fg=blue} 
\end{Verbatim}

Néanmoins, dans le cas d'une utilisation à l'intérieur d'un environnement |{Piton}| un tel
réglage n'est sans doute pas pertinent, puisque, justement, \pkg{piton} va (le plus
souvent) changer la couleur des élements selon leur valeur lexicale. On préfèrera sans
doute un environnement |{alertenv}| qui change la couleur de fond des éléments à mettre en
évidence.

\smallskip
Voici un code qui effectuera ce travail en mettant un fond jaune. Ce code utilise la
commande |\@highLight| de l'extension \pkg{lua-ul} (cette extension nécessite elle-même
l'extension \pkg{luacolor}).

\begingroup
\fvset{commandchars=\~\#\+,formatcom=\color{gray}}
\begin{Verbatim}
\setbeamercolor{alerted text}{bg=yellow!50}
\makeatletter
\AddToHook{env/Piton/begin}
  {\renewenvironment<>{alertenv}{\only~#1{~emphase#\@highLight+[alerted text.bg]}}{}}
\makeatother
\end{Verbatim}
\endgroup

Ce code redéfinit localement l'environnement |{alertenv}| à l'intérieur de l'environnement
|{Piton}| (on rappelle que la commande |\alert| s'appuie sur cet environnement
|{alertenv}|).


\bigskip
\subsection{Notes de pied de page dans les environnements de piton}

\index{footnote@\pkg{footnote} (extension)}
\index{footnote (clé)}
\index{footnotehyper@\pkg{footnotehyper} (extension)}
\index{footnotehyper (clé)}

\label{footnote}


\smallskip
Si vous voulez mettre des notes de pied de page dans un environnement de \pkg{piton} (ou
bien dans un listing produit par |\PitonInputFile|, bien que cela paraisse moins pertinent
dans ce cas-là) vous pouvez utiliser une paire |\footnotemark|--|\footnotetext|.

\smallskip
Néanmoins, il est également possible d'extraire les notes de pieds de page avec
l'extension \pkg{footnote} ou bien l'extension \pkg{footnotehyper}.

\smallskip
Si \pkg{piton} est chargée avec l'option \Definition{footnote} (avec
|\usepackage[footnote]{piton}|) l'extension \pkg{footnote} est chargée (si elle ne l'est
pas déjà) et elle est utilisée pour extraire les notes de pied de page.

\smallskip
Si \pkg{piton} est chargée avec l'option \Definition{footnotehyper}, l'extension
\pkg{footnotehyper} est chargée (si elle ne l'est pas déjà) et elle est utilisée pour
extraire les notes de pied de page.

\smallskip
Attention : Les extensions \pkg{footnote} et \pkg{footnotehyper} sont incompatibles.
L'extension \pkg{footnotehyper} est le successeur de l'extension \pkg{footnote} et devrait
être utilisée préférentiellement. L'extension \pkg{footnote} a quelques défauts ; en
particulier, elle doit être chargée après l'extension \pkg{xcolor} et elle n'est pas
parfaitement compatible avec \pkg{hyperref}.


\medskip
\textbf{Remarque importante} : Si vous utilisez Beamer, il faut savoir que Beamer a son
propre système d'extraction des notes de pied de page et vous n'avez donc pas à charger
\pkg{piton} avec la clé |footnote| ou bien la clé |footnotehyper|.

\bigskip
Par défaut, une commande |\footnote| ne peut apparaître que dans un «commentaire LaTeX».
Mais on peut aussi ajouter la commande |\footnote| à la liste des
\emph{detected-commands} (cf.~partie~\ref{detected-commands},
p.~\pageref{detected-commands}). 

\medskip
Dans ce document, l'extension \pkg{piton} a été chargée avec l'option |footnotehyper| et
on rajouté la commande |\footnote| aux \emph{detected-commands} avec le code suivant
dans le préambule du document LaTeX :

\qquad \verb|\PitonOptions{detected-commands = footnote}|

\begingroup
\fvset{commandchars=\~\&\@,formatcom=\small\color{gray}}
\begin{Verbatim}
\PitonOptions{background-color=gray!15}
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)~emphase&\footnote{Un premier appel récursif.}@
    elif x > 1: 
        return pi/2 - arctan(1/x)~emphase&\footnote{Un deuxième appel récursif.}@
    else: 
        return sum( (-1)**k/(2*k+1)*x**(2*k+1) for k in range(n) ) 
\end{Piton}
\end{Verbatim}
\endgroup

\begingroup
\PitonOptions{background-color=gray!15}
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)\footnote{Un premier appel récursif.}
    elif x > 1: 
        return pi/2 - arctan(1/x)\footnote{Un deuxième appel récursif.}
    else: 
        return sum( (-1)**k/(2*k+1)*x**(2*k+1) for k in range(n) ) 
\end{Piton}
\endgroup


\vspace{1cm}

Si on utilise l'environnement |{Piton}| dans un environnement |{minipage}| de LaTeX, les
notes sont, bien entendu, composées au bas de l'environnement |{minipage}|. Rappelons
qu'une telle |{minipage}| ne peut \emph{pas} être coupée par un saut de page.


\begingroup
\fvset{commandchars=\~\&\@,formatcom=\small\color{gray}}
\begin{Verbatim}
\PitonOptions{background-color=gray!15}
~emphase&\begin{minipage}{\linewidth}@
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)~emphase&\footnote{Un premier appel récursif.}@
    elif x > 1: 
        return pi/2 - arctan(1/x)~emphase&\footnote{Un deuxième appel récursif.}@
    else: 
        return sum( (-1)**k/(2*k+1)*x**(2*k+1) for k in range(n) ) 
\end{Piton}
~emphase&\end{minipage}@
\end{Verbatim}
\endgroup

\begingroup
\PitonOptions{background-color=gray!15}
\begin{minipage}{\linewidth}
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)\footnote{Un premier appel récursif.}
    elif x > 1: 
        return pi/2 - arctan(1/x)\footnote{Un deuxième appel récursif.}
    else: 
        return sum( (-1)**k/(2*k+1)*x**(2*k+1) for k in range(n) ) 
\end{Piton}
\end{minipage}
\endgroup



\subsection{Tabulations}

\index{tabulations}
\index{tab-size}

\smallskip
Même s'il est sans doute recommandable d'indenter les listings informatiques avec des
espaces et non des tabulations\footnote{Voir, par exemple, pour le langage Python, la note PEP~8.},
\pkg{piton} accepte les caractères de tabulations (U+0009) en début de ligne. Chaque
caractère U+0009 est remplacé par $n$ espaces. La valeur initiale de~$n$ est~4 mais on
peut la changer avec la clé \Definition{tab-size} de |\PitonOptions|.

\smallskip
Il existe aussi une clé \Definition{tabs-auto-gobble} qui détermine le nombre minimal de
caractères U+0009 débutant chaque ligne (non vide) de l'environnement |{Piton}| et
applique |gobble| avec cette valeur (avant le remplacement des caractères U+0009 par des
espaces, bien entendu). Cette clé est donc similaire à la clé |auto-gobble| mais agit sur
des caractères U+0009 au lieu de caractères U+0020 (espaces).

\smallskip
La clé |env-gobble| n'est pas compatible avec les tabulations.


\section{API pour les développeurs}


\index{piton.last@\texttt{piton.get\_last\_code} (fonction Lua)}
\label{API}

La variable L3 \DefinitionCommand{l_piton_language_str} contient le nom du
langage courant (en minuscules).

\bigskip

L'extension \pkg{piton} fournit une fonction Lua
\Definition{piton.get_last_code} sans argument permettant de récupérer le code
contenu dans le dernier environnement de \pkg{piton}.
\begin{itemize}
\item Les retours à la ligne (présents dans l'environnement de départ)
apparaissent comme des caractères |\r| (c'est-à-dire des caractères U+000D).

\item Le code fourni par |piton.get_last_code()| tient compte de l'éventuelle
application d'une clé |gobble| (cf. p.~\pageref{gobble}).

\item Les surcharges du code (qui entraînent des échappements vers LaTeX) ont
été retirées du code fourni par |piton.get_last_code()|. Cela s'applique aux
commandes LaTeX déclarées par la clé |detected-commands| et ses variantess (cf.
partie~\ref{detected-commands}) et aux éléments insérés avec le mécanisme
«|escape|» (cf. partie~\ref{escape}).

\item |piton.get_last_code| est une fonction Lua et non une chaîne de caractères
: les traitements présentés précédemment sont exécutés lorsque la fonction est
appelée. De ce fait, il peut être judicieux de stocker la valeur renvoyée par
|piton.get_last_code()| dans une variable Lua si on doit l'utiliser plusieurs
fois.
\end{itemize}

\medskip
Pour un exemple d'utilisation, voir la partie concernant l'utilisation
(standard) de \pkg{pyluatex}, partie~\ref{pyluatex}, p.~\pageref{pyluatex}.

\section{Exemples}



\subsection{Un exemple de réglage des styles}

Les styles graphiques ont été présentés à la partie \ref{styles}, p.~\pageref{styles}.

\smallskip
On présente ici un réglage de ces styles adapté pour les documents en noir et blanc.

Ce réglage utilise la commande |\highLight| de \pkg{lua-ul} (cette extension nécessite
elle-même l'extension \pkg{luacolor}).


\begin{Verbatim}
\SetPitonStyle
  {
    Number = ,
    String = \itshape , 
    String.Doc = \color{gray} \itshape ,
    Operator = , 
    Operator.Word = \bfseries ,
    Name.Builtin = ,
    Name.Function = \bfseries \highLight[gray!20] ,
    Comment = \color{gray} ,
    Comment.LaTeX = \normalfont \color{gray},
    Keyword = \bfseries ,
    Name.Namespace = ,
    Name.Class = , 
    Name.Type = ,
    InitialValues = \color{gray}
  }
\end{Verbatim}


Dans ce réglage, de nombreuses valeurs fournies aux clés sont vides, ce qui
signifie que le style correspondant n'insèrera aucune instruction de formatage,
si ce n'est celles données par le paramètre |font-command|, dont la valeur
initiale est |\ttfamily| (l'élément sera composé dans la couleur standard, le
plus souvent, en noir, etc.). Ces entrées avec valeurs nulles sont néanmoins
nécessaires car la valeur initiale de ces styles dans \pkg{piton} n'est
\emph{pas} vide.

\begingroup

\SetPitonStyle
  {
    Number = ,
    String = \itshape , 
    String.Doc = \color{gray} \itshape ,
    Operator = , 
    Operator.Word = \bfseries ,
    Name.Builtin = ,
    Name.Function = \bfseries \highLight[gray!20] ,
    Comment = \color{gray} ,
    Comment.LaTeX = \normalfont \color{gray},
    Keyword = \bfseries ,
    Name.Namespace = ,
    Name.Class = , 
    Name.Type = ,
    InitialValues = \color{gray}
  }


\bigskip 

\begin{Piton}
from math import pi

def arctan(x,n=10):
    """Compute the mathematical value of arctan(x)

    n is the number of terms in the sum
    """
    if x < 0:
        return -arctan(-x) # appel récursif
    elif x > 1: 
        return pi/2 - arctan(1/x) 
        #> (on a utilisé le fait que $\arctan(x)+\arctan(1/x)=\pi/2$ pour $x>0$)
    else: 
        s = 0
        for k in range(n):
            s += (-1)**k/(2*k+1)*x**(2*k+1)
        return s 
\end{Piton}


\endgroup


\subsection{Numérotation des lignes}

\label{example-numbering}
\index{numérotation des lignes de code|emph}

On rappelle que l'on peut demander la numérotation des lignes des listings avec
la clé |line-numbers| (utilisée sans valeur).

Par défaut, les numéros de ligne sont composés par \pkg{piton} en débordement à
gauche (en utilisant en interne la commande |\llap| de LaTeX).


\begingroup
\fvset{commandchars=\~\&\@,formatcom=\small\color{gray}}
\begin{Verbatim}
~emphase&\PitonOptions{background-color=gray!15, line-numbers}@
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)        #> (appel récursif)
    elif x > 1: 
        return pi/2 - arctan(1/x) #> (autre appel récursif) 
    else:
        s = 0.0
        for k in range(n):
            s = s + (-1)**k/(2*k+1)*x**(2*k+1)
        return s
\end{Piton}
\end{Verbatim}
\endgroup



\begingroup
\PitonOptions{background-color=gray!15,line-numbers}
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)        #> (appel récursif)
    elif x > 1: 
        return pi/2 - arctan(1/x) #> (autre appel récursif) 
    else:
        s = 0.0
        for k in range(n):
            s = s + (-1)**k/(2*k+1)*x**(2*k+1)
        return s
\end{Piton}
\endgroup

\bigskip

Si on ne veut pas de débordement, on peut utiliser l'option |left-margin=auto| qui va
insérer une marge adaptée aux numéros qui seront insérés (elle est plus large quand les
numéros dépassent 10).


\begingroup
\fvset{commandchars=\~\&\@,formatcom=\small\color{gray}}
\begin{Verbatim}
~emphase&\PitonOptions{background-color=gray!15, left-margin = auto, line-numbers}@
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)        #> (appel récursif)
    elif x > 1: 
        return pi/2 - arctan(1/x) #> (autre appel récursif) 
    else:
        s = 0.0
        for k in range(n):
            s = s + (-1)**k/(2*k+1)*x**(2*k+1)
        return s
\end{Piton}
\end{Verbatim}
\endgroup



\begingroup
\PitonOptions{background-color=gray!15,left-margin = auto, line-numbers}
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)        #> (appel récursif)
    elif x > 1: 
        return pi/2 - arctan(1/x) #> (autre appel récursif) 
    else:
        s = 0.0
        for k in range(n):
            s = s + (-1)**k/(2*k+1)*x**(2*k+1)
        return s
\end{Piton}
\endgroup


\bigskip
On peut aussi demander la composition des numéros à droite avec
|line-numbers/position=right| (la valeur initiale du paramètre
|line-numbers/position| est, sans surprise, |left|). Il est bon dans ce cas de
donner une valeur non nulle à |right-margin| (on peut aussi utiliser
|right-margin=auto| mais la valeur effective résultante pour |right-margin| paraîtra
dans doute trop faible en cas de longues lignes coupées).


\begingroup
\fvset{commandchars=\~\&\@,formatcom=\small\color{gray}}
\begin{Verbatim}
\PitonOptions
  {
    background-color=gray!15,
    ~emphase&line-numbers/position = right@,
    ~emphase&right-margin = 1cm@,
    ~emphase&line-numbers@
  }
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)        #> (appel récursif)
    elif x > 1: 
        return pi/2 - arctan(1/x) #> (autre appel récursif) 
    else:
        s = 0.0
        for k in range(n):
            s = s + (-1)**k/(2*k+1)*x**(2*k+1)
        return s
\end{Piton}
\end{Verbatim}
\endgroup



\begingroup
\PitonOptions
  {
    background-color=gray!15,
    line-numbers/position = right,
    right-margin = 1cm,
    line-numbers
  }
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)        #> (appel récursif)
    elif x > 1: 
        return pi/2 - arctan(1/x) #> (autre appel récursif) 
    else:
        s = 0.0
        for k in range(n):
            s = s + (-1)**k/(2*k+1)*x**(2*k+1)
        return s
\end{Piton}
\endgroup



\bigskip
Le même exemple avec la clé |width=min|.

\begingroup
\fvset{commandchars=\~\&\@,formatcom=\small\color{gray}}
\begin{Verbatim}
\PitonOptions
  {
    background-color=gray!15,
    ~emphase&line-numbers/position = right@,
    ~emphase&right-margin = 1cm@,
    ~emphase&line-numbers@,
    ~emphase&width=min@
  }
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)        #> (appel récursif)
    elif x > 1: 
        return pi/2 - arctan(1/x) #> (autre appel récursif) 
    else:
        s = 0.0
        for k in range(n):
            s = s + (-1)**k/(2*k+1)*x**(2*k+1)
        return s
\end{Piton}
\end{Verbatim}
\endgroup



\begingroup
\PitonOptions
  {
    background-color=gray!15,
    line-numbers/position = right,
    right-margin = 1cm,
    line-numbers,
    width=min
  }
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)        #> (appel récursif)
    elif x > 1: 
        return pi/2 - arctan(1/x) #> (autre appel récursif) 
    else:
        s = 0.0
        for k in range(n):
            s = s + (-1)**k/(2*k+1)*x**(2*k+1)
        return s
\end{Piton}
\endgroup



\bigskip

\subsection{Formatage des commentaires LaTeX}

\label{example-comments}
\index{commentaires LaTeX|emph}

On peut modifier le style |Comment.LaTeX| (avec |\SetPitonStyle|) pour faire afficher les
commentaires LaTeX (qui débutent par |#>|) en butée à droite.

\begingroup
\fvset{commandchars=\~\&\@,formatcom=\small\color{gray}}
\begin{Verbatim}
\PitonOptions{background-color=gray!15}
~emphase&\SetPitonStyle{Comment.LaTeX = \hfill \normalfont\color{gray}}@
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)        #> appel récursif
    elif x > 1: 
        return pi/2 - arctan(1/x) #> autre appel récursif 
    else: 
        return sum( (-1)**k/(2*k+1)*x**(2*k+1) for k in range(n) ) 
\end{Piton}
\end{Verbatim}
\endgroup

\begingroup
\PitonOptions{background-color=gray!15}
\SetPitonStyle{Comment.LaTeX = \hfill \normalfont\color{gray}}
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)        #> appel récursif
    elif x > 1: 
        return pi/2 - arctan(1/x) #> autre appel récursif 
    else: 
        return sum( (-1)**k/(2*k+1)*x**(2*k+1) for k in range(n) ) 
\end{Piton}
\endgroup


\vspace{1cm} On peut aussi faire afficher les commentaires dans une deuxième colonne à
droite si on limite la largeur du code proprement dit avec la clé |width|. 

\begingroup
\fvset{commandchars=\~\&\@,formatcom=\small\color{gray}}
\begin{Verbatim}
\PitonOptions{width=9cm, background-color=gray!15}
~emphase&\NewDocumentCommand{\MyLaTeXCommand}{m}{\hfill \normalfont\itshape\rlap{\quad #1}}@
~emphase&\SetPitonStyle{Comment.LaTeX = \MyLaTeXCommand}@
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)       #> appel récursif
    elif x > 1: 
        return pi/2 - arctan(1/x) #> autre appel récursif 
    else: 
        s = 0
        for k in range(n):
             s += (-1)**k/(2*k+1)*x**(2*k+1)
        return s 
\end{Piton}
\end{Verbatim}
\endgroup



\begingroup
\PitonOptions{width = 9cm , background-color=gray!15} 
\NewDocumentCommand{\MyLaTeXCommand}{m}{\hfill \normalfont\itshape\rlap{\quad #1}}
\SetPitonStyle{Comment.LaTeX = \MyLaTeXCommand}
\begin{Piton}
def arctan(x,n=10):
    if x < 0:
        return -arctan(-x)       #> appel récursif
    elif x > 1: 
        return pi/2 - arctan(1/x) #> autre appel récursif 
    else: 
        s = 0
        for k in range(n):
             s += (-1)**k/(2*k+1)*x**(2*k+1)
        return s 
\end{Piton}
\endgroup

\subsection{La commande \texttt{\textbackslash rowcolor}}

\indexcommand{rowcolor}

La commande |\rowcolor| a été décrite à la partie \ref{rowcolor},
p.~\pageref{rowcolor}, dans la partie sur les styles. Rappelons qu'elle impose
un fond coloré à la ligne courante (\emph{toute la ligne} et pas seulement la partie
contenant du texte).

\medskip
Cette commande |\rowcolor| peut être utilisée dans un style, comme illustré à la
page~\pageref{rowcolor} mais on peut aussi envisager de l'utiliser directement
dans un listing. Il faudra néanmoins utiliser un des mécanismes d'échappement
vers LaTeX fournis par \pkg{piton}. Dans l'exemple suivant, on utilise la clé
|raw-detected-commands| (cf.~p.~\pageref{raw-detected-commands}). On ne pourra
pas utiliser une syntaxe comme |\rowcolor[rgb]{0.8,1,0.8}| car les «commandes
détectées» sont des commandes à un seul argument mais on pourra utiliser
|\rowcolor{[rgb]{0.8,1,0.8}}| (syntaxe acceptée par |\rowcolor|).

\nobreak
\begin{footnotesize}
\begin{Verbatim}
\PitonOptions{raw-detected-commands = rowcolor} % dans le préambule
\end{Verbatim}
\end{footnotesize}

\medskip

\begin{BVerbatim}[boxwidth=87mm,baseline=c]
\begin{Piton}[width=min]
def fact(n):
    if n==0:
        return 1 ~emphase#\rowcolor{yellow!50}@
    else:
        return n*fact(n-1)
\end{Piton}        
\end{BVerbatim}
\hspace{1cm}
\begin{Piton}[width=min,box]
def fact(n):
    if n==0:
        return 1 \rowcolor{yellow!50}
    else:
        return n*fact(n-1)
\end{Piton}        


\bigbreak
Voici maintenant le même exemple avec utilisation conjointe de la clé
|background-color| (cf. p.~\pageref{background-color}).

\medskip
\begin{BVerbatim}[boxwidth=91mm,baseline=c]
\begin{Piton}[width=min,~emphase#background-color=gray!15@]
def fact(n):
    if n==0:
        return 1 ~emphase#\rowcolor{yellow!50}@
    else:
        return n*fact(n-1)
\end{Piton}        
\end{BVerbatim}
\hspace{6mm}
\begin{Piton}[width=min,box,background-color=gray!15]
def fact(n):
    if n==0:
        return 1 \rowcolor{yellow!50}
    else:
        return n*fact(n-1)
\end{Piton}        


\bigbreak
Comme on le constate, une marge a été ajoutée à gauche et à droite par la clé
|background-color|. Pour avoir une telle marge sans couleur de fond générale, il
convient d'utiliser |background-color| avec
la couleur spéciale |none|.

\medskip
\begin{BVerbatim}[boxwidth=87mm,baseline=c]
\begin{Piton}[width=min,~emphase#background-color=none@]
def fact(n):
    if n==0:
        return 1 ~emphase#\rowcolor{yellow!50}@
    else:
        return n*fact(n-1)
\end{Piton}        
\end{BVerbatim}
\hspace{1cm}
\begin{Piton}[width=min,box,background-color=none]
def fact(n):
    if n==0:
        return 1 \rowcolor{yellow!50}
    else:
        return n*fact(n-1)
\end{Piton}        



\subsection{Utilisation avec tcolorbox}

\label{examples-tcolorbox}
\index{tcolorbox (clé)|emph}

La clé |tcolorbox| de \pkg{piton} a été présentée à la page \pageref{tcolorbox}.

Si on souhaite l'utiliser en paramétrant la boîte graphique créée par
\pkg{tcolorbox} (avec les clés fournies par \pkg{tcolorbox}), il convient
d'utiliser la commande |\tcbset| de \pkg{tcolorbox}. Pour limiter la portée de
ces réglages, le mieux est sans doute de créer un nouvel environnement avec
|\NewPitonEnvironment| (cf.~p.~\pageref{NewPitonEnvironment}). Cet environnement
contiendra les personnalisations de \pkg{piton} (avec |\PitonOptions|) et celles
de \pkg{tcolorbox} (avec |\tcbset|).

\bigskip
Voici un exemple d'un tel environnement |{Python}| avec une colonne colorée à gauche
pour les numéros de ligne. 

\begin{footnotesize}
\begin{Verbatim}
\usepackage{tcolorbox}          % dans le préambule
\tcbuselibrary{breakable,skins} % dans le préambule
\end{Verbatim}
\end{footnotesize}

\medskip

\begin{Verbatim}
\NewPitonEnvironment{Python}{m}
  {%
    \PitonOptions
      {
        ~emphase#tcolorbox@,
        splittable=3,
        width=min,
        line-numbers,       % active les numéros de ligne
        line-numbers =      % personnalisation des numéros de ligne
         {
           format = \footnotesize\color{white}\sffamily ,
           sep = 2.5mm
         }
      }%
    \tcbset
      {
        enhanced,
        title=~#1,
        fonttitle=\sffamily,
        left = 6mm,
        top = 0mm,
        bottom = 0mm,
        overlay=
         {%
            \begin{tcbclipinterior}%
                \fill[gray!80]
                    (frame.south west) rectangle
                    ([xshift=6mm]frame.north west); 
            \end{tcbclipinterior}%
         }
      } 
  } 
  { }
\end{Verbatim}

\bigskip
Dans l'exemple d'utilisation qui suit, on a illustré le fait que l'on peut
forcer un saut de page dans un tel environnement avec |\newpage{}| si on a
demandé à \pkg{piton} de détecter la commande |\newpage| avec la clé
|vertical-detected-commands| (cf.~p.~\pageref{vertical-detected-commands}) dans
le préambule du document LaTeX.

Remarquer que l'on doit bien utiliser |\newpage{}| et non |\newpage| car les
commandes LaTeX détectées par \pkg{piton} sont censées être des commandes à un argument
entre accolades (les accolades doivent être explicites).

\begin{footnotesize}
\begin{Verbatim}
\PitonOptions{vertical-detected-commands = newpage}  % dans le préambule
\end{Verbatim}
\end{footnotesize}

\begin{Verbatim}
~emphase#\begin{Python}@{Mon exemple}
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x ~emphase#\newpage{}@
def carré(x):
    """Calcule le carré de x"""
    return x*x
...    
def carré(x):
    """Calcule le carré de x"""
    return x*x
~emphase#\end{Python}@
\end{Verbatim}

\bigskip

\RenewPitonEnvironment{Python}{m}
  {%
    \PitonOptions
      {
        tcolorbox,
        splittable=3,
        width=min,
        line-numbers,
        line-numbers =
         {
           format = \footnotesize\color{white}\sffamily ,
           sep = 2.5mm
         }
      }%
    \tcbset
      {
        enhanced,
        title=#1,
        fonttitle=\sffamily,
        left = 6mm,
        top = 0mm,
        bottom = 0mm,
        overlay=
         {%
            \begin{tcbclipinterior}%
                \fill[gray!80]
                    (frame.south west) rectangle
                    ([xshift=6mm]frame.north west); 
            \end{tcbclipinterior}%
         }
      } 
  } 
  { }
  

\begin{Python}{Mon exemple}
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x \newpage{}
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
def carré(x):
    """Calcule le carré de x"""
    return x*x
\end{Python}

\subsection{Utilisation avec pyluatex}

\subsubsection{Utilisation standard de pyluatex}

\label{pyluatex}
\index{pyluatex@{\pkg{pyluatex}} (extension)}


\textcolor{red}{Attention: Les codes qui suivent nécessitent la version 0.7.0 de \pkg{pyluatex}.}

\bigskip

L'extension \pkg{pyluatex} est une extension qui permet l'exécution de code Python à
partir de |lualatex| (pourvu que Python soit installé sur la machine et que la compilation
soit effectuée avec |lualatex| et |--shell-escape|).

Voici, à titre d'exemple, un environnement |{PitonExecute}| qui formate un listing Python
(avec \pkg{piton}) et qui affiche également dessous le résultat de l'exécution de ce code
avec Python.

\medskip
\begin{Code}
\NewPitonEnvironment{\emph{PitonExecute}}{O{}}
  {\PitonOptions{#1}}
  {\begin{center}
   \directlua
     {
       pyluatex.execute(piton.get_last_code(),false,cctab_latex,
         false,false,true,"default",false,false)
       tex.print(pyluatex.get_last_output())         
     }
   \end{center}}
\end{Code}

\medskip
\NewPitonEnvironment{PitonExecute}{O{}}
  {\PitonOptions{#1}}
  {\begin{center}
   \directlua
     {
       pyluatex.execute(piton.get_last_code(),false,cctab_latex,
         false,false,true,"default",false,false)
       tex.print(pyluatex.get_last_output()) 
     }
   \end{center}}


On a utilisé la fonction Lua |piton.get_last_code| fournie dans l'API de \pkg{piton} :
cf.~partie~\ref{API}, p.~\pageref{API}.

\bigskip
Cet environnement |{PitonExecute}| prend en argument optionnel (entre crochets) les
options proposées par la commande |\PitonOptions|.

\medskip
\begin{Verbatim}
\begin{~emphase#PitonExecute@}[background-color=gray!15]
def carré(x):
    """Calcule le carré de x"""
    return x*x
print(f'Le carré de 12 est {carré(12)}.')
\end{~emphase#PitonExecute@}
\end{Verbatim}


\medskip
\begin{PitonExecute}[background-color=gray!15]
def carré(x):
    """Calcule le carré de x"""
    return x*x
print(f'Le carré de 12 est {carré(12)}.')
\end{PitonExecute}

\bigskip
On peut, dans cet environnement, utiliser les mécanismes d'échappement vers
LaTeX de la même manière que précédemment (cf. p.~\pageref{LaTeX-escapes}).

\begin{footnotesize}
\begin{Verbatim}
\usepackage{luacolor,lua-ul}                  % dans le préambule
\PitonOptions{detected-commands = highLight}  % dans le préambule
\end{Verbatim}
\end{footnotesize}

\medskip
\begin{Verbatim}
\begin{PitonExecute}[background-color=gray!15]
def carré(x):
    """Calcule le carré de x"""
    ~emphase#\highLight{return x*x}@
print(f'Le carré de 12 est {carré(12)}.')
\end{PitonExecute}
\end{Verbatim}

\medskip
\begin{PitonExecute}[background-color=gray!15]
def carré(x):
    """Calcule le carré de x"""
    \highLight{return x*x}
print(f'Le carré de 12 est {carré(12)}.')
\end{PitonExecute}



\bigskip

\subsubsection{Utilisation de l'environnement \{python\} de pyluatex avec la clé repl}

\label{python}

\index{python@\texttt{\{python\}} (environnement de \pkg{pyluatex})}

Avec la clé |repl|, l'environnement |{python}| de \pkg{pyluatex} passe son
contenu à Python et renvoie ce que l'on obtient quand on fournit ce code à une
boucle \textsc{repl} (\emph{read-eval-print loop}) de Python. On obtient un
entrelacement d'instructions précédées par le prompt |>>>| de Python et des
valeurs renvoyées par Python (et de ce qui a été demandé d'être affiché avec des
\piton{print} de Python).

\medskip
Il est ensuite possible de passer cela à un environnement |{Piton}| qui va faire un
coloriage syntaxique et mettre sur fond grisé les lignes correspondant aux instructions
fournies à l'interpréteur Python (la couleur de ce fond est réglable avec la clé
|prompt-background-color| dont la valuer initiale est |gray!15|).


\medskip
Voici la programmation d'un environnement |{PitonREPL}| qui effectue ce travail (pour des
raisons techniques, le |!| est ici obligatoire dans la signature de l'environnement). On
ne peut pas procéder comme précédemment (dans l'utilisation «standard» de \pkg{pyluatex})
car, bien sûr, c'est le retour fait par |{python}| qui doit être traité par
\pkg{piton}. De ce fait, il ne sera pas possible de mettre des surcharges (avec
|detected-commands|, |begin-escape|, etc.) dans le code.

\begin{Verbatim}
\NewDocumentEnvironment{PitonREPL}{!O{}} % le ! est obligatoire
 { 
   \PitonOptions
     {
       ~emphase#prompt-background-color=blue!15@ ,
       ~emphase#background-color=none@, % pour avoir des petites marges
       ~#1
     }
   \PyLTVerbatimEnv
   \begin{python}[repl,quiet]
 }
 {
   \end{python}
   \directlua
     {
       tex.print("\\begin{Piton}")
       tex.print(pyluatex.get_last_output())
       tex.print("\\end{Piton}")
       tex.print("") 
     } 
   \ignorespacesafterend
 }
\end{Verbatim}

\medskip
Voici un exemple d'utilisation de ce nouvel environnement |{PitonREPL}|.

\medskip
\begin{Code}
\emph{\begin{PitonREPL}}
    def valeur_absolue(x):
        """Renvoie la valeur absolue de x"""
        if x > 0:
           return x
        else:
           return -x

    valeur_absolue(-3)
    valeur_absolue(0)
    valeur_absolue(5)
\emph{\end{PitonREPL}}
\end{Code}

\bigskip


\NewDocumentEnvironment { PitonREPL } { }
 { 
   \PitonOptions
     {
       prompt-background-color=blue!15 ,
       background-color=none ,
     }
   \PyLTVerbatimEnv
   \begin{python}[repl,quiet]
 }
 {
   \end{python}
    \directlua
     {
       tex.print("\\begin{Piton}")
       tex.print(pyluatex.get_last_output())
       tex.print("\\end{Piton}")
       tex.print("") 
     }
   \ignorespacesafterend
 }

 
\begin{PitonREPL}
    def valeur_absolue(x):
        """Renvoie la valeur absolue de x"""
        if x > 0:
           return x
        else:
           return -x

    valeur_absolue(-3)
    valeur_absolue(0)
    valeur_absolue(5)
\end{PitonREPL}


\bigskip
En fait, il est possible de ne pas faire afficher les prompts eux-mêmes (c'est-à-dire les
chaînes de caractères |>>>| et |...|). En effet, \pkg{piton} propose un style pour ces
éléments, qui est appelé |Prompt|. La valeur initial de ce style est vide, ce qui fait
qu'aucune action n'est exécutée sur ces éléments qui sont donc affichés tels quels. En
fournissant comme valeur une fonction qui se contente de gober son argument, on peut
demander à ce qu'ils ne soient pas affichés.

\bigskip
\begin{savenotes}
\begin{Verbatim}
\NewDocumentCommand{\Gobe}{m}{}#~color#black@~footnote#On a défini ici une fonction ~texttt#~string~Gobe@ mais, en fait, elle existe déjà en L3 sous le nom ~texttt#~string~use~_none:n@.@@
\SetPitonStyle{ ~emphase#Prompt = \Gobe@ }
\end{Verbatim}
\end{savenotes}




\NewDocumentCommand{\Gobe}{m}{}
\ExplSyntaxOn
\SetPitonStyle{ Prompt = \use_none:n }
\ExplSyntaxOff

\bigskip
L'exemple précédent donne alors :

\medskip
\begin{Code}
\emph{\begin{PitonREPL}}
    def valeur_absolue(x):
        """Renvoie la valeur absolue de x"""
        if x > 0:
           return x
        else:
           return -x

    valeur_absolue(-3)
    valeur_absolue(0)
    valeur_absolue(5)
\emph{\end{PitonREPL}}
\end{Code}


\bigskip

\begin{PitonREPL}
    def valeur_absolue(x):
        """Renvoie la valeur absolue de x"""
        if x > 0:
           return x
        else:
           return -x

    valeur_absolue(-3)
    valeur_absolue(0)
    valeur_absolue(5)
\end{PitonREPL}

\clearpage

\section{Les styles pour les différents langages informatiques}

\label{Semantic}


\subsection{Le langage Python}

Le langage par défaut de l'extension \pkg{piton} est Python. Si besoin est, on peut
revenir au langage Python avec |\PitonOptions{language=Python}|.

\bigskip

Les réglages initiaux effectués par \pkg{piton} dans |piton.sty| sont inspirés par le
style \pkg{manni} de Pygments tel qu'il est appliqué au langage Python par
Pygments.\footnote{Voir \url{https://pygments.org/styles/}. À remarquer que, par défaut,
  Pygments propose pour le style \pkg{manni} un fond coloré dont la couleur est la couleur
  HTML |#F0F3F3|. Il est possible d'avoir la même couleur dans |{Piton}| avec
  l'instruction : |\PitonOptions{background-color = [HTML]{F0F3F3}}|}

\vspace{1cm}


\begin{center}
\begin{tabularx}{\textwidth}{@{}>{\ttfamily}l>{\raggedright\arraybackslash}X@{}}
\toprule
\normalfont Style  & Usage \\
\midrule
Number & les nombres \\
String.Short & les chaînes de caractères courtes (entre \texttt{'} ou \texttt{"}) \\
String.Long & les chaînes de caractères longues (entre \texttt{'''} ou \texttt{"""})
              sauf les chaînes de documentation (qui sont gérées par |String.Doc|)\\
String & cette clé fixe à la fois |String.Short| et |String.Long| \\
String.Doc & les chaînes de documentation (seulement entre |"""| suivant PEP~257) \\
String.Interpol & les éléments syntaxiques des champs des f-strings (c'est-à-dire les
                  caractères \texttt{\{} et \texttt{\}}) ; ce style hérite des styles
                  |String.Short| et |String.Long| (suivant la chaîne où apparaît
                  l'interpolation)\\ 
Interpol.Inside & le contenu des interpolations dans les f-strings (c'est-à-dire les
                  éléments qui se trouvent entre \texttt{\{} et~\texttt{\}}) ; si
                  l'utilisateur n'a pas fixé ce style, ces éléments sont analysés et
                  formatés par \pkg{piton} au même titre que le reste du code. \\ 
Operator & les opérateurs suivants : \texttt{!= == << >> - \~{} + / * \% = < > \& .}
           \verb+|+ |@| \\  % |
Operator.Word & les opérateurs suivants : |in|, |is|, |and|, |or| et |not| \\
Name.Builtin & la plupart des fonctions prédéfinies par Python \\
Name.Decorator & les décorateurs (instructions débutant par \verb|@|) \\
Name.Namespace & le nom des modules (= bibliothèques extérieures) \\
Name.Class & le nom des classes au moment de leur définition, c'est-à-dire après le
             mot-clé \verb|class| \\ 
Name.Function & le nom des fonctions définies par l'utilisateur \emph{au moment de leur
                définition} (après le mot-clé |def|) \\
UserFunction & le nom des fonctions précédemment définies par l'utilisateur (la valeur
               initiale de ce paramètre est {\ttfamily \textbackslash
               PitonStyle\{Identifier\}}, ce qui fait que ces noms de fonctions sont 
               affichés comme les identifiants) \\ 
Exception & les exceptions prédéfinies (ex.: \texttt{SyntaxError}) \\
InitialValues & les valeurs initiales (et le symbole |=| qui précède) des arguments
                optionnels dans les définitions de fonctions ; si l'utilisateur n'a pas
                fixé ce style, ces éléments sont analysés et formatés par \pkg{piton} 
                au même titre que le reste du code.\\
Comment & les commentaires commençant par \texttt{\#} \\
Comment.LaTeX & les commentaires commençant par \texttt{\#>} qui sont composés par
                \pkg{piton} comme du code LaTeX (et appelés simplement «commentaires
                LaTeX» dans ce document) \\ 
Keyword.Constant & |True|, |False| et |None| \\
Keyword & les mots-clés suivants :
          \ttfamily assert, break, case, continue, del,
          elif, else, except, exec, finally, for, from, 
          global, if, import, in, lambda, non local,
          pass, raise, return, try, while,
          with, yield et yield from.\\
Identifier & les identificateurs. \\
\bottomrule
\end{tabularx}
\end{center}


\newpage

\subsection{Le langage OCaml}

On peut basculer vers le langage |OCaml| avec la clé |language| : |language = OCaml|


\bigskip


\begin{center}
\begin{tabularx}{0.9\textwidth}{@{}>{\ttfamily}l>{\raggedright\arraybackslash}X@{}}
  \toprule
  \normalfont Style  & Usage \\
  \midrule
  Number & les nombres \\
  String.Short & les caractères (entre \texttt{'}) \\
  String.Long & les chaînes de caractères, entre |"| mais aussi les \emph{quoted-strings} \\
  String & cette clé fixe à la fois |String.Short| et |String.Long| \\
  Operator & les opérateurs, en particulier |+|, |-|, |/|, |*|, |@|, |!=|, |==|, |&&| \\
  Operator.Word & les opérateurs suivants : |asr|, |land|, |lor|, |lsl|, |lxor|,
                  |mod| et |or| \\ 
  Name.Builtin & les fonctions |not|, |incr|, |decr|, |fst| et |snd| \\
  Name.Type & le nom des types OCaml \\
  Name.Field & le nom d'un champ de module \\
  Name.Constructor & le nom des constructeurs de types (qui débutent par une majuscule) \\
  Name.Module & le nom des modules \\
  Name.Function & le nom des fonctions définies par l'utilisateur \emph{au moment de leur
                  définition} (après le mot-clé |let|) \\  
  UserFunction & le nom des fonctions précédemment définies par l'utilisateur (la valeur
                 initiale de ce paramètre est {\ttfamily \textbackslash
                 PitonStyle\{Identifier\}}, ce qui fait que ces noms de fonctions sont
                 affichés comme les identifiants) \\ 
  Exception & les exceptions prédéfinies (ex. : |End_of_File|) \\
  TypeParameter & les paramétreurs de type \\
  Comment & les commentaires, entre |(*| et |*)| ; ces commentaires peuvent être imbriqués \\
  Keyword.Constant & |true| et |false| \\
  Keyword & les mots-clés suivants :
         |assert|, |as|, |done|, |downto|, |do|, |else|, |exception|, |for|, |function| ,
            |fun|, |if|, |lazy|, |match|, |mutable|, |new|, |of|, |private|, |raise|,
            |then|, |to|, |try| , |virtual|, |when|, |while| et |with| \\ 
  Keyword.Governing & les mot-clés suivants : |and|, |begin|, |class|, |constraint|,
                      |end|, |external|, |functor|, |include|, |inherit|, |initializer|,
                      |in|, |let|, |method|, |module|, |object|, |open|, |rec|, |sig|,
                      |struct|, |type| et |val|. \\
  Identifier & les identificateurs \\
  Delim      & les délimiteurs |(|, |[|, \verb+[|+, |)|, |]| et \verb+|]+ \\
  Punct      & les symboles de ponctuation |,| |:|, |;| et |!|. \\
  \bottomrule
\end{tabularx}
\end{center}

\vspace{1cm}

Voici un exemple :

\medskip
\begin{Piton}[language = OCaml]
let rec quick_sort lst =    (* Tri par segmentation *)
  match lst with
  | [] -> []
  | pivot :: rest ->
      let left  = List.filter (fun x -> x < pivot) rest in
      let right = List.filter (fun x -> x >= pivot) rest in
      quick_sort left @ [pivot] @ quick_sort right
\end{Piton}

\newpage

\subsection[Le langage C (et C++)]{Le langage C (et \CC)}


On peut basculer vers le langage |C| avec la clé |language| : |language = C|


\bigskip

\begin{center}
\begin{tabularx}{0.9\textwidth}{@{}>{\ttfamily}l>{\raggedright\arraybackslash}X@{}}
\toprule
\normalfont Style  & Usage \\
\midrule
Number & les nombres \\
String.Short & les caractères (entre \texttt{'}) \\  
String.Long & les chaînes de caractères (entre \texttt{"}) \\
String.Interpol & les éléments \texttt{\%d}, \texttt{\%i}, \texttt{\%f}, \texttt{\%c},
                  etc. dans les chaînes de caractères ; ce style hérite du style
                  |String.Long| \\ 
Operator & les opérateurs suivants : \texttt{!= == << >> - \~{} + / * \% = < > \& .} \verb+|+ |@| \\ % |
Name.Type & les types prédéfinis suivants : |bool|, |char|, |char16_t|, |char32_t|,
            |double|, |float|, |int|, |int8_t|, |int16_t|, |int32_t|, |int64_t|, |long|,
            |short|, |signed|, |unsigned|, |void| et |wchar_t| \\  
Name.Builtin & les fonctions prédéfinies suivantes : |printf|, |scanf|, |malloc|, |sizeof|
               et  |alignof|  \\ 
Name.Class & le nom des classes au moment de leur définition, c'est-à-dire après le
               mot-clé |class| \\ 
Name.Function & le nom des fonctions définies par l'utilisateur \emph{au moment de leur
                définition} \\
UserFunction & le nom des fonctions précédemment définies par l'utilisateur (la valeur
               initiale de ce paramètre est {\ttfamily \textbackslash
               PitonStyle\{Identifier\}}, ce qui fait que ces noms de fonctions sont
               affichés comme les identifiants) \\ 
Preproc & les instructions du préprocesseur (commençant par |#|) \\
Comment & les commentaires (commençant par \texttt{//} ou entre |/*| et |*/|) \\
Comment.LaTeX & les commentaires commençant par \texttt{//>} qui sont composés par
                \pkg{piton} comme du code LaTeX (et appelés simplement «commentaires
                LaTeX» dans ce document) \\ 
Keyword.Constant & |default|, |false|, |NULL|, |nullptr| et |true| \\
Keyword & les mots-clés suivants : |alignas|, |asm|, |auto|, |break|, |case|, |catch|,
          |class|, |constexpr|, |const|, |continue|, |decltype|, |do|, |else|, |enum|,
          |extern|, |for|, |goto|, |if|, |nexcept|, |private|, |public|, |register|,
          |restricted|, |try|, |return|, |static|, |static_assert|, |struct|, |switch|,
          |thread_local|, |throw|, |typedef|, |union|, |using|, |virtual|, |volatile| et
          |while| 
\\
Identifier & les identificateurs. \\
\bottomrule
\end{tabularx}
\end{center}


\newpage

\subsection{Le langage SQL}

On peut basculer vers le langage |SQL| avec la clé |language| : |language = SQL|


\bigskip

\begin{center}
\begin{tabularx}{0.9\textwidth}{@{}>{\ttfamily}l>{\raggedright\arraybackslash}X@{}}
\toprule
\normalfont Style  & Usage \\
\midrule
Number & les nombres \\
String.Long & les chaînes de caractères (entre \texttt{'} et non entre \texttt{"} car les éléments entre \texttt{"}
              sont des noms de champs et formatés avec |Name.Field|) \\
Operator & les opérateurs suivants : \texttt{= != <> >= > < <= * + / } \\
Name.Table & les noms des tables \\
Name.Field & les noms des champs des tables \\
Name.Builtin & les fonctions prédéfinies suivantes (leur nom n'est \emph{pas} sensible à
               la casse) : |avg|, |count|, |char_lenght|, |concat|, |curdate|,
               |current_date|, |date_format|, |day|, |lower|, |ltrim|, |max|, |min|,
               |month|, |now|, |rank|, |round|, |rtrim|, |substring|, |sum|, |upper| et
               |year|. \\ 
Comment & les commentaires (débutant par |--| ou bien entre |/*| et |*/|) \\
Comment.LaTeX & les commentaires commençant par \texttt{-->} qui sont composés par
                \pkg{piton} comme du code LaTeX (et appelés simplement «commentaires
                LaTeX» dans ce document) \\ 
Keyword & les mots-clés suivants (leur nom n'est \emph{pas} sensible à la casse) :
     |abort|, |action|, |add|, |after|, |all|, |alter|, |always|, |analyze|,
     |and|, |as|, |asc|, |attach|, |autoincrement|, |before|, |begin|, |between|,
     |by|, |cascade|, |case|, |cast|, |check|, |collate|, |column|, |commit|,
     |conflict|, |constraint|, |create|, |cross|, |current|, |current_date|,
     |current_time|, |current_timestamp|, |database|, |default|, |deferrable|,
     |deferred|, |delete|, |desc|, |detach|, |distinct|, |do|, |drop|, |each|,
     |else|, |end|, |escape|, |except|, |exclude|, |exclusive|, |exists|,
     |explain|, |fail|, |filter|, |first|, |following|, |for|, |foreign|, |from|,
     |full|, |generated|, |glob|, |group|, |groups|, |having|, |if|, |ignore|,
     |immediate|, |in|, |index|, |indexed|, |initially|, |inner|, |insert|,
     |instead|, |intersect|, |into|, |is|, |isnull|, |join|, |key|, |last|,
     |left|, |like|, |limit|, |match|, |materialized|, |natural|, |no|, |not|,
     |nothing|, |notnull|, |null|, |nulls|, |of|, |offset|, |on|, |or|, |order|,
     |others|, |outer|, |over|, |partition|, |plan|, |pragma|, |preceding|,
     |primary|, |query|, |raise|, |range|, |recursive|, |references|, |regexp|,
     |reindex|, |release|, |rename|, |replace|, |restrict|, |returning|, |right|,
     |rollback|, |row|, |rows|, |savepoint|, |select|, |set|, |table|, |temp|,
     |temporary|, |then|, |ties|, |to|, |transaction|, |trigger|, |unbounded|,
     |union|, |unique|, |update|, |using|, |vacuum|, |values|, |view|, |virtual|,
     |when|, |where|, |window|, |with|, |without| \\
\bottomrule
\end{tabularx}
\end{center}

\bigskip
Si on souhaite que les mots-clés soient capitalisés automatiquement, on peut modifier le
style |Keywords| localement pour le langage SQL avec l'instruction :
\begin{Verbatim}
\SetPitonStyle~emphase#[SQL]@{Keywords = \bfseries \MakeUppercase}
\end{Verbatim}

\newpage

\subsection{Les langages définis par la commande \texttt{\textbackslash NewPitonLanguage}}

\indexcommand{NewPitonLanguage}

\vspace{1cm}
La commande |\NewPitonLanguage|, qui permet de définir de nouveaux langages en utilisant
la syntaxe de l'extension \pkg{listings}, a été présentée p.~\pageref{NewPitonLanguage}.

Tous les langages définis avec la commande |\NewPitonLanguage| partagent les mêmes styles.

\vspace{1cm}

\begin{center}
\begin{tabularx}{0.9\textwidth}{@{}>{\ttfamily}l>{\raggedright\arraybackslash}X@{}}
\toprule
\normalfont Style  & Usage \\
\midrule
Number & les nombres \\
String.Long & les chaînes de caractères définies dans |\NewPitonLanguage| par la clé
              |morestring| \\  
Comment & les commentaires définis dans |\NewPitonLanguage| par la clé |morecomment|  \\
Comment.LaTeX & les commentaires qui sont composés par \pkg{piton} comme du code LaTeX (et
                appelés simplement «commentaires LaTeX» dans ce document) \\
Keyword & les mots-clés, définis dans |\NewPitonLanguage| par les clés |morekeywords| et
          |moretexcs| (et également la clé |sensitive| qui indique si les mots-clés sont
          sensibles à la casse) \\  
Directive & les directives définies dans |\NewPitonLanguage| par la clé |moredirectives| \\
Tag & les «tags» définis par la clé |tag| (les lexèmes détectés à l'intérieur d'un tag
      seront aussi composés avec leur propre style) \\
Identifier & les identificateurs. \\
\bottomrule
\end{tabularx}
\end{center}


\vspace{1cm}
Voici une possibilité de définition d'un language HTML, obtenu par une légère adaptation
de la définition faite par \pkg{listings} (fichier |lstlang1.sty|).

\medskip
\begin{small}
\begin{Verbatim}
\NewPitonLanguage{HTML}%
  {morekeywords={A,ABBR,ACRONYM,ADDRESS,APPLET,AREA,B,BASE,BASEFONT,%
      BDO,BIG,BLOCKQUOTE,BODY,BR,BUTTON,CAPTION,CENTER,CITE,CODE,COL,%
      COLGROUP,DD,DEL,DFN,DIR,DIV,DL,DOCTYPE,DT,EM,FIELDSET,FONT,FORM,%
      FRAME,FRAMESET,HEAD,HR,H1,H2,H3,H4,H5,H6,HTML,I,IFRAME,IMG,INPUT,%
      INS,ISINDEX,KBD,LABEL,LEGEND,LH,LI,LINK,LISTING,MAP,META,MENU,%
      NOFRAMES,NOSCRIPT,OBJECT,OPTGROUP,OPTION,P,PARAM,PLAINTEXT,PRE,%
      OL,Q,S,SAMP,SCRIPT,SELECT,SMALL,SPAN,STRIKE,STRING,STRONG,STYLE,%
      SUB,SUP,TABLE,TBODY,TD,TEXTAREA,TFOOT,TH,THEAD,TITLE,TR,TT,U,UL,%
      VAR,XMP,%
      accesskey,action,align,alink,alt,archive,axis,background,bgcolor,%
      border,cellpadding,cellspacing,charset,checked,cite,class,classid,%
      code,codebase,codetype,color,cols,colspan,content,coords,data,%
      datetime,defer,disabled,dir,event,error,for,frameborder,headers,%
      height,href,hreflang,hspace,http-equiv,id,ismap,label,lang,link,%
      longdesc,marginwidth,marginheight,maxlength,media,method,multiple,%
      name,nohref,noresize,noshade,nowrap,onblur,onchange,onclick,%
      ondblclick,onfocus,onkeydown,onkeypress,onkeyup,onload,onmousedown,%
      profile,readonly,onmousemove,onmouseout,onmouseover,onmouseup,%
      onselect,onunload,rel,rev,rows,rowspan,scheme,scope,scrolling,%
      selected,shape,size,src,standby,style,tabindex,text,title,type,%
      units,usemap,valign,value,valuetype,vlink,vspace,width,xmlns},%
   tag=<>,%
   alsoletter = - ,%
   sensitive=f,%
   morestring=[d]",
  }
\end{Verbatim}
\end{small}

\newpage

\subsection{Le langage «minimal»}


\label{minimal}
\index{minimal (langage «minimal»)}

On peut basculer vers le langage «|minimal|» avec la clé |language| : |language = minimal|


\bigskip

\begin{center}
\begin{tabularx}{0.9\textwidth}{@{}>{\ttfamily}l>{\raggedright\arraybackslash}X@{}}
\toprule
\normalfont Style  & Usage \\
\midrule
Number & les nombres \\
String & les chaînes de caractères (qui sont entre \texttt{"}) \\
Comment & les commentaires (qui débutent par |#|) \\
Comment.LaTeX & les commentaires commençant par \texttt{\#>} qui sont composés par
                \pkg{piton} comme du code LaTeX (et appelés simplement «commentaires
                LaTeX» dans ce document) \\ 
Identifier & les identificateurs. \\
\bottomrule
\end{tabularx}
\end{center}

\bigskip
Ce langage «|minimal|» est proposé par \pkg{piton} à l'utilisateur final pour qu'il puisse
y ajouter des formatages de mots-clés avec la commande |\SetPitonIdentifier| (cf.
\ref{SetPitonIdentifier}, p.~\pageref{SetPitonIdentifier}) et créer par exemple un langage
pour pseudo-code.

\vspace{2cm}

\subsection{Le langage «verbatim»}


\label{verbatim}
\index{verbatim (langage «verbatim»)}

On peut basculer vers le langage «|verbatim|» avec la clé |language| : |language = verbatim|

\bigskip

\begin{center}
\begin{tabularx}{0.9\textwidth}{@{}>{\ttfamily}l>{\raggedright\arraybackslash}X@{}}
\toprule
\normalfont Style  & Usage \\
\midrule
\emph{rien...} & \\
\bottomrule
\end{tabularx}
\end{center}

\bigskip
Le langage «|verbatim|» ne propose aucun style et ne fait donc aucun formatage
syntaxique. On peut néanmoins y utiliser le mécanisme |detected-commands| (cf. partie
\ref{detected-commands}, p.~\pageref{detected-commands}) ainsi que le
mécanisme de détection des commandes et des environnements de Beamer.





\newpage

\phantomsection
\addcontentsline{toc}{section}{Index}

\printindex


\section*{Remerciements}

Remerciements à Yann Salmon et Pierre Le Scornet pour leurs nombreuses suggestions pertinentes.

\section*{Autre documentation}

Le document |piton.pdf| (fourni avec l'extension \pkg{piton}) contient
une traduction anglaise de la documentation ici présente ainsi qu'un historique des versions.
Le fichier |piton-code.pdf| contient le code commenté de l'extension \pkg{piton}.


\medskip
Les versions successives du fichier |piton.sty| fournies par
TeX Live sont disponibles sur le serveur \textsc{svn} de TeX Live :

\smallskip
{
\small
\nolinkurl{https://tug.org/svn/texlive/trunk/Master/texmf-dist/tex/lualatex/piton/piton.sty}
}

\medskip
Le développement de l'extension \pkg{piton} se fait sur le dépôt GitHub suivant :

\smallskip
\verb|https://github.com/fpantigny/piton|


\tableofcontents

\end{document}

% Local Variables:
% fill-column: 80
% End:
