Chapitre 36 : CGI et Introduction au langage PERL

36.1 - Introduction

La section Les formulaires expliquait comment écrire la partie cliente des procédures CGI (Gateway Common Interface) dans vos pages Web, c'est-à-dire comment mettre des menus déroulants, des boutons radio dans votre page html. Cette section vous explicite comment mettre en place ces informations sur le serveur. Le langage le plus adapté pour mettre en place les procédures CGI est le langage PERL (Practical Extraction and Report Language), écrit par Larry Wall.

Il vous permettra même de bénéficier sur votre Macintosh ou votre PC d'un langage aussi puissant que les ShellScripts d'Unix. Perl a connu quelques critiques en 1995-1996 comme tout l'univers des CGI car le langage JAVA tenait le haut de l'affiche.

Mais aujourd'hui :

ont rendu à ce langage ses lettres de noblesse bien méritées.

Il existe plusieurs versions de langage PERL, celle qui est explicitée ici est la version Perl 5.004 qui existe en environnement UNIX, PC et Macintosh.

De bons manuels de langage PERL existent sur Internet, si vous désirez apprendre ce langage, et ce en langue anglaise. Des interpréteurs PERL sont également disponibles sur Internet. Le tout a l'avantage d'être gratuit.

Tout ce que vous désirez connaître sur le langage PERL se trouve sur la page Yahoo [www.yahoo.com/Computers_and_Internet/Programming_Languages/Perl/]

Mais c'est surtout un répertoire appelé CPAN (Comprehensive Perl Archive Network)  qui regroupe l'ensemble des ressources relatives au langage PERL. On y trouve les documents, les sources, les librairies officielles relatives au langage.

Les CPAN possèdent de nombreux sites miroirs et le site principal est www.CPAN.org

Il existe une news sur le langage PERL : comp.lang.perl.misc [news:comp.lang.perl.misc]
Désormais un groupe français existe  : fr.comp.lang.perl

Attention!comp.lang.perl existe aussi, mais est obsolète.
Enfin les FAQ et autres documentations sont disponibles à l'adresse www.perl.com/perl

Attention!Pour les utilisateurs de PC, il est bon de savoir que les archives Perl sont au format tar.gzip, pour lire ce format il est conseillé de posséder une version de winzip récente.

Pour fixer les idées nous allons maintenant écrire une procédure CGI très simple qui va servir de base à la suite de l'exposé. Cette procédure CGI sera lancée sur le serveur http après la soumission d'une balise FORM par un utilisateur connecté.
Voici le code html de cette FORM :

<html>
<head>
<title>Voici un exemple</title>
</head>
<body>
<form method="POST" action="http://nom_du_serveur/cgi-bin/procedure.pl">
Entrez votre nom <input name="Nom">
Entrez le nom d'une personne que vous aimez <input name="Nom2">
<input type="submit" value="Valider"><BR>
<input type="reset" value="Remettre a zéro">
</form>
</body>
</html>

Qui donnera ceci :


 
 

Entrez votre nom 

Entrez le nom d'une personne que vous aimez 



 
 

Voyons comment est élaboré le logiciel interprétant ces informations sur le serveur. Ce programme comme nous le voyons dans la ligne POST s'appelle procedure.pl.

Ce programme est un programme en PERL, mais la traduction en C ou autre serait  assez triviale.

Nous allons construire un programme qui va renvoyer un fichier HTML construit dynamiquement à partir des données reçues.

La première ligne de ce programme en PERL est sur un système UNIX :

#!/bin/perl
Elle donne le chemin de l'interpréteur PERL qui se trouve dans l'exemple cité dans le répertoire bin.

Si le programme doit être exécuté de façon indépendante, cette ligne de commentaire peut être conservée sous PC Windows pour assurer la compatibilité avec le système UNIX, sachant qu'elle sera sans effet sous Windows.

Par contre, en mode CGI il faut la garder car certains serveurs commes Apache sous Windows interpretent cette ligne pour connaitre le programme qu'ils doivent lancer.

Les autres serveurs HTTP sous Windows se contentent de lancer la commande associée avec les fichiers d'extension pl.

Sur Unix elle indique à l'interpréteur de commandes que votre programme est interprété en PERL et non plus par les interpréteurs de commande shell, C Shell ou Bourne shell de votre système UNIX.

