Index: /trunk/perl/Makefile
===================================================================
--- /trunk/perl/Makefile	(revision 182)
+++ /trunk/perl/Makefile	(revision 183)
@@ -10,10 +10,10 @@
 perl_INCLUDES = \
 	perlcommon.tex \
-	introduction.tex \
-    variables.tex \
-	syntaxe.tex \
-	variablesbis.tex \
-	chaines.tex \
-	conclusion.tex \
+    perl.introduction.tex \
+    perl.variables.tex \
+    perl.syntaxe.tex \
+    perl.variablesbis.tex \
+    perl.chaines.tex \
+    perl.conclusion.tex \
 
 perl_EXAMPLES = \
Index: unk/perl/chaines.tex
===================================================================
--- /trunk/perl/chaines.tex	(revision 182)
+++ 	(revision )
@@ -1,198 +1,0 @@
-% $Id$
-\section{Chaines de caractères}
-
-\subsection{quote}
-
-\begin{frame}[fragile]
-\frametitle{Opérateur et délimiteurs}
-\begin{block}{}
-\begin{tabular}{|l|l|l|}
-\hline
-\textbf{faire}&\textbf{interpollée}&\textbf{non interpolée}\\
-\hline
-\hline
-une chaine&\verb+""+&\verb+''+\\
-\hline
-\hline
-une chaine&\verb+q//+&\verb+qq//+\\
-\hline
-une liste&&qw//\\
-\hline
-\end{tabular}
-\end{block}
-\vfill
-\pause
-
-\begin{block}{Délimiteurs des opérateurs:}
-\begin{itemize}
-\item n'importe quels caractères
-\item les couples logiques \verb+()+, \verb+[]+, \verb+{}+
-\end{itemize}
-\end{block}
-\vfill
-\pause
-\begin{exampleblock}{}
-Exemple: \verb+q//+, \verb+q;;+, \verb+q[]+, \verb+q{}+
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{quote: exemple}
-
-\begin{exampleblock}{Chaine interpolées:}
-\begin{verbatim}
-my $var = "UMR7620";
-
-print "nous somme \"$var\"";
-print qq!nous somme "$var"!;
-\end{verbatim}
-\end{exampleblock}
-\pause
-\vfill
-\begin{exampleblock}{Chaine non interpolées:}
-\begin{verbatim}
-my $var = 'UMR7620';
-
-print '$var est une variable';
-print q{'$var' est une variable};
-\end{verbatim}
-\end{exampleblock}
-\pause
-\vfill
-\begin{exampleblock}{une liste}
-\begin{verbatim}
-my @tableau = qw(une liste de mots);
-\end{verbatim}
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{quote quote}
-\vfill
-\begin{exampleblock}{Pour les longues chaines:}
-\begin{verbatim}
-my $var = 42;
-
-print <<FIN_DU_TEXTE;
-La réponse à la question
-universelle est $var.
-FIN_DU_TEXTE
-\end{verbatim}
-\end{exampleblock}
-\end{frame}
-
-\subsection{RegExp}
-
-\begin{frame}
-\frametitle{Perl réinvente les RegExp}
-\begin{block}{Comment ne pas parler des Expéssions Régulières ?}
-Elles sont
-\begin{itemize}
-\item puissantes
-\item très étendues
-\item naturelles en perl
-\end{itemize}
-\end{block}
-
-\vfill
-\begin{block}{Perl Compatible Regular Expression}
-Il y a même une librairie qui émule les expression régulière de PERL.
-
-Utilisé par
-\begin{itemize}
-\item grep (et oui)
-\item php
-\item kde
-\item \ldots
-\end{itemize}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{RegExp: les bases}
-\textbf{Regarde si une chaine correspond à un motif}
-
-\begin{block}{le motif peut contenir:}
-\vfill
-
-\begin{tabular}{cl}
-\verb+.+&1 caractère\\
-\pause
-&\\
-\verb+*+&0 ou plusieurs fois\\
-\verb-+-&1 ou plusieurs fois\\
-\verb+?+&1 fois\\
-\pause
-&\\
-\verb+\+&echape un caractère magique\\
-\pause
-&\\
-\verb+^+&début de ligne\\
-\verb+$+&fin de ligne\\
-\pause
-&\\
-\verb+()+&forme un groupe\\
-\end{tabular}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Anatomie}
-\begin{exampleblock}{L'expression régulière:}
-\small
-\begin{semiverbatim}
-  $var \onslide<2->{=~}  \onslide<3->{m}\onslide<4->{/}\onslide<5->{motif}\onslide<4->{/}\onslide<6->{i};
-  $var \onslide<2->{=~}   \onslide<4->{/}\onslide<5->{motif}\onslide<4->{/}\onslide<6->{i}; \onslide<3->{# séparateur / => opérateur m}
-  $var \onslide<2->{=~}  \onslide<3->{s}\onslide<4->{/}\onslide<5->{motif}\onslide<4->{/}\onslide<5->{remplacement}\onslide<4->{/}\onslide<6->{g};
-\end{semiverbatim}
-\end{exampleblock}
-
-\vfill
-\pause
-\begin{block}{}
-\begin{itemize}
-\small
-\item un opérateur de comparaison
-    \begin{itemize}
-    \item \verb+=~+ : correspond
-    \item \verb+!~+ : ne correspond pas
-    \end{itemize}
-\pause
-\item une action
-    \begin{itemize}
-    \item \textbf{m} (match, le défaut)
-    \item \textbf{s} (substitute)
-    \end{itemize}
-\pause
-\item des séparateurs (au choix)
-\pause
-\item le texte recherché (et le remplacement)
-\pause
-\item éventuellement un modificateur
-\end{itemize}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{RegExp: exemple dans perl}
-\begin{exampleblock}{}
-\begin{verbatim}
-my @list = ('UMR7620', 'umr8639');
-
-foreach my $umr (@list) {
-    my ($number) = $umr =~ /^umr(.*)$/;
-    if ($number)  {
-        print "Unité mixte $number\n";
-    }
-}
-\end{verbatim}
-\end{exampleblock}
-\pause
-\vfill
-\begin{block}{la doc !}
-\begin{itemize}
-\item \verb+man perlre+
-\item \verb+man perlretut+
-\end{itemize}
-\end{block}
-\end{frame}
Index: unk/perl/conclusion.tex
===================================================================
--- /trunk/perl/conclusion.tex	(revision 182)
+++ 	(revision )
@@ -1,59 +1,0 @@
-% $Id$
-
-\section{Fin}
-
-\begin{frame}[fragile]
-\frametitle{La doc !}
-\begin{itemize}
-\item \verb+perldoc+
-\item \verb+man+
-\end{itemize}
-\pause
-\vfill
-\begin{block}{Les références}
-\begin{tabular}{ll}
-perlfunc&functions de base\\
-\pause
-perlop&les opérateurs\\
-\pause
-perlvar&les variables de perl\\
-\pause
-perldata&utilisation des variables\\
-\pause
-perlref&les références\\
-perlreftut&\\
-\pause
-perlopentut&tout sur open\\
-\pause
-\end{tabular}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{La communauté}
-\begin{block}{Perl}
-\href{http://www.perl.org/}{http://www.perl.org/}\\
-\href{http://cpan.perl.org/}{http://cpan.perl.org/}
-\end{block}
-\vfill
-\pause
-\begin{block}{les Mongueurs}
-\begin{columns}
-\column{20mm}
-\includegraphics[height=20mm]{mongueurs}
-\column{100mm}
-Association loi 1901\\
-\href{http://www.mongueurs.net/}{http://www.mongueurs.net/}\\
-\href{http://paris.mongueurs.net/}{http://paris.mongueurs.net/} (Paris)
-\end{columns}
-Vous les retrouverez dans "Linux Magazine" et aux
-\href{http://conferences.mongueurs.net}{Journées Perl}
-\end{block}
-\end{frame}
-
-\begin{frame}{Questions ?}
-\center{
-\hfill
-}
-\end{frame}
-
Index: unk/perl/introduction.tex
===================================================================
--- /trunk/perl/introduction.tex	(revision 182)
+++ 	(revision )
@@ -1,129 +1,0 @@
-% $Id$
-
-\section{Presentation}
-
-\begin{frame}
-\frametitle{PERL}
-\begin{block}{}
-Perl, écrit par Larry Wall en 1987.
-\pause
-
-Perl 5.10 maintenu par Rafael Garcia-Suarez
-\pause
-
-Dernière version: 5.10.0
-\end{block}
-\pause
-\vfill
-\begin{block}{PERL ne signifie rien}
-\emph{Practical Extraction and Report Language}
-(\emph{langage pratique d'extraction et de génération de rapports})
-
-\textbf{ou}
-
-\emph{Pathetically Eclectic Rubbish Lister}
-(\emph{collectionneur de déchets pathétiquement éclectiques})
-\end{block}
-\pause
-\vfill
-
-\begin{alertblock}{Perl 5 !}
-Perl 6 sera très différent
-\end{alertblock}
-\end{frame}
-
-\begin{frame}
-\frametitle{Pourquoi PERL ?}
-\begin{itemize}
-\item langage scripté, non compilé
-\pause
-\item gestion de la mémoire dynamique et automatique
-\pause
-\item portable (existe sous Unix*, Windows, OS/2, VMS\ldots)
-\pause
-\item est orienté objet
-\pause
-\item possède un grand nombre de modules additionnels
-\pause
-\item est très documenté
-\pause
-\item la communauté perl est conviviale
-\end{itemize}
-\pause
-\vfill
-Utilisation:
-\begin{itemize}
-\item petits scripts type shell
-\pause
-\item des programmes complexes
-\pause
-\item des services de toutes sortes
-\pause
-\item des sites web
-\item \ldots
-\end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Exemples}
-\begin{exampleblock}{Exemple de script:}
-\begin{verbatim}
-#!env perl
-
-print "Hello World\n";
-\end{verbatim}
-\end{exampleblock}
-\pause
-\vfill
-\begin{exampleblock}{One-liner}
-\verb+perl -e 'print "Hello World\n"'+
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Obfusacte perl}
-Sinon ça peut aussi ressembler à ça:
-\vfill
-\begin{exampleblock}{bestever.pl de Philippe Bruhat (Book)}
-\begin{tiny}
-\verbatiminput{bestever.pl}
-\end{tiny}
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}
-\frametitle{Avant-propos}
-\begin{alertblock}{Ce dont je ne vais pas parler\ldots}
-\begin{itemize}
-\pause
-\item Plain Old Documentation - documenter son code
-\pause
-\item Espaces de noms
-\pause
-\item Ecriture de modules
-\pause
-\item Objets
-\pause
-\item XS: pont du C <=> perl
-\pause
-\item de la tonne de modules super géniale qui fait choses épatantes
-\pause
-\item obfuscate perl
-\pause
-\item des trucs super gores qu'on peut faire en perl, bien pire que l'obfuscate
-\end{itemize}
-\end{alertblock}
-\vfill
-\begin{block}{}
-Je sais, vous êtes déçus !
-\end{block}
-\end{frame}
-
-\begin{frame}
-\begin{block}{}
-\begin{Huge}There's More Than One Way To Do It!\end{Huge}
-
-\vfill
-Larry Wall
-\end{block}
-\end{frame}
Index: /trunk/perl/perl.chaines.tex
===================================================================
--- /trunk/perl/perl.chaines.tex	(revision 183)
+++ /trunk/perl/perl.chaines.tex	(revision 183)
@@ -0,0 +1,198 @@
+% $Id$
+\section{Chaines de caractères}
+
+\subsection{quote}
+
+\begin{frame}[fragile]
+\frametitle{Opérateur et délimiteurs}
+\begin{block}{}
+\begin{tabular}{|l|l|l|}
+\hline
+\textbf{faire}&\textbf{interpollée}&\textbf{non interpolée}\\
+\hline
+\hline
+une chaine&\verb+""+&\verb+''+\\
+\hline
+\hline
+une chaine&\verb+q//+&\verb+qq//+\\
+\hline
+une liste&&qw//\\
+\hline
+\end{tabular}
+\end{block}
+\vfill
+\pause
+
+\begin{block}{Délimiteurs des opérateurs:}
+\begin{itemize}
+\item n'importe quels caractères
+\item les couples logiques \verb+()+, \verb+[]+, \verb+{}+
+\end{itemize}
+\end{block}
+\vfill
+\pause
+\begin{exampleblock}{}
+Exemple: \verb+q//+, \verb+q;;+, \verb+q[]+, \verb+q{}+
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{quote: exemple}
+
+\begin{exampleblock}{Chaine interpolées:}
+\begin{verbatim}
+my $var = "UMR7620";
+
+print "nous somme \"$var\"";
+print qq!nous somme "$var"!;
+\end{verbatim}
+\end{exampleblock}
+\pause
+\vfill
+\begin{exampleblock}{Chaine non interpolées:}
+\begin{verbatim}
+my $var = 'UMR7620';
+
+print '$var est une variable';
+print q{'$var' est une variable};
+\end{verbatim}
+\end{exampleblock}
+\pause
+\vfill
+\begin{exampleblock}{une liste}
+\begin{verbatim}
+my @tableau = qw(une liste de mots);
+\end{verbatim}
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{quote quote}
+\vfill
+\begin{exampleblock}{Pour les longues chaines:}
+\begin{verbatim}
+my $var = 42;
+
+print <<FIN_DU_TEXTE;
+La réponse à la question
+universelle est $var.
+FIN_DU_TEXTE
+\end{verbatim}
+\end{exampleblock}
+\end{frame}
+
+\subsection{RegExp}
+
+\begin{frame}
+\frametitle{Perl réinvente les RegExp}
+\begin{block}{Comment ne pas parler des Expéssions Régulières ?}
+Elles sont
+\begin{itemize}
+\item puissantes
+\item très étendues
+\item naturelles en perl
+\end{itemize}
+\end{block}
+
+\vfill
+\begin{block}{Perl Compatible Regular Expression}
+Il y a même une librairie qui émule les expression régulière de PERL.
+
+Utilisé par
+\begin{itemize}
+\item grep (et oui)
+\item php
+\item kde
+\item \ldots
+\end{itemize}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{RegExp: les bases}
+\textbf{Regarde si une chaine correspond à un motif}
+
+\begin{block}{le motif peut contenir:}
+\vfill
+
+\begin{tabular}{cl}
+\verb+.+&1 caractère\\
+\pause
+&\\
+\verb+*+&0 ou plusieurs fois\\
+\verb-+-&1 ou plusieurs fois\\
+\verb+?+&1 fois\\
+\pause
+&\\
+\verb+\+&echape un caractère magique\\
+\pause
+&\\
+\verb+^+&début de ligne\\
+\verb+$+&fin de ligne\\
+\pause
+&\\
+\verb+()+&forme un groupe\\
+\end{tabular}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Anatomie}
+\begin{exampleblock}{L'expression régulière:}
+\small
+\begin{semiverbatim}
+  $var \onslide<2->{=~}  \onslide<3->{m}\onslide<4->{/}\onslide<5->{motif}\onslide<4->{/}\onslide<6->{i};
+  $var \onslide<2->{=~}   \onslide<4->{/}\onslide<5->{motif}\onslide<4->{/}\onslide<6->{i}; \onslide<3->{# séparateur / => opérateur m}
+  $var \onslide<2->{=~}  \onslide<3->{s}\onslide<4->{/}\onslide<5->{motif}\onslide<4->{/}\onslide<5->{remplacement}\onslide<4->{/}\onslide<6->{g};
+\end{semiverbatim}
+\end{exampleblock}
+
+\vfill
+\pause
+\begin{block}{}
+\begin{itemize}
+\small
+\item un opérateur de comparaison
+    \begin{itemize}
+    \item \verb+=~+ : correspond
+    \item \verb+!~+ : ne correspond pas
+    \end{itemize}
+\pause
+\item une action
+    \begin{itemize}
+    \item \textbf{m} (match, le défaut)
+    \item \textbf{s} (substitute)
+    \end{itemize}
+\pause
+\item des séparateurs (au choix)
+\pause
+\item le texte recherché (et le remplacement)
+\pause
+\item éventuellement un modificateur
+\end{itemize}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{RegExp: exemple dans perl}
+\begin{exampleblock}{}
+\begin{verbatim}
+my @list = ('UMR7620', 'umr8639');
+
+foreach my $umr (@list) {
+    my ($number) = $umr =~ /^umr(.*)$/;
+    if ($number)  {
+        print "Unité mixte $number\n";
+    }
+}
+\end{verbatim}
+\end{exampleblock}
+\pause
+\vfill
+\begin{block}{la doc !}
+\begin{itemize}
+\item \verb+man perlre+
+\item \verb+man perlretut+
+\end{itemize}
+\end{block}
+\end{frame}
Index: /trunk/perl/perl.conclusion.tex
===================================================================
--- /trunk/perl/perl.conclusion.tex	(revision 183)
+++ /trunk/perl/perl.conclusion.tex	(revision 183)
@@ -0,0 +1,59 @@
+% $Id$
+
+\section{Fin}
+
+\begin{frame}[fragile]
+\frametitle{La doc !}
+\begin{itemize}
+\item \verb+perldoc+
+\item \verb+man+
+\end{itemize}
+\pause
+\vfill
+\begin{block}{Les références}
+\begin{tabular}{ll}
+perlfunc&functions de base\\
+\pause
+perlop&les opérateurs\\
+\pause
+perlvar&les variables de perl\\
+\pause
+perldata&utilisation des variables\\
+\pause
+perlref&les références\\
+perlreftut&\\
+\pause
+perlopentut&tout sur open\\
+\pause
+\end{tabular}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{La communauté}
+\begin{block}{Perl}
+\href{http://www.perl.org/}{http://www.perl.org/}\\
+\href{http://cpan.perl.org/}{http://cpan.perl.org/}
+\end{block}
+\vfill
+\pause
+\begin{block}{les Mongueurs}
+\begin{columns}
+\column{20mm}
+\includegraphics[height=20mm]{mongueurs}
+\column{100mm}
+Association loi 1901\\
+\href{http://www.mongueurs.net/}{http://www.mongueurs.net/}\\
+\href{http://paris.mongueurs.net/}{http://paris.mongueurs.net/} (Paris)
+\end{columns}
+Vous les retrouverez dans "Linux Magazine" et aux
+\href{http://conferences.mongueurs.net}{Journées Perl}
+\end{block}
+\end{frame}
+
+\begin{frame}{Questions ?}
+\center{
+\hfill
+}
+\end{frame}
+
Index: /trunk/perl/perl.introduction.tex
===================================================================
--- /trunk/perl/perl.introduction.tex	(revision 183)
+++ /trunk/perl/perl.introduction.tex	(revision 183)
@@ -0,0 +1,129 @@
+% $Id$
+
+\section{Presentation}
+
+\begin{frame}
+\frametitle{PERL}
+\begin{block}{}
+Perl, écrit par Larry Wall en 1987.
+\pause
+
+Perl 5.10 maintenu par Rafael Garcia-Suarez
+\pause
+
+Dernière version: 5.10.0
+\end{block}
+\pause
+\vfill
+\begin{block}{PERL ne signifie rien}
+\emph{Practical Extraction and Report Language}
+(\emph{langage pratique d'extraction et de génération de rapports})
+
+\textbf{ou}
+
+\emph{Pathetically Eclectic Rubbish Lister}
+(\emph{collectionneur de déchets pathétiquement éclectiques})
+\end{block}
+\pause
+\vfill
+
+\begin{alertblock}{Perl 5 !}
+Perl 6 sera très différent
+\end{alertblock}
+\end{frame}
+
+\begin{frame}
+\frametitle{Pourquoi PERL ?}
+\begin{itemize}
+\item langage scripté, non compilé
+\pause
+\item gestion de la mémoire dynamique et automatique
+\pause
+\item portable (existe sous Unix*, Windows, OS/2, VMS\ldots)
+\pause
+\item est orienté objet
+\pause
+\item possède un grand nombre de modules additionnels
+\pause
+\item est très documenté
+\pause
+\item la communauté perl est conviviale
+\end{itemize}
+\pause
+\vfill
+Utilisation:
+\begin{itemize}
+\item petits scripts type shell
+\pause
+\item des programmes complexes
+\pause
+\item des services de toutes sortes
+\pause
+\item des sites web
+\item \ldots
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Exemples}
+\begin{exampleblock}{Exemple de script:}
+\begin{verbatim}
+#!env perl
+
+print "Hello World\n";
+\end{verbatim}
+\end{exampleblock}
+\pause
+\vfill
+\begin{exampleblock}{One-liner}
+\verb+perl -e 'print "Hello World\n"'+
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Obfusacte perl}
+Sinon ça peut aussi ressembler à ça:
+\vfill
+\begin{exampleblock}{bestever.pl de Philippe Bruhat (Book)}
+\begin{tiny}
+\verbatiminput{bestever.pl}
+\end{tiny}
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}
+\frametitle{Avant-propos}
+\begin{alertblock}{Ce dont je ne vais pas parler\ldots}
+\begin{itemize}
+\pause
+\item Plain Old Documentation - documenter son code
+\pause
+\item Espaces de noms
+\pause
+\item Ecriture de modules
+\pause
+\item Objets
+\pause
+\item XS: pont du C <=> perl
+\pause
+\item de la tonne de modules super géniale qui fait choses épatantes
+\pause
+\item obfuscate perl
+\pause
+\item des trucs super gores qu'on peut faire en perl, bien pire que l'obfuscate
+\end{itemize}
+\end{alertblock}
+\vfill
+\begin{block}{}
+Je sais, vous êtes déçus !
+\end{block}
+\end{frame}
+
+\begin{frame}
+\begin{block}{}
+\begin{Huge}There's More Than One Way To Do It!\end{Huge}
+
+\vfill
+Larry Wall
+\end{block}
+\end{frame}
Index: /trunk/perl/perl.syntaxe.tex
===================================================================
--- /trunk/perl/perl.syntaxe.tex	(revision 183)
+++ /trunk/perl/perl.syntaxe.tex	(revision 183)
@@ -0,0 +1,494 @@
+% $Id$
+
+\section{Syntaxe}
+
+\subsection{Syntaxe générale}
+
+\begin{frame}[fragile]
+\frametitle{Grandes lignes}
+\begin{itemize}
+\item les espaces sépare les mots
+\pause
+\item le '\verb+;+' sépare les instructions
+\pause
+\item le '\verb+,+' sépare les valeurs
+\pause
+\item \verb+( )+ limite une liste
+\pause
+\item \verb+{ }+ limite un bloc
+\pause
+\item tout ce qui suit un \verb+#+ est un commentaire
+\pause
+\item \verb+__END__+ indique la fin des instructions
+\end{itemize}
+\pause
+
+\begin{exampleblock}{Tout est permis, y compris apporter de la lisibilité à votre code:}
+\begin{verbatim}
+      push # création du tableau
+(         @tableau
+  , $valeur,    $valeur2     );
+\end{verbatim}
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Structure classique d'un script}
+\onslide<1-6>{un shell bang:}
+\onslide<2->
+\begin{verbatim}
+#!env perl
+\end{verbatim}
+\onslide<3-6>{charger les modules dont on a besoin:}
+\onslide<4->
+\begin{verbatim}
+use strict;
+use warnings;
+\end{verbatim}
+\onslide<5-6>{arrive le code:}
+\onslide<6->
+\begin{verbatim}
+while (<STDIN>) {
+    s/ //g;
+    print $_;
+}
+\end{verbatim}
+\onslide<7->
+\begin{verbatim}
+__END__
+\end{verbatim}
+\end{frame}
+
+\subsection{Controles d'execution}
+
+\begin{frame}[fragile]
+\frametitle{if}
+\begin{exampleblock}{Bah... if quoi...}
+\onslide<1->
+\vfill
+\begin{verbatim}
+if ($var == 0) {
+    print "var vaut 0\n";
+}
+\end{verbatim}
+\onslide<3->
+\begin{verbatim}
+ elsif ($var == 1) {
+    print "var vaut 1\n";
+}
+\end{verbatim}
+\onslide<2->
+\begin{verbatim}
+ else {
+    print "var vaut $var\n";
+}
+\end{verbatim}
+\end{exampleblock}
+\onslide<4->
+\begin{block}{Forme suffixée:}
+\begin{verbatim}
+print "var vaut 0\n" if ($var == 0);
+\end{verbatim}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{while}
+\begin{exampleblock}{Boucle tant qu'une condition est vraie:}
+\begin{verbatim}
+while ($i < 100) {
+    print "$i\n";
+    $i++;
+}
+\end{verbatim}
+\pause
+\begin{verbatim}
+do {
+    print "$i\n";
+    $i++;
+} while($i < 100;
+\end{verbatim}
+\end{exampleblock}
+\vfill
+\pause
+\begin{block}{Forme suffixée:}
+\begin{verbatim}
+$i++ while($i < 100);
+\end{verbatim}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{foreach}
+\begin{exampleblock}{Boucle \textbf{pour chaque} élément d'une liste:}
+\begin{verbatim}
+foreach $elem (@tableau) {
+    print "$elem\n";
+}
+\end{verbatim}
+\end{exampleblock}
+
+Très pratique, cela évite de s'embeter avec les indices du tableau.
+\vfill
+\pause
+
+\begin{block}{Forme suffixée:}
+\begin{verbatim}
+print "$_\n" foreach(@tableau);
+\end{verbatim}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Sortez moi de là}
+\begin{block}{\textbf{next} fait passer à la prochaine itération d'une boucle:}
+\begin{verbatim}
+foreach $val (@tableau) {
+    next if(!$val);
+    print "$val\n";
+}
+\end{verbatim}
+\end{block}
+\pause
+\vfill
+\begin{block}{\textbf{last} quitte une boucle:}
+\begin{verbatim}
+foreach $val (@tableau) {
+    if ($val > 1000) {
+        print "$val est trop haut, arret\n";
+        last;
+    }
+    print "$val\n";
+}
+\end{verbatim}
+\end{block}
+\end{frame}
+
+
+\subsection{Fonctions et subroutines}
+
+\begin{frame}[fragile]
+\frametitle{Fonctions}
+\begin{block}{Déclarer une fonction:}
+\begin{verbatim}
+sub fonction {
+    print "Hello World\n";
+}
+\end{verbatim}
+\end{block}
+\pause
+\begin{block}{Utilisation}
+\begin{verbatim}
+fonction();
+
+fonction;
+\end{verbatim}
+\end{block}
+\pause
+\vfill
+\begin{block}{\textit{Sub anonyme}, plus rarement utilisé:}
+\begin{verbatim}
+my $sub = sub { };
+$sub->();
+\end{verbatim}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Fonction: passage d'arguments}
+\begin{block}{les arguments sont passé dans \textbf{@\_}}
+\only<2>{On passe 1 arguments}
+\only<3>{On n arguments (ici 2)}
+\only<5>{on rends le premier arguments obligatoire, les autres
+sont optionnels}
+\onslide<4>{Via un hash:
+\begin{itemize}
+\item arguments nommés
+\item arguments optionnels
+\end{itemize}}
+\end{block}
+\begin{exampleblock}{}
+\pause
+\begin{semiverbatim}
+sub affiche \{
+    (\only<2-3,5->{$arg}\only<3,5->{, }\only<3>{$arg2}\only<4->{\%hash}) = @_;
+    print \only<2-3,5->{"$arg\\n"}\only<4>{$hash\{key1\}};
+\}
+
+affiche(\only<2,3,5->{"foo"}\only<3,5->{, }\only<3>{"bar"}\only<4->{key1 => "val1"});
+\end{semiverbatim}
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Retours des valeurs}
+\begin{block}{la dernière valeur est retournée}
+\pause
+\only<2-3>{On renvoit \only<2>{explicitement}\only<3>{implicitement} \$res
+\only<3>{ (dernière valeur)}}
+\only<4>{On renvoit explicitement le résultat}
+\only<5>{le resultat est la dernière valeur\ldots}
+\end{block}
+\begin{exampleblock}{}
+\begin{semiverbatim}
+sub addition \{
+    ($un, $deux) = @\_;
+    \only<2-3>{$res = }\only<4>{return }$un + $deux;
+    \only<2>{return }\only<2-3>{$res}
+\}
+
+print addition(2, 4);
+\end{semiverbatim}
+\end{exampleblock}
+\end{frame}
+
+\subsection{Traitement sur les listes}
+
+\begin{frame}[fragile]
+\frametitle{sort}
+
+\begin{block}{Fonction de tri}
+Evalue la comparaison entre \verb+$a+ et \verb+$b+
+
+Selon le résultat, l'une ou l'autre passe devant
+\end{block}
+\pause
+
+\vfill
+\begin{exampleblock}{}
+\begin{verbatim}
+my @tableau = ('010', '1', '12');
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\vfill
+\begin{exampleblock}{tri numérique}
+\begin{verbatim}
+sort { $a <=> $b } @tableau;
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\vfill
+\begin{exampleblock}{tri alphabétique}
+\begin{verbatim}
+sort { $a cmp $b } @tableau;
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\vfill
+\begin{exampleblock}{tri numérique inverse}
+\begin{verbatim}
+sort { $b <=> $a } @tableau;
+\end{verbatim}
+\end{exampleblock}
+
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{grep}
+\begin{block}{Fonction de filtre}
+Revois chaque valeur placée dans \verb+$_+ si la condition renvoyée est vraie
+\end{block}
+\pause
+
+\vfill
+\begin{exampleblock}{}
+
+
+\begin{verbatim}
+my @tableau = ('010', '1', '12');
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\vfill
+\begin{exampleblock}{valeur vraie}
+\begin{verbatim}
+grep { $_ } @tableau;
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\vfill
+\begin{exampleblock}{avec une condition}
+\begin{verbatim}
+grep { $_ > 10 } @tableau;
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\vfill
+\begin{exampleblock}{sans utiliser \$\_}
+\begin{verbatim}
+my $vrai = 1
+grep { $vrai } @tableau;
+\end{verbatim}
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{map}
+\begin{block}{mappage des valeurs}
+Remplace chaque valeur par l'évaluation retournée
+
+Chaque valeur est placé dans \verb+$_+
+\end{block}
+\pause
+
+\vfill
+\begin{exampleblock}{}
+\begin{verbatim}
+my @tableau = ('010', '1', '12');
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\vfill
+\begin{exampleblock}{renvois chaque valeur + 1}
+\begin{verbatim}
+map { $_ + 1 } @tableau;
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\vfill
+\begin{exampleblock}{renvois chaque valeur et chaque valeur + 1}
+\begin{verbatim}
+map { $_, $_ + 1 } @tableau;
+\end{verbatim}
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Combinaison pour la forme}
+
+\begin{exampleblock}{humpff\ldots}
+\begin{semiverbatim}
+my @communes =
+    \onslide<5->{# première lettre en majuscule}
+    map \{ ucfirst($\_) \}
+    \onslide<4->{# tri: ordre alphabétique}
+    sort \{ $a cmp $b \}
+    \onslide<3->{# filtre: première lettre est un m}
+    grep \{ substr($\_, 0, 1) eq 'm' \}
+    \onslide<2->{# une liste de villes}
+    ('nantes',
+     'mont de marsan', 'amiens', 'nancy', 'dijon',
+     'bordeaux', 'metz', bordeaux', 'bordeaux', );
+\end{semiverbatim}
+\end{exampleblock}
+\end{frame}
+
+\subsection{Déclarer ses variables}
+
+\begin{frame}[fragile]
+\frametitle{my and compagny}
+\begin{block}{Perl est très laxiste:}
+\pause
+\only<2>{Voici un code qui fonctionne, mais pas comme on veut\ldots}
+\onslide<3->{
+Deux moyens de forcer les décalarations:
+\pause
+\begin{itemize}
+\item \textbf{use strict;} force la declaration des variables
+\pause
+\item \textbf{use warnings;} produit des warnings sur les actions douteuses
+\end{itemize}
+}
+\only<6->{\textbf{my} sert à déclarer une variable\\
+}
+\pause
+\only<8->{Voilà qui est parfait !}
+\end{block}
+
+\onslide<5,7>{
+\begin{alertblock}{l'erreur:}
+\only<5>{Global symbol "\$latitude" requires explicit package}
+\only<7>{Global symbol "\$latitud" requires explicit package}
+\end{alertblock}
+}
+
+\onslide<1->
+\begin{exampleblock}{}
+\begin{semiverbatim}
+\onslide<5->{use strict;
+}
+\only<6->{my }$latitude = 5;
+print "$latitud\only<8->{e}\\n";
+\end{semiverbatim}
+\end{exampleblock}
+
+\end{frame}
+
+\begin{frame}
+\frametitle{The use strict rules}
+
+\begin{alertblock}{J'ai bien pris note que:}
+\only<2->{
+J'utiliserais au moins \textit{use strict}\\
+}
+\only<3->{
+J'utiliserais \textbf{toujours} au moins \textit{use strict}\\
+}
+\only<4->{
+\textbf{Jamais} je ne dérangerais un gourou Perl si je n'ai pas utilisé
+\textit{use strict}\\
+}
+
+\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Portée des variables}
+\begin{alertblock}{}
+\verb+$var+ différent de \verb+@var+ différent de \verb+%var+ !
+\end{alertblock}
+\pause
+\begin{block}{les règles}
+Sans \verb+use strict;+ ni \verb+my+ Perl fait au mieux.\\
+\pause
+Les déclarations se font n'importe où, mais avant leur utilisation.
+\end{block}
+\pause
+\begin{exampleblock}{example:}
+\onslide<4->
+\begin{semiverbatim}
+use strict;
+\onslide<5->{mafonction();}
+my $var = 1
+sub mafonction \{
+    print $var;
+    my $fvar = 3;
+\}
+\end{semiverbatim}
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{boucles et blocs}
+\begin{exampleblock}{limiter la portée en utilisant un bloc}
+\begin{verbatim}
+my $globalvar = 1;
+{
+    my $blockvar = 2;
+}
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\begin{exampleblock}{Déclaration dans les boucles}
+\begin{verbatim}
+
+my @tableau = (1, 2, 3, 4);
+
+foreach my $item (@tableau) {
+    print "$item\n";
+}
+\end{verbatim}
+\end{exampleblock}
+\end{frame}
+
+
Index: /trunk/perl/perl.tex
===================================================================
--- /trunk/perl/perl.tex	(revision 182)
+++ /trunk/perl/perl.tex	(revision 183)
@@ -21,15 +21,15 @@
 \end{frame}
 
-\include{introduction}
+\include{perl.introduction}
 
-\include{variables}
+\include{perl.variables}
 
-\include{syntaxe}
+\include{perl.syntaxe}
 
-\include{chaines}
+\include{perl.chaines}
 
-\include{variablesbis}
+\include{perl.variablesbis}
 
-\include{conclusion}
+\include{perl.conclusion}
 
 \end{document}
Index: /trunk/perl/perl.variables.tex
===================================================================
--- /trunk/perl/perl.variables.tex	(revision 183)
+++ /trunk/perl/perl.variables.tex	(revision 183)
@@ -0,0 +1,280 @@
+% $Id$
+
+\section{Variables}
+
+\subsection{Variables de Perl}
+
+\begin{frame}
+\frametitle{types de variables}
+\textbf{15} types de variables:
+\pause
+\begin{itemize}
+\item scalaires (scalar)
+\pause
+\item tableaux (array)
+\pause
+\item hash (hash)
+\pause
+\end{itemize}
+\vfill
+\onslide<2->
+\includegraphics[height=40mm]{Angel_fish}
+\onslide<3->
+\includegraphics[height=40mm]{tableau}
+\onslide<4->
+\includegraphics[height=40mm]{hache}
+\onslide<5->
+\vfill
+Et les autres on s'en moque...
+\end{frame}
+
+\subsection{Scalaire}
+
+\begin{frame}[fragile]
+\frametitle{scalaire}
+\begin{block}{Un \textbf{scalaire} est une simple valeur:}
+\begin{itemize}
+\pause
+\item \emph{undef}
+\pause
+\item définie:
+    \begin{itemize}
+    \item un chiffre, nombre
+    \item une chaine de caractères
+    \item \ldots
+    \end{itemize}
+\end{itemize}
+\end{block}
+\pause
+\vfill
+\begin{block}{Convertion}
+Perl évalue et converti les valeurs numériques au vol!
+\end{block}
+\pause
+\vfill
+
+\begin{exampleblock}{Exemple de valeur de scalaire}
+\begin{verbatim}
+$rien = undef;
+$chiffre = 42; $chaine = "1";
+print $chaine + $chiffre;
+print $chaine . $chiffre;
+\end{verbatim}
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Scalair: Vrai ou Faux ?}
+\begin{block}{}
+Valeur \textit{fausses}: \textit{undef}, 0, "0", ""
+
+Valeur \textit{vraies}: le reste: 1, "1", "un chien ?"
+\end{block}
+\pause
+\vfill
+
+\begin{exampleblock}{Exemple de test}
+\begin{verbatim}
+$valeur = "0"; 
+if ($valeur) # faux, "0" => 0
+if ($valeur == 0) # vrai "0" => 0
+if ($valeur eq "") # faux, chaine non vide
+\end{verbatim}
+\end{exampleblock}
+\pause
+\vfill
+
+\begin{exampleblock}{0 but True}
+\begin{verbatim}
+$valeur = "0E0";
+\end{verbatim}
+\end{exampleblock}
+\end{frame}
+
+\subsection{Les tableaux}
+
+\begin{frame}[fragile]
+\frametitle{Tableau (array)}
+\begin{block}{Les tableaux sont des piles de scalaires}
+\begin{verbatim}
+$valeur = 3;
+@tableau = ($valeur, "chaines");
+\end{verbatim}
+\end{block}
+\pause
+
+\vfill
+\begin{block}{}
+Ils sont dynamiques, et a une seule dimension
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Tableau: Exemples}
+\begin{exampleblock}{Utilisation:}
+\begin{verbatim}
+@tableau = (1, 2, 3);
+$tableau[3] = 4;
+$tableau[-1]; # dernier élément
+\end{verbatim}
+\end{exampleblock}
+\pause
+\vfill
+\begin{alertblock}{Attention au \$}
+\begin{verbatim}
+@tableau;
+$tableau[1];
+\end{verbatim}
+\end{alertblock}
+\pause
+\vfill
+\begin{block}{}
+Nombre d'éléments: \verb+scalar(@tableau)+
+
+Dernier indice: \verb+$#tableau+
+\end{block}
+\pause
+\vfill
+\begin{block}{Les bouts du tableau}
+\begin{tabular}{rcl}
+shift <=&\verb+0$$$$$n+&<= push\\
+unshift =>&\verb+0$$$$$n+&=> pop\\
+\end{tabular}
+\end{block}
+\end{frame}
+
+\subsection{Les tables de hashage}
+
+\begin{frame}[fragile]
+\frametitle{hash}
+\begin{block}{tables de hashage}
+Ce sont des tableaux indexés \verb+clef => valeur+.
+
+Ils sont dynamiques.
+
+\pause
+\begin{itemize}
+\item la clef est une valeur textuelle simple
+\item la valeur est un \textbf{scalaire}
+\item l'ordre des clefs n'est pas conservé !!!
+\end{itemize}
+\end{block}
+
+\end{frame}
+\begin{frame}[fragile]
+\frametitle{hash: exemple}
+\begin{exampleblock}{Utiliser tableau de hashage:}
+\begin{verbatim}
+%hash = ( foo => "un"
+          bar => 2 );
+print $hash{'bar'};
+$clef = 'clef'; $hash{$clef};
+\end{verbatim}
+\end{exampleblock}
+\pause
+\vfill
+\begin{alertblock}{Attention au \$}
+\begin{verbatim}
+%hash;
+$hash{baz};
+\end{verbatim}
+\end{alertblock}
+\vfill
+\pause
+\begin{block}{keys: renvois les clefs}
+\begin{verbatim}
+keys(%hash);
+\end{verbatim}
+\end{block}
+
+\end{frame}
+
+\subsection{Les listes}
+
+\begin{frame}[fragile]
+\frametitle{Comprendre les listes}
+\begin{alertblock}{Perl aplati les listes !}
+
+Le concept est simple, mais redoutable:
+\end{alertblock}
+\pause
+
+\vfill
+\vfill
+\begin{exampleblock}{Prenons deux tableaux de trois entrées:}
+\begin{verbatim}
+@tab1 = (1, 2, 3);
+@tab2 = (4, 5, 6);
+\end{verbatim}
+\end{exampleblock}
+\vfill
+\pause
+
+\begin{exampleblock}{}
+\begin{semiverbatim}
+(\only<6>{undef, }$un\only<4->{, @reste}) = \only<5->{(}@tab1\only<5->{, @tab2)};
+\end{semiverbatim}
+\end{exampleblock}
+\begin{block}{}
+\only<3>{On copie la première entrée du tableau dans \$un}
+\only<4>{pareil, mais la fin du tableaux va dans @reste}
+\only<5>{@tab1 et @tab2 ne forme plus qu'un lors de la copie}
+\only<6>{la première entrée est ignoré (undef)}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Comprendre les listes: les hash}
+\begin{block}{}
+'\verb+=>+' est un séparateur comme la '\verb+,+', donc c'est une liste:
+\begin{verbatim}
+%hash = (un => 1, deux => 2);
+%hash = (un, 1, deux, 2);
+@tab = %hash; %hash = @tableau;
+\end{verbatim}
+\verb+@tab+ contient "un", 1\ldots
+\end{block}
+\pause
+\begin{block}{hash vers hash}
+\begin{verbatim}
+%unhash = (%hash2, %hash3);
+\end{verbatim}
+\verb+%hash+ contient 1 \verb+=>+ 2, 3 \verb+=>+ 4\ldots
+\end{block}
+\pause
+\begin{alertblock}{}
+Les clefs dupliquées sont ecrasées, la dernière gagne !
+\end{alertblock}
+\end{frame}
+
+\subsection{les variables magiques}
+
+\begin{frame}[fragile]
+\begin{block}{Elles existent dans tout programme perl.}
+Les principales à connaitre:\\
+\pause
+\vfill
+
+\begin{tabular}{ll}
+\verb+$_+&stockage par défaut\\
+\pause
+\verb+@_+&paramètres des subroutines\\
+\pause
+&\\
+\verb+@ARGV+&les arguments passés aux programmes\\
+\pause
+&\\
+\verb+$a+ et \verb+$b+&utilisé par sort\\
+\end{tabular}
+\end{block}
+\pause
+
+\vfill
+\vfill
+\begin{alertblock}{Attention à \$\_}
+\verb+$_+ permet d'écrire du code succin, mais n'augmente pas la visibilité:
+\begin{verbatim}
+$entier = int;
+\end{verbatim}
+\end{alertblock}
+\end{frame}
Index: /trunk/perl/perl.variablesbis.tex
===================================================================
--- /trunk/perl/perl.variablesbis.tex	(revision 183)
+++ /trunk/perl/perl.variablesbis.tex	(revision 183)
@@ -0,0 +1,250 @@
+% $Id$
+
+\section{Variables bis}
+
+\subsection{Références}
+
+\begin{frame}[fragile]
+\frametitle{Référence: Concept}
+\begin{block}{Quoi ça ?}
+C'est une valeur scalaire\ldots
+
+\pause
+\vfill
+qui fait référence à un scalaire, un tableau ou un hash.
+
+\pause
+\vfill
+\begin{itemize}
+\item elle contient l'adresse mémoire de l'élément pointé
+\pause
+\item plusieurs références peuvent pointer la même variable
+\pause
+\item on peut faire des tableaux de références\ldots
+\end{itemize}
+\end{block}
+\pause
+\vfill
+\begin{alertblock}{Ce n'est pas un pointeur au sens C du terme}
+\verb.$ref++;. ne donnera rien de bien !!!!
+
+On fait du perl, on ne joue pas avec les octets de la mémoire.
+\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Créer des références}
+\begin{exampleblock}{Renvoyer la référence de}
+\verb+\+ pour renvoyer un référence:
+\begin{verbatim}
+my $ref = \$scalaire;
+my $ref = \@tableau;
+my $ref = \%hash;
+\end{verbatim}
+\end{exampleblock}
+\vfill
+\pause
+
+\begin{block}{Créer une référence:}
+\begin{tabular}{|l|c|}
+\hline
+Type de variable&code\\
+\hline
+\hline
+tableau&\verb+[ 'val1', 'val2' ]+\\
+\hline
+hash&\verb+{ key => val }+\\
+\hline
+\end{tabular}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Utiliser les références}
+
+\begin{exampleblock}{prenons une référence}
+\begin{verbatim}
+$ref = { key => 'val' }; print $ref;
+HASH(0x8bca880)
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\begin{block}{Accès aux variable}
+\center
+\begin{tabular}{|l|c|c|}
+\hline
+type&variables&éléments de\\
+\hline
+\hline
+scalaire&\verb+$$var+&\\
+\hline
+tableau&\verb+@{$ref}+&\verb+$ref->[0]+\\
+\hline
+hash&\verb+%{$ref}+&\verb+$ref->{'key'}+\\
+\hline
+\end{tabular}
+\end{block}
+\pause
+
+\begin{exampleblock}{}
+\begin{verbatim}
+foreach my $key (keys %$ref) {
+    print "$ref->{$key}\n";
+}
+\end{verbatim}
+\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Pourquoi les références ?}
+\begin{alertblock}{Perl aplati les listes, remember ?}
+
+\pause
+\begin{verbatim}
+my @tab1 = (1,2); my @tab2 = (3,4);
+my @tab = (@tab1, @tab2);
+\end{verbatim}
+\verb+@tab+ contient 4 éléments...
+\end{alertblock}
+\pause
+
+\begin{block}{par contre:}
+\begin{verbatim}
+my @tab1 = (1,2); my @tab2 = (3,4);
+my @tab = (\@tab1, \@tab2);
+\end{verbatim}
+\verb+@tab+ contient 2 éléments qui réferencent des tableaux.
+\end{block}
+\pause
+
+\begin{block}{On accède aux valeurs:}
+\begin{verbatim}
+$tab[0]->[0];
+$tab[0][0];
+\end{verbatim}
+\end{block}
+
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Références: les pièges}
+\begin{alertblock}{Déférencer un undef:}
+\begin{verbatim}
+perl -we 'my $ref; print @{ $ref }'
+Use of uninitialized value $ref in 
+array dereference at -e line 1.
+\end{verbatim}
+\end{alertblock}
+\pause
+\vfill
+\begin{alertblock}{Attention au type de variable référencée:}
+\begin{verbatim}
+perl -we 'my $ref = {}; print @{ $ref }'
+Not an ARRAY reference at -e line 1.
+\end{verbatim}
+\end{alertblock}
+\pause
+\vfill
+\begin{alertblock}{Attention au structure complexes:}
+\begin{verbatim}
+$ref->[0][2]{daleks}[0]{episode}
+    {$ennemi}{histoire}[0];
+\end{verbatim}
+\end{alertblock}
+\end{frame}
+
+\subsection{les descripteurs de fichier}
+
+\begin{frame}[fragile]
+\frametitle{Fichiers: Version simple}
+\begin{exampleblock}{Ouvrir un fichier en lecture:}
+\begin{verbatim}
+open(my $handle, '<', 'fichier');
+\end{verbatim}
+\end{exampleblock}
+\pause
+\begin{exampleblock}{Lire une ligne:}
+\begin{verbatim}
+my $line = <$handle>;
+chomp($line); # strip cariage return
+\end{verbatim}
+\end{exampleblock}
+\pause
+\begin{exampleblock}{Fermer le fichier:}
+\begin{verbatim}
+close($handle);
+\end{verbatim}
+\end{exampleblock}
+\pause
+\vfill
+\begin{alertblock}{Ancienne méthode (perl < 5.6)}
+\begin{verbatim}
+open(HANDLE, '<', 'fichier');
+my $line = <HANDLE>;
+close(HANDLE);
+\end{verbatim}
+\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Fichier: version simple (suite)}
+
+\begin{exampleblock}{Ecrire}
+\begin{verbatim}
+open(my $handle, '>', 'fichier');
+print $handle "Exterminate !\n";
+close($handle);
+\end{verbatim}
+\end{exampleblock}
+\pause
+
+\begin{alertblock}{Attention à print}
+pas de \verb+,+ après le file handle
+\end{alertblock}
+
+\pause
+\vfill
+\begin{block}{File handle par défaut}
+\begin{itemize}
+\item \verb+STDERR+ (sortie d'erreur)
+\item \verb+STDOUT+ (sortie standard)
+\item \verb+STDIN+ (entrée standard)
+\end{itemize}
+\end{block}
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Fichiers: Version compliquée}
+\begin{block}{haut niveau}
+\begin{itemize}
+\item open()/close()
+\item read()/print()
+\end{itemize}
+\end{block}
+
+\pause
+\vfill
+\begin{block}{bas niveau}
+\begin{itemize}
+\item sysopen()/sysclose()
+\item sysread()/syswrite()
+\end{itemize}
+\end{block}
+
+\pause
+\vfill
+\begin{block}{Glob !}
+Pour info, un filehandle est une variable de type \textbf{GLOB}.
+\end{block}
+
+\pause
+\vfill
+\begin{block}{Si vraiment vous voulez en savoir plus: man}
+\begin{itemize}
+\item perlfunc
+\item perlopentut
+\end{itemize}
+\end{block}
+\end{frame}
+
Index: unk/perl/syntaxe.tex
===================================================================
--- /trunk/perl/syntaxe.tex	(revision 182)
+++ 	(revision )
@@ -1,494 +1,0 @@
-% $Id$
-
-\section{Syntaxe}
-
-\subsection{Syntaxe générale}
-
-\begin{frame}[fragile]
-\frametitle{Grandes lignes}
-\begin{itemize}
-\item les espaces sépare les mots
-\pause
-\item le '\verb+;+' sépare les instructions
-\pause
-\item le '\verb+,+' sépare les valeurs
-\pause
-\item \verb+( )+ limite une liste
-\pause
-\item \verb+{ }+ limite un bloc
-\pause
-\item tout ce qui suit un \verb+#+ est un commentaire
-\pause
-\item \verb+__END__+ indique la fin des instructions
-\end{itemize}
-\pause
-
-\begin{exampleblock}{Tout est permis, y compris apporter de la lisibilité à votre code:}
-\begin{verbatim}
-      push # création du tableau
-(         @tableau
-  , $valeur,    $valeur2     );
-\end{verbatim}
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Structure classique d'un script}
-\onslide<1-6>{un shell bang:}
-\onslide<2->
-\begin{verbatim}
-#!env perl
-\end{verbatim}
-\onslide<3-6>{charger les modules dont on a besoin:}
-\onslide<4->
-\begin{verbatim}
-use strict;
-use warnings;
-\end{verbatim}
-\onslide<5-6>{arrive le code:}
-\onslide<6->
-\begin{verbatim}
-while (<STDIN>) {
-    s/ //g;
-    print $_;
-}
-\end{verbatim}
-\onslide<7->
-\begin{verbatim}
-__END__
-\end{verbatim}
-\end{frame}
-
-\subsection{Controles d'execution}
-
-\begin{frame}[fragile]
-\frametitle{if}
-\begin{exampleblock}{Bah... if quoi...}
-\onslide<1->
-\vfill
-\begin{verbatim}
-if ($var == 0) {
-    print "var vaut 0\n";
-}
-\end{verbatim}
-\onslide<3->
-\begin{verbatim}
- elsif ($var == 1) {
-    print "var vaut 1\n";
-}
-\end{verbatim}
-\onslide<2->
-\begin{verbatim}
- else {
-    print "var vaut $var\n";
-}
-\end{verbatim}
-\end{exampleblock}
-\onslide<4->
-\begin{block}{Forme suffixée:}
-\begin{verbatim}
-print "var vaut 0\n" if ($var == 0);
-\end{verbatim}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{while}
-\begin{exampleblock}{Boucle tant qu'une condition est vraie:}
-\begin{verbatim}
-while ($i < 100) {
-    print "$i\n";
-    $i++;
-}
-\end{verbatim}
-\pause
-\begin{verbatim}
-do {
-    print "$i\n";
-    $i++;
-} while($i < 100;
-\end{verbatim}
-\end{exampleblock}
-\vfill
-\pause
-\begin{block}{Forme suffixée:}
-\begin{verbatim}
-$i++ while($i < 100);
-\end{verbatim}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{foreach}
-\begin{exampleblock}{Boucle \textbf{pour chaque} élément d'une liste:}
-\begin{verbatim}
-foreach $elem (@tableau) {
-    print "$elem\n";
-}
-\end{verbatim}
-\end{exampleblock}
-
-Très pratique, cela évite de s'embeter avec les indices du tableau.
-\vfill
-\pause
-
-\begin{block}{Forme suffixée:}
-\begin{verbatim}
-print "$_\n" foreach(@tableau);
-\end{verbatim}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Sortez moi de là}
-\begin{block}{\textbf{next} fait passer à la prochaine itération d'une boucle:}
-\begin{verbatim}
-foreach $val (@tableau) {
-    next if(!$val);
-    print "$val\n";
-}
-\end{verbatim}
-\end{block}
-\pause
-\vfill
-\begin{block}{\textbf{last} quitte une boucle:}
-\begin{verbatim}
-foreach $val (@tableau) {
-    if ($val > 1000) {
-        print "$val est trop haut, arret\n";
-        last;
-    }
-    print "$val\n";
-}
-\end{verbatim}
-\end{block}
-\end{frame}
-
-
-\subsection{Fonctions et subroutines}
-
-\begin{frame}[fragile]
-\frametitle{Fonctions}
-\begin{block}{Déclarer une fonction:}
-\begin{verbatim}
-sub fonction {
-    print "Hello World\n";
-}
-\end{verbatim}
-\end{block}
-\pause
-\begin{block}{Utilisation}
-\begin{verbatim}
-fonction();
-
-fonction;
-\end{verbatim}
-\end{block}
-\pause
-\vfill
-\begin{block}{\textit{Sub anonyme}, plus rarement utilisé:}
-\begin{verbatim}
-my $sub = sub { };
-$sub->();
-\end{verbatim}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Fonction: passage d'arguments}
-\begin{block}{les arguments sont passé dans \textbf{@\_}}
-\only<2>{On passe 1 arguments}
-\only<3>{On n arguments (ici 2)}
-\only<5>{on rends le premier arguments obligatoire, les autres
-sont optionnels}
-\onslide<4>{Via un hash:
-\begin{itemize}
-\item arguments nommés
-\item arguments optionnels
-\end{itemize}}
-\end{block}
-\begin{exampleblock}{}
-\pause
-\begin{semiverbatim}
-sub affiche \{
-    (\only<2-3,5->{$arg}\only<3,5->{, }\only<3>{$arg2}\only<4->{\%hash}) = @_;
-    print \only<2-3,5->{"$arg\\n"}\only<4>{$hash\{key1\}};
-\}
-
-affiche(\only<2,3,5->{"foo"}\only<3,5->{, }\only<3>{"bar"}\only<4->{key1 => "val1"});
-\end{semiverbatim}
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Retours des valeurs}
-\begin{block}{la dernière valeur est retournée}
-\pause
-\only<2-3>{On renvoit \only<2>{explicitement}\only<3>{implicitement} \$res
-\only<3>{ (dernière valeur)}}
-\only<4>{On renvoit explicitement le résultat}
-\only<5>{le resultat est la dernière valeur\ldots}
-\end{block}
-\begin{exampleblock}{}
-\begin{semiverbatim}
-sub addition \{
-    ($un, $deux) = @\_;
-    \only<2-3>{$res = }\only<4>{return }$un + $deux;
-    \only<2>{return }\only<2-3>{$res}
-\}
-
-print addition(2, 4);
-\end{semiverbatim}
-\end{exampleblock}
-\end{frame}
-
-\subsection{Traitement sur les listes}
-
-\begin{frame}[fragile]
-\frametitle{sort}
-
-\begin{block}{Fonction de tri}
-Evalue la comparaison entre \verb+$a+ et \verb+$b+
-
-Selon le résultat, l'une ou l'autre passe devant
-\end{block}
-\pause
-
-\vfill
-\begin{exampleblock}{}
-\begin{verbatim}
-my @tableau = ('010', '1', '12');
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\vfill
-\begin{exampleblock}{tri numérique}
-\begin{verbatim}
-sort { $a <=> $b } @tableau;
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\vfill
-\begin{exampleblock}{tri alphabétique}
-\begin{verbatim}
-sort { $a cmp $b } @tableau;
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\vfill
-\begin{exampleblock}{tri numérique inverse}
-\begin{verbatim}
-sort { $b <=> $a } @tableau;
-\end{verbatim}
-\end{exampleblock}
-
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{grep}
-\begin{block}{Fonction de filtre}
-Revois chaque valeur placée dans \verb+$_+ si la condition renvoyée est vraie
-\end{block}
-\pause
-
-\vfill
-\begin{exampleblock}{}
-
-
-\begin{verbatim}
-my @tableau = ('010', '1', '12');
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\vfill
-\begin{exampleblock}{valeur vraie}
-\begin{verbatim}
-grep { $_ } @tableau;
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\vfill
-\begin{exampleblock}{avec une condition}
-\begin{verbatim}
-grep { $_ > 10 } @tableau;
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\vfill
-\begin{exampleblock}{sans utiliser \$\_}
-\begin{verbatim}
-my $vrai = 1
-grep { $vrai } @tableau;
-\end{verbatim}
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{map}
-\begin{block}{mappage des valeurs}
-Remplace chaque valeur par l'évaluation retournée
-
-Chaque valeur est placé dans \verb+$_+
-\end{block}
-\pause
-
-\vfill
-\begin{exampleblock}{}
-\begin{verbatim}
-my @tableau = ('010', '1', '12');
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\vfill
-\begin{exampleblock}{renvois chaque valeur + 1}
-\begin{verbatim}
-map { $_ + 1 } @tableau;
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\vfill
-\begin{exampleblock}{renvois chaque valeur et chaque valeur + 1}
-\begin{verbatim}
-map { $_, $_ + 1 } @tableau;
-\end{verbatim}
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Combinaison pour la forme}
-
-\begin{exampleblock}{humpff\ldots}
-\begin{semiverbatim}
-my @communes =
-    \onslide<5->{# première lettre en majuscule}
-    map \{ ucfirst($\_) \}
-    \onslide<4->{# tri: ordre alphabétique}
-    sort \{ $a cmp $b \}
-    \onslide<3->{# filtre: première lettre est un m}
-    grep \{ substr($\_, 0, 1) eq 'm' \}
-    \onslide<2->{# une liste de villes}
-    ('nantes',
-     'mont de marsan', 'amiens', 'nancy', 'dijon',
-     'bordeaux', 'metz', bordeaux', 'bordeaux', );
-\end{semiverbatim}
-\end{exampleblock}
-\end{frame}
-
-\subsection{Déclarer ses variables}
-
-\begin{frame}[fragile]
-\frametitle{my and compagny}
-\begin{block}{Perl est très laxiste:}
-\pause
-\only<2>{Voici un code qui fonctionne, mais pas comme on veut\ldots}
-\onslide<3->{
-Deux moyens de forcer les décalarations:
-\pause
-\begin{itemize}
-\item \textbf{use strict;} force la declaration des variables
-\pause
-\item \textbf{use warnings;} produit des warnings sur les actions douteuses
-\end{itemize}
-}
-\only<6->{\textbf{my} sert à déclarer une variable\\
-}
-\pause
-\only<8->{Voilà qui est parfait !}
-\end{block}
-
-\onslide<5,7>{
-\begin{alertblock}{l'erreur:}
-\only<5>{Global symbol "\$latitude" requires explicit package}
-\only<7>{Global symbol "\$latitud" requires explicit package}
-\end{alertblock}
-}
-
-\onslide<1->
-\begin{exampleblock}{}
-\begin{semiverbatim}
-\onslide<5->{use strict;
-}
-\only<6->{my }$latitude = 5;
-print "$latitud\only<8->{e}\\n";
-\end{semiverbatim}
-\end{exampleblock}
-
-\end{frame}
-
-\begin{frame}
-\frametitle{The use strict rules}
-
-\begin{alertblock}{J'ai bien pris note que:}
-\only<2->{
-J'utiliserais au moins \textit{use strict}\\
-}
-\only<3->{
-J'utiliserais \textbf{toujours} au moins \textit{use strict}\\
-}
-\only<4->{
-\textbf{Jamais} je ne dérangerais un gourou Perl si je n'ai pas utilisé
-\textit{use strict}\\
-}
-
-\end{alertblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Portée des variables}
-\begin{alertblock}{}
-\verb+$var+ différent de \verb+@var+ différent de \verb+%var+ !
-\end{alertblock}
-\pause
-\begin{block}{les règles}
-Sans \verb+use strict;+ ni \verb+my+ Perl fait au mieux.\\
-\pause
-Les déclarations se font n'importe où, mais avant leur utilisation.
-\end{block}
-\pause
-\begin{exampleblock}{example:}
-\onslide<4->
-\begin{semiverbatim}
-use strict;
-\onslide<5->{mafonction();}
-my $var = 1
-sub mafonction \{
-    print $var;
-    my $fvar = 3;
-\}
-\end{semiverbatim}
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{boucles et blocs}
-\begin{exampleblock}{limiter la portée en utilisant un bloc}
-\begin{verbatim}
-my $globalvar = 1;
-{
-    my $blockvar = 2;
-}
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\begin{exampleblock}{Déclaration dans les boucles}
-\begin{verbatim}
-
-my @tableau = (1, 2, 3, 4);
-
-foreach my $item (@tableau) {
-    print "$item\n";
-}
-\end{verbatim}
-\end{exampleblock}
-\end{frame}
-
-
Index: unk/perl/variables.tex
===================================================================
--- /trunk/perl/variables.tex	(revision 182)
+++ 	(revision )
@@ -1,280 +1,0 @@
-% $Id$
-
-\section{Variables}
-
-\subsection{Variables de Perl}
-
-\begin{frame}
-\frametitle{types de variables}
-\textbf{15} types de variables:
-\pause
-\begin{itemize}
-\item scalaires (scalar)
-\pause
-\item tableaux (array)
-\pause
-\item hash (hash)
-\pause
-\end{itemize}
-\vfill
-\onslide<2->
-\includegraphics[height=40mm]{Angel_fish}
-\onslide<3->
-\includegraphics[height=40mm]{tableau}
-\onslide<4->
-\includegraphics[height=40mm]{hache}
-\onslide<5->
-\vfill
-Et les autres on s'en moque...
-\end{frame}
-
-\subsection{Scalaire}
-
-\begin{frame}[fragile]
-\frametitle{scalaire}
-\begin{block}{Un \textbf{scalaire} est une simple valeur:}
-\begin{itemize}
-\pause
-\item \emph{undef}
-\pause
-\item définie:
-    \begin{itemize}
-    \item un chiffre, nombre
-    \item une chaine de caractères
-    \item \ldots
-    \end{itemize}
-\end{itemize}
-\end{block}
-\pause
-\vfill
-\begin{block}{Convertion}
-Perl évalue et converti les valeurs numériques au vol!
-\end{block}
-\pause
-\vfill
-
-\begin{exampleblock}{Exemple de valeur de scalaire}
-\begin{verbatim}
-$rien = undef;
-$chiffre = 42; $chaine = "1";
-print $chaine + $chiffre;
-print $chaine . $chiffre;
-\end{verbatim}
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Scalair: Vrai ou Faux ?}
-\begin{block}{}
-Valeur \textit{fausses}: \textit{undef}, 0, "0", ""
-
-Valeur \textit{vraies}: le reste: 1, "1", "un chien ?"
-\end{block}
-\pause
-\vfill
-
-\begin{exampleblock}{Exemple de test}
-\begin{verbatim}
-$valeur = "0"; 
-if ($valeur) # faux, "0" => 0
-if ($valeur == 0) # vrai "0" => 0
-if ($valeur eq "") # faux, chaine non vide
-\end{verbatim}
-\end{exampleblock}
-\pause
-\vfill
-
-\begin{exampleblock}{0 but True}
-\begin{verbatim}
-$valeur = "0E0";
-\end{verbatim}
-\end{exampleblock}
-\end{frame}
-
-\subsection{Les tableaux}
-
-\begin{frame}[fragile]
-\frametitle{Tableau (array)}
-\begin{block}{Les tableaux sont des piles de scalaires}
-\begin{verbatim}
-$valeur = 3;
-@tableau = ($valeur, "chaines");
-\end{verbatim}
-\end{block}
-\pause
-
-\vfill
-\begin{block}{}
-Ils sont dynamiques, et a une seule dimension
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Tableau: Exemples}
-\begin{exampleblock}{Utilisation:}
-\begin{verbatim}
-@tableau = (1, 2, 3);
-$tableau[3] = 4;
-$tableau[-1]; # dernier élément
-\end{verbatim}
-\end{exampleblock}
-\pause
-\vfill
-\begin{alertblock}{Attention au \$}
-\begin{verbatim}
-@tableau;
-$tableau[1];
-\end{verbatim}
-\end{alertblock}
-\pause
-\vfill
-\begin{block}{}
-Nombre d'éléments: \verb+scalar(@tableau)+
-
-Dernier indice: \verb+$#tableau+
-\end{block}
-\pause
-\vfill
-\begin{block}{Les bouts du tableau}
-\begin{tabular}{rcl}
-shift <=&\verb+0$$$$$n+&<= push\\
-unshift =>&\verb+0$$$$$n+&=> pop\\
-\end{tabular}
-\end{block}
-\end{frame}
-
-\subsection{Les tables de hashage}
-
-\begin{frame}[fragile]
-\frametitle{hash}
-\begin{block}{tables de hashage}
-Ce sont des tableaux indexés \verb+clef => valeur+.
-
-Ils sont dynamiques.
-
-\pause
-\begin{itemize}
-\item la clef est une valeur textuelle simple
-\item la valeur est un \textbf{scalaire}
-\item l'ordre des clefs n'est pas conservé !!!
-\end{itemize}
-\end{block}
-
-\end{frame}
-\begin{frame}[fragile]
-\frametitle{hash: exemple}
-\begin{exampleblock}{Utiliser tableau de hashage:}
-\begin{verbatim}
-%hash = ( foo => "un"
-          bar => 2 );
-print $hash{'bar'};
-$clef = 'clef'; $hash{$clef};
-\end{verbatim}
-\end{exampleblock}
-\pause
-\vfill
-\begin{alertblock}{Attention au \$}
-\begin{verbatim}
-%hash;
-$hash{baz};
-\end{verbatim}
-\end{alertblock}
-\vfill
-\pause
-\begin{block}{keys: renvois les clefs}
-\begin{verbatim}
-keys(%hash);
-\end{verbatim}
-\end{block}
-
-\end{frame}
-
-\subsection{Les listes}
-
-\begin{frame}[fragile]
-\frametitle{Comprendre les listes}
-\begin{alertblock}{Perl aplati les listes !}
-
-Le concept est simple, mais redoutable:
-\end{alertblock}
-\pause
-
-\vfill
-\vfill
-\begin{exampleblock}{Prenons deux tableaux de trois entrées:}
-\begin{verbatim}
-@tab1 = (1, 2, 3);
-@tab2 = (4, 5, 6);
-\end{verbatim}
-\end{exampleblock}
-\vfill
-\pause
-
-\begin{exampleblock}{}
-\begin{semiverbatim}
-(\only<6>{undef, }$un\only<4->{, @reste}) = \only<5->{(}@tab1\only<5->{, @tab2)};
-\end{semiverbatim}
-\end{exampleblock}
-\begin{block}{}
-\only<3>{On copie la première entrée du tableau dans \$un}
-\only<4>{pareil, mais la fin du tableaux va dans @reste}
-\only<5>{@tab1 et @tab2 ne forme plus qu'un lors de la copie}
-\only<6>{la première entrée est ignoré (undef)}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Comprendre les listes: les hash}
-\begin{block}{}
-'\verb+=>+' est un séparateur comme la '\verb+,+', donc c'est une liste:
-\begin{verbatim}
-%hash = (un => 1, deux => 2);
-%hash = (un, 1, deux, 2);
-@tab = %hash; %hash = @tableau;
-\end{verbatim}
-\verb+@tab+ contient "un", 1\ldots
-\end{block}
-\pause
-\begin{block}{hash vers hash}
-\begin{verbatim}
-%unhash = (%hash2, %hash3);
-\end{verbatim}
-\verb+%hash+ contient 1 \verb+=>+ 2, 3 \verb+=>+ 4\ldots
-\end{block}
-\pause
-\begin{alertblock}{}
-Les clefs dupliquées sont ecrasées, la dernière gagne !
-\end{alertblock}
-\end{frame}
-
-\subsection{les variables magiques}
-
-\begin{frame}[fragile]
-\begin{block}{Elles existent dans tout programme perl.}
-Les principales à connaitre:\\
-\pause
-\vfill
-
-\begin{tabular}{ll}
-\verb+$_+&stockage par défaut\\
-\pause
-\verb+@_+&paramètres des subroutines\\
-\pause
-&\\
-\verb+@ARGV+&les arguments passés aux programmes\\
-\pause
-&\\
-\verb+$a+ et \verb+$b+&utilisé par sort\\
-\end{tabular}
-\end{block}
-\pause
-
-\vfill
-\vfill
-\begin{alertblock}{Attention à \$\_}
-\verb+$_+ permet d'écrire du code succin, mais n'augmente pas la visibilité:
-\begin{verbatim}
-$entier = int;
-\end{verbatim}
-\end{alertblock}
-\end{frame}
Index: unk/perl/variablesbis.tex
===================================================================
--- /trunk/perl/variablesbis.tex	(revision 182)
+++ 	(revision )
@@ -1,250 +1,0 @@
-% $Id$
-
-\section{Variables bis}
-
-\subsection{Références}
-
-\begin{frame}[fragile]
-\frametitle{Référence: Concept}
-\begin{block}{Quoi ça ?}
-C'est une valeur scalaire\ldots
-
-\pause
-\vfill
-qui fait référence à un scalaire, un tableau ou un hash.
-
-\pause
-\vfill
-\begin{itemize}
-\item elle contient l'adresse mémoire de l'élément pointé
-\pause
-\item plusieurs références peuvent pointer la même variable
-\pause
-\item on peut faire des tableaux de références\ldots
-\end{itemize}
-\end{block}
-\pause
-\vfill
-\begin{alertblock}{Ce n'est pas un pointeur au sens C du terme}
-\verb.$ref++;. ne donnera rien de bien !!!!
-
-On fait du perl, on ne joue pas avec les octets de la mémoire.
-\end{alertblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Créer des références}
-\begin{exampleblock}{Renvoyer la référence de}
-\verb+\+ pour renvoyer un référence:
-\begin{verbatim}
-my $ref = \$scalaire;
-my $ref = \@tableau;
-my $ref = \%hash;
-\end{verbatim}
-\end{exampleblock}
-\vfill
-\pause
-
-\begin{block}{Créer une référence:}
-\begin{tabular}{|l|c|}
-\hline
-Type de variable&code\\
-\hline
-\hline
-tableau&\verb+[ 'val1', 'val2' ]+\\
-\hline
-hash&\verb+{ key => val }+\\
-\hline
-\end{tabular}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Utiliser les références}
-
-\begin{exampleblock}{prenons une référence}
-\begin{verbatim}
-$ref = { key => 'val' }; print $ref;
-HASH(0x8bca880)
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\begin{block}{Accès aux variable}
-\center
-\begin{tabular}{|l|c|c|}
-\hline
-type&variables&éléments de\\
-\hline
-\hline
-scalaire&\verb+$$var+&\\
-\hline
-tableau&\verb+@{$ref}+&\verb+$ref->[0]+\\
-\hline
-hash&\verb+%{$ref}+&\verb+$ref->{'key'}+\\
-\hline
-\end{tabular}
-\end{block}
-\pause
-
-\begin{exampleblock}{}
-\begin{verbatim}
-foreach my $key (keys %$ref) {
-    print "$ref->{$key}\n";
-}
-\end{verbatim}
-\end{exampleblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Pourquoi les références ?}
-\begin{alertblock}{Perl aplati les listes, remember ?}
-
-\pause
-\begin{verbatim}
-my @tab1 = (1,2); my @tab2 = (3,4);
-my @tab = (@tab1, @tab2);
-\end{verbatim}
-\verb+@tab+ contient 4 éléments...
-\end{alertblock}
-\pause
-
-\begin{block}{par contre:}
-\begin{verbatim}
-my @tab1 = (1,2); my @tab2 = (3,4);
-my @tab = (\@tab1, \@tab2);
-\end{verbatim}
-\verb+@tab+ contient 2 éléments qui réferencent des tableaux.
-\end{block}
-\pause
-
-\begin{block}{On accède aux valeurs:}
-\begin{verbatim}
-$tab[0]->[0];
-$tab[0][0];
-\end{verbatim}
-\end{block}
-
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Références: les pièges}
-\begin{alertblock}{Déférencer un undef:}
-\begin{verbatim}
-perl -we 'my $ref; print @{ $ref }'
-Use of uninitialized value $ref in 
-array dereference at -e line 1.
-\end{verbatim}
-\end{alertblock}
-\pause
-\vfill
-\begin{alertblock}{Attention au type de variable référencée:}
-\begin{verbatim}
-perl -we 'my $ref = {}; print @{ $ref }'
-Not an ARRAY reference at -e line 1.
-\end{verbatim}
-\end{alertblock}
-\pause
-\vfill
-\begin{alertblock}{Attention au structure complexes:}
-\begin{verbatim}
-$ref->[0][2]{daleks}[0]{episode}
-    {$ennemi}{histoire}[0];
-\end{verbatim}
-\end{alertblock}
-\end{frame}
-
-\subsection{les descripteurs de fichier}
-
-\begin{frame}[fragile]
-\frametitle{Fichiers: Version simple}
-\begin{exampleblock}{Ouvrir un fichier en lecture:}
-\begin{verbatim}
-open(my $handle, '<', 'fichier');
-\end{verbatim}
-\end{exampleblock}
-\pause
-\begin{exampleblock}{Lire une ligne:}
-\begin{verbatim}
-my $line = <$handle>;
-chomp($line); # strip cariage return
-\end{verbatim}
-\end{exampleblock}
-\pause
-\begin{exampleblock}{Fermer le fichier:}
-\begin{verbatim}
-close($handle);
-\end{verbatim}
-\end{exampleblock}
-\pause
-\vfill
-\begin{alertblock}{Ancienne méthode (perl < 5.6)}
-\begin{verbatim}
-open(HANDLE, '<', 'fichier');
-my $line = <HANDLE>;
-close(HANDLE);
-\end{verbatim}
-\end{alertblock}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Fichier: version simple (suite)}
-
-\begin{exampleblock}{Ecrire}
-\begin{verbatim}
-open(my $handle, '>', 'fichier');
-print $handle "Exterminate !\n";
-close($handle);
-\end{verbatim}
-\end{exampleblock}
-\pause
-
-\begin{alertblock}{Attention à print}
-pas de \verb+,+ après le file handle
-\end{alertblock}
-
-\pause
-\vfill
-\begin{block}{File handle par défaut}
-\begin{itemize}
-\item \verb+STDERR+ (sortie d'erreur)
-\item \verb+STDOUT+ (sortie standard)
-\item \verb+STDIN+ (entrée standard)
-\end{itemize}
-\end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-\frametitle{Fichiers: Version compliquée}
-\begin{block}{haut niveau}
-\begin{itemize}
-\item open()/close()
-\item read()/print()
-\end{itemize}
-\end{block}
-
-\pause
-\vfill
-\begin{block}{bas niveau}
-\begin{itemize}
-\item sysopen()/sysclose()
-\item sysread()/syswrite()
-\end{itemize}
-\end{block}
-
-\pause
-\vfill
-\begin{block}{Glob !}
-Pour info, un filehandle est une variable de type \textbf{GLOB}.
-\end{block}
-
-\pause
-\vfill
-\begin{block}{Si vraiment vous voulez en savoir plus: man}
-\begin{itemize}
-\item perlfunc
-\item perlopentut
-\end{itemize}
-\end{block}
-\end{frame}
-