Bien qu'il soit possible d'analyser les différents champs de façon manuelle en PERL, nous allons utiliser un module qui permet de masquer cette tâche. Il existe plusieurs modules ou plusieurs librairies permettant de gérer cette interface, nous citerons les deux plus connus :

Nous appuierons la suite de notre exposé sur cette librairie que nous explorerons dans une autre chapitre. Le module CGI.pm se trouve dans les librairies CPAN de l'institut Pasteur [ftp://ftp.pasteur.fr/pub/Perl/CPAN], il est encore sous Author/Stein s'il n'est pas contenu dans votre version  de PERL 5.

Ce paquetage s'installe sous /usr/local/lib/perl5 sous UNIX. Sur Windows NT ou Windows 95, il faut installer manuellement les fichiers CGI.pm dans c:/perl/lib/ et Carp.pm dans le sous répertoire CGI de c:/perl/lib. Bien sûr, c:/perl/lib peut avoir un nom légèrement différent en fonction de votre installation.

Nous continuerons notre programme PERL par la ligne : 

use CGI ; 
$html = new CGI ;
Certaines syntaxes peuvent différer  et cela est explicité dans  de futurs chapitres, mais dans tous les cas   l'utilisation de la variable $html va nous permettre d'utiliser bon nombre de propriétés comme nous l'allons voir plus loin.

Maintenant, nous devons écrire une ligne indiquant le type MIME  du fichier que nous nous proposons de renvoyer vers le navigateur.

Ce type est spécifié par la chaîne de caractères

Content-type: text/html\n\n

Mais le module CGI.pm nous permet de nous affranchir de cette syntaxe par utilisation de l'instruction :

print $html->header ;

La commande print est la fonction qui permet l'affichage sur la sortie standard de toute chaîne de caractères.

Nous nous souvenons que la  première variable du formulaire était nom.

Ainsi pour imprimer la valeur de cette  variable avec un texte devant on peut utiliser la commande suivante : 

print "<HTML><HEAD></HEAD><BODY>mon nom est ", $html->param('nom') , "<P></BODY></HTML>\n" ;
Le point virgule est obligatoire pour séparer chaque instruction. Cela revient à dire, que chaque ligne doit être achevée par un point virgule, mis à part la dernière. En pratique, on termine même la dernière par un point virgule.

Nous verrons dans le chapitre consacré aux modules que cette écriture peut encore être simplifiée, mais pour l'instant, il nous faut étudier le langage PERL.

Les fichiers

Maintenant que vous savez afficher les variables entrées par un utilisateur, la chose la plus intéressante est de les sauvegarder dans un fichier, voyons comment cela se fait :

Il faut utiliser la commande open pour ouvrir le fichier. Cette commande a la forme suivante : 

open(FILEHANDLE,">>nomdufichier");
Bien sûr FILEHANDLE peut être remplacé par un nom de descripteur de votre choix comme par exemple F1, fic ou FICHIER.
Le symbole >> indique que le fichier va recevoir les nouvelles informations après son dernier enregistrement. Le nom FILEHANDLE est un nom de descripteur de fichier et sera différent pour chaque nom de fichier.

Pour créer un nouveau fichier ou écrire au début d'un fichier existant, (en le vidant au passage) on utilise le symbole >.

Ensuite vous pouvez remplir le fichier avec vos variables :

print FILEHANDLE "Nom: ",$html->param('nom'),"\n";
print FILEHANDLE "\n";
print FILEHANDLE  "--------------------------------------------------\n";

Ensuite il ne faut pas oublier de fermer le fichier :

close FILEHANDLE;

L'existence d'un fichier se teste par la commande -e "nomdufichier".

L'ouverture d'un fichier en lecture, se fait par la commande : 

open(FILEHANDLE,"<nomdefichier");
Attention!En Perl même sous Dos, les noms de répertoires sont donnés avec les caractères / et non pas avec les caractères \.

 Pour lire le contenu d'un fichier, le langage PERL utilise une syntaxe originale et puissante :

 @lignes = <FILEHANDLE>;

Cette commande permet de ranger dans un tableau lignes chacune des lignes de FILEHANDLE
Ainsi $ligne[0] sera la première ligne, $ligne[1] sera la deuxième etc...

Un tableau est représenté par les syntaxes suivantes: 

@tableau # désigne le tableau
$tableau[0]     # Est le premier élément du tableau.
Pour remplir un tableau avec le contenu d'un fichier il suffit de taper la commande @tableau = <FILEHANDLE>

Ceci est l'une des premières richesses du PERL.

Pour lire la chaîne de caractères $nom depuis une entrée clavier, la commande suivante est suffisante : 

$nom=<INPUT> ;
De même, si vous utilisez une syntaxe de la forme $ligne=<FILEHANDLE>, vous lirez une seule ligne dans le fichier, c'est le type d'élément qui informe si on lit l'ensemble du fichier (tableau) ou une ligne (variable)
Il est également possible d'utiliser les expressions suivantes pour ouvrir le fichier d'entrée standard, ou pour le fichier de
sortie standard comme ceci : 
open(ENTREE, '-');  #Entrée standard      
open(SORTIE, '>-');  #Sortie standard

Autres éléments du langage

Nous allons maintenant faire quelques vérifications sur les valeurs entrées par les utilisateurs de notre exemple précédent.

Nous allons vérifier que les noms entrés ne sont pas vides et si l'entrée est vide, renvoyer un message.

 if ($in{'nom'} eq "") {
  # Nous avons ici une chaîne vide :
  # on quitte
  exit;
  }

Le test d'égalité entre des chaînes de caractères est eq. Entre les nombres c'est ==.

Le test d'inégalité entre des chaînes de caractères est ne. Entre les nombres c'est !=.

La condition de test est :

 if (..) {action ;}

On aurait pu tester les deux variables d'un seul tenant par les lignes : 

if (($in{'nom'} eq "") || ($in{'nom2'} eq "")) {
  #   exit;
  }
La conjonction ou est matérialisée par le symbole | | en perl.

Nous avons parlé de la condition if, on peut la compléter par une condition else sous la forme : 

if (condition )  {
  action1;  
   }  
else {
action2; 
}
Comme dans d'autres langages le mot elsif est la contraction des mots clés else et if, permettant dans les cas de tests imbriqués d'étendre la syntaxe à :
 
 

if ( ) { }
elsif () {}
elsif () {}
else {}

La condition while permet de répéter une action par la syntaxe :

while (condition) {
  action ;
  }

La condition foreach permet de répéter une action sur tous les éléments d'une liste :

foreach  (@liste) {
  action ;

  }

Une autre syntaxe est souvent utilisée dans le langage :
 { action } unless (condition) ;

 

Les étiquettes sont un élément non négligeable du langage puisque elles permettent des branchements à l'intérieur d'une instruction répétitive. Par exemple,

    etiquette: while (expression) {}
  etiquette: while (expression) {} continue {}
  etiquette: for (expression de départ; condition d'arrêt; incrément ) {}
  etiquette: foreach  (liste) {}
  etiquette: {} continue {}

sont des déclarations qui permettent l'utilisation le branchement sur une étiquette par l'utilisation des mots clés suivants :

Par exemple la séquence suivante permet de sauter les lignes commentaires d'un fichier :

ligne: while (<F1>) {

           next ligne if /^#/;
             ...
         }

Le langage PERL permet de faire des opérations sur les chaînes de caractères comme la substitution d'une chaîne par une autre. Ceci se fait par la ligne : 

$ligne =~ s/ancien/nouveau/
Pour répéter la substitution sur l'ensemble des lignes il suffit d 'appliquer la syntaxe suivante : 
$ligne =~ s/ancien/nouveau/g
La destruction d'un ou plusieurs fichiers se fait par la syntaxe 
unlink(liste de fichiers);
La directive location permet de renvoyer un URL 
print "Location: http://www.adresse\n";

36.2 - Référence

Les mots du langage

Le langage Perl est composés d'instructions comme tout langage, plusieurs instructions peuvent être regroupées en blocs entourés des symboles { et }.

A la différence d'autres langages Perl oblige la création d'un bloc après les instruction comme par exemple if . Ainsi, par exemple, le modèle suivant sera valide : 

if ( condition )
{
instruction1;
instruction2
}
En cas d'emploi d'une seule instruction, les accolades sont tout de même nécessaires, comme nous le mentionnions précédemment.
Le point virgule n'est pas nécessaire en fin de dernière instruction puisqu'il n'y a pas lieu de séparer deux instructions. Cependant, on le laisse généralement.

Les commentaires sont placés n'importe où dans le corps d'un programme, ils commencent par l'instruction #. Nous verrons que dans certaines instructions, l'emploi d'un # n'entraîne pas un commentaire, par exemple "la chaine # toto" contient le caractère # qui n'est pas ici pris comme une marque de début de commentaire.

Il n'existe pas d'instruction pour mettre plusieurs lignes de commentaires, il est donc nécessaire de commencer chacune de ces lignes par le caractère #.

Les chaînes de caractères

Le langage PERL étant un langage de manipulation de chaînes de caractères, il est naturel que les instructions rendent cette manipulation aisée.

Une chaîne de caractères se déclare par l'une des instruction suivantes : 

$premiere="ceci est une chaîne" ;
$deuxième='ceci est une autre chaîne' ;
En première approximation ces deux chaînes sont identiques, mais l'utilisation des caractères ' ou " permettent de demander l'interprétation des caractères. Ainsi, le deuxième exemple est très différent : 
$premiere="ceci est une $belle chaîne" ;
$deuxième='ceci est une $belle chaîne' ;
Supposons que la variable $belle soit égale à 9, la variable $premiere vaut "ceci est une 9 chaîne", alors que la variable $deuxieme vaut "ceci est une $belle chaîne".

La concaténation de chaînes de caractères peut se faire de plusieurs façons :

Une instruction originale est x elle permet la prolifération d'une sous chaîne : 
$chaine="*"x10 ;
$chaine vaudra "**********"; par contre l'instruction $chaine=2x"*" ; ne donnera rien.

De plus les opérateurs suivants peuvent être utilisés : 

$chaine1=$chaine2 # assignation de la chaîne 2 à la chaîne 1
$chaine.=$chaine2 # permet la concaténation de plusieurs chaînes

Type de données en PERL

Les scalaires

Une variable qui est identifiée par le symbole $ (par exemple $chaine) est un scalaire (entier, entier flottant ou chaîne de caractères).

Pour assigner une valeur à une variable il suffit de faire $variable=valeur; y compris pour les chaînes de caractères. Une variable non initialisée prend la valeur 0, ou la chaîne vide dans le cas des chaînes de caractères.

En outre, les variables $premier, $Premier et $PREMIER sont toutes différentes, puisque le langage est sensible aux majuscules et minuscules.

Ainsi l'affectation $chaine="ok"; affecte la valeur "ok" à la variable $chaine.

Pour affecter à la variable $toto la valeur entière 5, il suffit de faire : $toto=5;

L'affectation de la chaîne "ok" à la variable toto se fait par : $toto="ok";

Une chose très puissante en PERL réside dans la conversion automatique des types. Prenons l'exemple suivant : 

$a="3"
$b=4
$z=$a+$b
La variable $z vaut 7.

De même la commande 

print "autre exemple $a"
imprime la chaîne autre exemple 3.

Enfin la notation des entiers suit les conventions montrées dans l'exemple ci-dessous :
 

Valeur  Définition  Commentaire 
$titi=1234  Entier  $titi vaut 1234 
$titi=1234.5  Réel  $titi vaut 1235,5 
$titi=.123E3  Exposant  $titi vaut 123 
$titi=0xff  Hexadécimal  $titi vaut 127 en décimal 
$titi=011  Octal  $titi vaut 9 en décimal 
$titi=100_000  Grand nombre  $titi vaut 100000 

Les tableaux de scalaires

Les tableaux de scalaires commencent par le symbole @ pour désigner le tableau dans son intégralité et s'initialisent par des caractères entre parenthèses.

Par exemple 

@nombres = (3,1,3,2,5);
et un élément du tableau se retrouve par le nom du tableau précédé du signe $ et suivi des caractères [ et ]. Le premier élément est indexé par le chiffre 0.

Ainsi on peut dire à partir de l'exemple précédent que $nombres[0] est égal à 3.
 

 Il existe un particularisme qui trouble parfois les novices, mais qui n'est pas pénalisant car non obligatoire au bon usage du langage : 

@toto=(1,2,4) ; # est l'affectation du tableau @toto $toto[0] vaut ici 1 
$toto=(1,2,4) ; # $toto n'est pas un tableau mais une variable qui vaut 4 (la dernière valeur) 
$toto=@toto ;   # $toto vaut ici 3 car la syntaxe dans ce cas donne la  taille du tableau ! 
$toto="@toto" ; #toto vaut "1 2 4"
Notons que les tableaux se concatènent de façon triviale par des opérations du type :
@toto=(@titi,1,4,@tutu) ;
Notons aussi que la déclaration suivante est parfaitement valable :
@toto=(
1,
2,
4) ;   # équivalent à @toto =(1,2,4) ;
Pour ajouter un élément à un tableau, il est également possible d'utiliser la fonction push qui évite tout recopie en mémoire du tableau avec la syntaxe suivante : 
push(@toto,5);
Pour enlever le dernier élément d'un tableau, on utilise la fonction pop avec la syntaxe suivante : 
$valeurretournee=pop(@toto) ;
Enfin, et c'est important, le dernier indice du tableau toto est $#toto. Ceci permet de dire que le nombre d'éléments d'un tableau est $#toto+1

Les tableaux associatifs de scalaires

Ces tableaux sont identifiés par le caractère % ils sont indexés non pas par des entiers mais par des clés. Par exemple le tableau suivant : 
%tableau=("Gilles",23,"Pierre", 3312)
;
permettra d'accéder à la valeur 23 par $tableau{Gilles}.

En général ce type de tableau se déclare de la façon suivante : 

$tableau{"Gilles"} = "Oui" ;
$tableau{"Pierre"} = "Non" ;
Il est intéressant de constater que si un tableau associatif est nommé %valeurs, la variable $valeur est parfaitement définissable, et n'a rien à voir avec son homologue. Le tableau %SIG représente tous les signaux sous UNIX.

Le tableau %INC contient toutes les bibliothèques.

Un tableau très important en PERL est le tableau %ENV qui contient toutes les variables d'environnement. Ainsi on retrouve la variable PATH par %ENV{PATH} .

Pour connaître la liste de vos variables d'environnement il suffit de taper la commande : 

print %ENV ;
Si vous désirez que ces lignes soit un peu mieux présentées, la ligne suivante présentera le résultat avec des bullets : 
foreach   ( keys (%ENV))
#la procedure keys donne tous les indices du tableau associatif %ENV
{
 print "<LI><B>$_ </B> :<BR> $ENV{$_}\n" ;
  #On imprime simplement chaque nom de variable d'environnement et # 
  sa valeur.
}
print "</UL>";

Opérateurs

Tous les opérateurs du langage C sont valides: En plus de ces opérateurs on trouve les opérateurs

Des caractères très particuliers

La cotation en PERL comme dans tous les langages est un élément à bien maîtriser puisqu'on le rencontre souvent et que sa connaissance permet des astuces importantes comme nous allons le voir :
print 'cette $ligne sera interprétée\n comme ceci\n' ;
provoquera l'impression de la ligne :
 cette $ligne sera interprétée\n comme ceci\n
  
print "cette $ligne sera interprétée\n comme ceci\n" ;
provoquera l'impression de la ligne (sachant que $ligne="dir": )
 cette ..... sera interprétée
comme ceci
 
En outre dans une chaîne de caractères les valeurs suivantes sont interprétées comme le montre le tableau suivant :
6
Symbole  Interprétation  Exemple  Résultat 
\t  tabulation  print"1\t2";  
1        2
\n  nouvelle ligne  print"1\n2";  
1
2
\r  retour ligne  print"1\r2";  
1
             2
\f  form feed  print"1\f2";  
non affichable
\v  tabulation verticale  print"1\v2";  
non affichable
\b  retour arrière  print"1\b2";  
non affichable
\a  beep  print"1\a2";  
non affichable
\e  escape  print"1\e2";  
non affichable
\0dd  caractère octal  print"1\0762";  
1>2
\xdd  caractère héxadécimal  print"1\x3a2";  
1:2
\cx  caractère de contrôle  print"1\c[2";  
non affichable
\l  force le caractère suivant en minuscule  print"\lUNGI\n";  
uNGI
\u  force le caractère suivant en majuscule  print"\lungi\n";  
Ungi
\L  force la suite en minuscules jusqu'au caractère \E  print"\LUNG\EI\n";  
ungI
\U  force la suite en majuscule jusqu'aux caractères \E  print"\Uung\Ei\n";  
UNGi
\Q  force la suite jusqu'à \E à être interprétée en expression régulière  print"\Q.*\E\n";  
UNGi
\E  marque de fin de minuscule/majuscule/quote  print"\Uung\Ei\n";  
UNGi
\\  empêche l'anlyse de \  print"\\ungi\n";  
\ungi

Procédures

Les procédures sont appelées subroutines .

Leur déclaration est de la forme : 

sub NOM {
...
} ;
Leur appel se fait par l'une des syntaxes équivalentes : 
do NOM() ;
&NOM ;
&NOM () ;
Elles peuvent être appelées récursivement et les passages d'argument peuvent se faire par référence en utilisant le symbole * comme dans le langage C avec la syntaxe suivante: 
sub proc 
{ 
local ( *variable ) = @_[0] ;
$variable=3 ;
}
Et l'appel se fait par :
 &proc (*nom) ;
au lieu de
 &proc ($nom) ;

Les expressions rationnelles ou régulières

Présentation

Les expressions rationnelles en PERL peuvent être utilisées dans les critères de certains moteurs de recherche. Elles sont donc à connaître, même si elle peuvent paraître complexes.
Les exemples aideront le lecteur à en comprendre les subtilités. s/config./ trouve les  les chaînes config1, config2, configuration etc mais pas les chaînes finies par config s/^FILE/ ne reverra que les lignes commençant par FILE s/conf$/ renverra les lignes se terminant par conf
s/\.conf$/ renverra les lignes se terminant par .conf Les classes de caractères contiennent les caractères qui peuvent être contenus dans l'expression. Le caractère - entre deux valeurs, autorise toutes les valeurs comprises  entre ces deux valeurs, le caractère ^ interdit le ou les caractères suivants.  Les expressions régulières ne sont bien sûr par autorisées à l'intérieur des crochets [ et ].

Ainsi

[abc]         # a b ou c sont autorisés
[^abc]       # ni a, ni b ni c ne sont autorisés
[a-z]           # toutes les lettres minuscules de  a à z
[^a-z]         # pas de lettre minuscule
[a-zA-Z]   # pas de lettres ni minuscules ni majuscules
[a-z]+          # toute suite de lettres Nous pouvons ainsi analyser l'exemple suivant :

s/AUTOEXEC\.BA[TK]/  # permet de trouver le nom AUTOEXEC.BAT ou AUTOEXEC.BAK

Exemples 

    2.  if (/Time: (..):(..):(..)/) { $heure = $1; $minute = $2; $seconde = $3;}
    permet d'utiliser $1, $2 et $3 comme résultat de (..) (..) (..) sachant que .. signifie deux caractères.
s/^([^ ]*) *([^ ]*)/$2 $1/;
permet de permuter deux mots : ([^ ]*) séparés par un ou plusieurs blancs : *)
$chaine=~ s/(\W)/;$1/g;
permet d'insérer un ; après chaque mot trouvé par (\W) Pour insérer le symbole \ après chaque mot on utilisera la même syntaxe en cotant le symbole \
$chaine=~ s/(\W)/\\$1/g;
 

Extensions

Les conventions précédentes seraient très simples si on ne pouvait les combiner à loisir comme le montre les exemples suivants :
On le comprend certaines d'entre elles sont des plus utilisées.

Des variables particulières

Certaines variables sont très usuelles en PERL, il faut convenir que ces noms de variables ne sont pas très mnémotechniques mais comme vous le verrons dans les évolutions PERL 5, elles ont toutes des correspondances en noms étendus.

Précédences

Les priorités des opérateurs PERL sont donnés dans l'ordre de priorité croissante:

Les arguments de l'interpréteur Perl

Définitions

Les options de l'interpréteur PERL permettent un certain nombre de paramétrages qu'il est bon de connaître.
 Les arguments peuvent être combinés et placés en argument de la commande perl (perl -s file.pl) ou dans la première ligne du programme (#!/usr/bin/perl -s)

 Voici la liste des options :

Exemples

Debug en PERL

Pour invoquer l'interpréteur PERL en mode debug (et bénéficier des commandes suivantes), il faut l'appeler avec l'option -d.

36.3 - Le langage PERL sur différentes plates-formes

Sous UNIX

Sous UNIX le fichier PERL sera rendu exécutable par la commande chmod +x nom du fichier. La première ligne du programme est #!/bin/perl. Cette ligne indique que le l'interpréteur de commande est le langage PERL, et le chemin d'accès de l'interpréteur peut évidemment varier d'une installation à l'autre.

Le chemin des librairies est renseigné par la variable d'environnement PERLIB.

Sur PC

Sur PC Windows, vous devez installer PERL 5.004 pour Windows 32 bits.

Vous aurez besoin d'un éditeur de texte sous Windows et le choix peut être celui que l'on doit à un Français, Patrick Philippot et c'est e!.

 Cet éditeur permet :

Ces fonctions sont disponibles depuis la version 2.05 et activables par le fichier prl.hdf livré avec celle-ci. Pour activer la fonction, il suffit d'activer dans le menu file l'item associate et de spécifier en regard de l'extension pl le champs hilite filename à prl.

WindowsCharger e!

Cet éditeur shareware à bas prix permet de bénéficier d'un environnement de programmation équivalent à ceux que l'on trouve pour les autres langages.

Pour installer Perl sur PC :

  1. Charger Perl
  2. L'installer en suivant les instructions, le mieux est de l'installer dans le répertoire c:\perl. Demandez l'installation de la documentation en HTML
  3. Installer un serveur HTTP, par exemple WebSite, Apache, OmniHTTP
  4. Dans le fichier autoexec.bat mettre la ligne :

    5. set PATH=%PATH%;c:\perl\bin
  5. Dans la configuration du serveur http indiquer que le chemin de l'interpréteur Perl : c:\perl\bin\perl.exe
    1. dans OmniHTTP (cela se trouve dans l'onglet Advanced/Perl command line)
    2. dans Apache pour Windows les fichiers perl doivent commencer par la ligne #!c:\perl\bin\perl.exe
    3. dans WebSite en fonction des versions il faut lier dans l'explorateur de Windows le type de fichier pl avec l'interpréteur.
  6. Pour travailler à la fabrication des fichiers HTML le mieux est d'installer l'éditeur de texte e!. Pour le configurer il suffit de faire les opérations suivantes :
    1. dans le menu fichier de l'éditeur (et pas dans la fenêtre centre de contrôle) cliquer sur Associate puis dans la case FileName Extension mettre pl, dans la case Hilite Filename mettre prl
    2. Une fois un fichier d'extension perl chargé, aller dans le menu compile. En regard des cases :
      1. file extension => pl
      2. Compile command => perl &&
      3. Make command => pod2html --infile=&& (ceci pour générer les documentations au format POD)
      4. Debug command => perl -d &&
      5. Ne pas oublier de cliquer sur modify puis sur sauver
    3. Pour sauvergarder les fichiers Perl en mode Unix ce qui marche très bien sur Windows et qui est optionnel, aller à local/set  et cliquer sur End Of Line à LF
  7. Pour installer des modules comme CGI.pm après les avoir chargé sous la de fichier module.pm.tgz sur un serveur ftp CPAN, puis
    1. le décompresser par Winzip
    2. dans le répertoire temp ou tmp dans le quel on l'a chargé faire sous une fenêtre dos
      1. perl Makefile.PL
      2. nmake test
      3. nmake install
  • Le reste est affaire d'habitude


    • Il est à noter que l'environnement Perl Builder ,s'il vaut 120 US$, est téléchargeable à l'adresse http://www.solutionsoft.com
    Cet environnement est assez convivial à utiliser.

    Enfin sous Linux l'éditeur Kwrite permet la colorisation syntaxique en Perl  et permet de coder de façon aisée.
     
     

    Haut Haut Suivant Sommaire Recherche Glossaire Nouveau Bientôt Courrier Souscription Aide Copyright