=encoding iso-8859-1 =head1 NOM perlvar - Variables prédéfinies en Perl =head1 DESCRIPTION =head2 Noms Prédéfinis Les noms suivants ont une signification spéciale en Perl. La plupart des noms ont un mnémonique acceptable, ou équivalent dans un des shells. Néanmoins si vous souhaitez utiliser des descripteurs longs vous avez juste à utiliser use English; en entête de programme. Cela créera un alias entre les noms courts et les noms longs du module courant. Certains ont même des noms intermédiaires, généralement empruntés au B. Pour aller encore plus loin, toute variable dépendant du descripteur de fichier courant peuvent (et devraient) être initialisées en appelant une méthode de l'objet FileHandle. (Les quelques références ci-dessous contiennent le mot HANDLE). D'abord vous devez écrire : use FileHandle; après quoi vous pouvez utiliser soit method HANDLE EXPR soit, de manière plus sûre HANDLE->method(EXPR) Chacune de ces méthodes retourne l'ancienne valeur de l'attribut FileHandle. Les méthodes acceptent chacune EXPR en option, qui s'il est précisé, spécifie la nouvelle valeur pour l'attribut FileHandle en question. S'il n'est pas précisé, la plupart des méthodes ne modifie pas la valeur courante, excepté pour autoflush(), qui fixera la valeur à 1, juste pour être différente. Quelques-unes de ces variables sont considérées en "lecture seule". Cela signifie que si vous essayez de leur attribuer une valeur, directement ou indirectement au travers d'une référence, vous obtiendrez une erreur d'exécution. La liste suivante est organisée avec les variables scalaires en premier, puis les tableaux, et enfin les tableaux associatifs (excepté $^M qui a été ajouté au mauvais endroit). Ceci est un peu brouillé par le fait que %ENV et %SIG sont listés comme $ENV{expr} et $SIG{expr}. =over 8 =item $ARG =item $_ La variable de stockage par défaut et l'espace de recherche de motif. Les paires suivantes sont équivalentes : while (<>) {...} # équivalent seulement dans while! while (defined($_ = <>)) {...} /^Subject:/ $_ =~ /^Subject:/ tr/a-z/A-Z/ $_ =~ tr/a-z/A-Z/ chop chop($_) Voici les endroits où le Perl utilisera $_ même si vous ne le précisez pas : =over 3 =item * Diverses fonctions, notamment les fonctions comme ord() et int(), ainsi que tous les tests sur les fichiers (C<-f>, C<-d>) à l'exception de C<-t>, qui utilise par défaut STDIN. =item * Diverses fonctions de liste comme print() et unlink(). =item * Les opérations de recherche C, C, et C quand elles n'utilisent pas l'opérateur C<=~>. =item * La variable d'itération par défaut dans une boucle C si aucune autre variable n'est précisée. =item * La variable implicite d'itération dans les fonctions grep() et map(). =item * La variable par défaut où est stocké un enregistrement quand le résultat de CFHE> s'auto-teste et représente le critère unique d'un C. Attention : en dehors d'un test C cela n'arrive pas. =back (Moyen mnémonique: Sous-ligné est sous-entendu dans certaines opérations.) =back =over 8 =item $EIE Contient le sous-motif inclus dans les parenthèses correspondantes du dernier motif trouvé, sans prendre en compte les motifs trouvés dans les sous-blocs dont on est déjà sortis.(Mnémonique : comme \digits.) Ces variables sont en lecture seule. =item $MATCH =item $& La chaîne de caractères trouvée par la dernière recherche de motif réussie (sans prendre en compte les motifs cachés dans un BLOCK ou par un eval() inclus dans le BLOCK courant). (Mnémonique : comme & dans certains éditeurs.) Variable en lecture seule. =item $PREMATCH =item $` La chaîne de caractère précédant tout ce qui a été trouvé au cours de la dernière recherche de motif réussie (sans compter les correspondances cachées dans un BLOCK ou un eval() dans le BLOCK courant). (Mnémonique : C<`> précède souvent une chaîne de caractère entre guillemets). Variable en lecture seule. =item $POSTMATCH =item $' La chaîne de caractère suivant tout ce qui a été trouvé au cours de la dernière recherche de motif réussie (sans compter les correspondances cachées dans un BLOCK ou un eval() dans le BLOCK courant). (Mnémonique : C<`> suit souvent une chaîne de caractère entre guillemets). Variable en lecture seule. Exemple : $_ = 'abcdefghi'; /def/; print "$`:$&:$'\n"; # affiche abc:def:ghi =item $LAST_PAREN_MATCH =item $+ La dernière valeur trouvée par une recherche de motif. Utile si vous ignorez lequel des différents motifs a donné un résultat. Exemple : /Version: (.*)|Revision: (.*)/ && ($rev = $+); (Mnémonique: Soyez positif et allez de l'avant.) Variable en lecture seule. =item $MULTILINE_MATCHING =item $* Initialisé à 1 pour rechercher dans une chaîne de caractères, multi-lignes, à 0 pour signifier au Perl que la chaîne ne contient qu'une seule ligne, afin d'optimiser la recherche. La recherche de motif sur des chaînes contenant plusieurs retour lignes peut produire des résultats étranges quand "C<$*>" est à 0. La valeur par défaut est 0. (Mnémonique : * remplace plusieurs.) Il est à noter que cette variable n'influence l'interprétation que de "C<^>" et de "C<$>". Un retour ligne peut être recherché même si C<$* == 0>. L'utilisation de "C<$*>" est obsolète dans les Perls modernes, et supplantée par les modificateurs de recherche C et C. =item input_line_number HANDLE EXPR =item $INPUT_LINE_NUMBER =item $NR =item $. Le numéro de ligne courante du dernier fichier depuis lequel vous avez lu (ou sur lequel vous avez utilisez C ou C). Une fermeture explicite d'un fichier réinitialise le numéro de ligne. Comme "CE>" ne provoque pas de fermeture explicite, le numéro de ligne augmente au travers des fichiers ARGV (voir les exemples sous eof()). Localiser C<$.> a pour effet de localiser également la notion de Perl du "dernier fichier ouvert et lu". (Mnémonique : beaucoup de programmes utilisent "." pour pointer la ligne en cours") =item input_record_separator HANDLE EXPR =item $INPUT_RECORD_SEPARATOR =item $RS =item $/ Le séparateur d'enregistrement en lecture, par défaut retour-ligne. Fonctionne comme la variable RS en B, y compris le traitement des lignes vides comme des délimiteurs si initialisé à vide. (Note : une ligne vide ne peut contenir ni espace, ni tabulation.) Vous pouvez le définir comme une chaîne de caractère pour correspondre à un délimiteur multi-caractère, ou à C pour lire jusqu'à la fin du fichier. Notez que le fixer à C<"\n\n"> est légèrement différent que le fixer à C<""> si le fichier contient plusieurs lignes vides consécutives. Le positionner à C<""> traitera deux lignes vides consécutives (ou plus) comme une seule. Le positionner à C<"\n\n"> implique que le prochain caractère lu appartient systématiquement à un nouveau paragraphe, même si c'est un retour-ligne. (Mnémonique: / est utiliser comme séparateur de ligne quand on cite la poésie.) undef $/; $_ = ; # Fichier complet depuis la position courante s/\n[ \t]+/ /g; Attention : La valeur de $/ est du texte pas une expression régulière. Il faut bien laisser quelque chose au AWK :-) Initialiser $/ avec une référence à un entier, un scalaire contenant un entier, ou un scalaire convertissable en entier va provoquer la lecture d'enregistrements au lieu de lignes, avec une taille maximum par enregistrement correspondant à l'entier en référence. Donc : $/ = \32768; # or \"32768", or \$var_contient_32768 open(FILE, $myfile); $_ = ; va lire un enregistrement d'une longueur maximale de 32768 octets depuis FILE. Si votre fichier ne contient pas d'enregistrements (ou si votre système d'exploitation ne supporte pas les fichiers d'enregistrements), vous obtiendrez probablement des valeurs incohérentes à chaque lecture. Si l'enregistrement est plus long que la taille spécifiée, il sera lu en plusieurs fois. Sur VMS, les lectures d'enregistrements sont faits avec l'équivalent de C, donc il vaut mieux éviter de mélanger les lectures en mode enregistrements et en mode lignes sur le même fichiers. (Cela ne posera sûrement pas de problème, puisque les fichiers que vous souhaiteriez lire en mode enregistrements sont probablement lisibles en mode lignes). Les systèmes non VMS effectuent des Entrées/Sorties standards, donc il est possible de mélanger les deux modes de lecture. =item autoflush HANDLE EXPR =item $OUTPUT_AUTOFLUSH =item $| Si initialisé à une valeur différente de zéro, force un actualisation immédiatement et juste après chaque lecture/écriture sur le canal de sortie sélectionné. La valeur par défaut est 0 (que la canal de sortie soit bufferisé par le système au non; C<$|> vous indique seulement si vous avez explicitement demandé au Perl d'actualiser après chaque écriture). Notez que STDOUT est typiquement bufferisé par ligne en sortie écran et par blocs autrement. Initialiser cette variable est surtout utile dans le cas d'une redirection de sortie, par exemple si vous exécutez un script Perl avec rsh et que vous voulez voir le résultat au fur et à mesure. Cela n'a aucun effet sur les buffers d'entrée. (Mnémonique : l'édition actualisée de vos redirections) =item output_field_separator HANDLE EXPR =item $OUTPUT_FIELD_SEPARATOR =item $OFS =item $, Le séparateur de champs pour l'opérateur de sortie. Normalement l'opérateur de sortie génère simplement les champs que vous avez spécifiés séparés par des virgules. Pour obtenir un comportement plus proche de B, initialisez cette variable comme vous le feriez de la variable OFS du B pour spécifier ce qui doit être imprimer entre chaque champs. (Mnémonique : Ce qui est imprimé quand vous avez une , dans vos champs) =item output_record_separator HANDLE EXPR =item $OUTPUT_RECORD_SEPARATOR =item $ORS =item $\ Le séparateur de champs pour l'opérateur de sortie. Normalement l'opérateur de sortie génère simplement les champs que vous avez spécifiés séparés par des virgules sans ajouter ni retour-ligne ni séparateur d'enregistrement. Pour obtenir un comportement plus proche de B, initialisez cette variable comme vous le feriez de la variable ORS du B pour spécifier ce qui doit être sorti en fin de traitement. (Mnémonique : positionnez "C<$\>" au lieu d'ajouter \n à la fin de chaque impression. Ou : Comme C<$/>, mais c'est ce que vous "obtenez" du Perl.) (NdT. get B = "obtenez", \ = Bslash) =item $LIST_SEPARATOR =item $" Même chose que "C<$,>", sauf que cela s'applique aux tableaux de valeurs interpolés dans une chaîne de caractères entre guillemets doubles(ou une chaîne interprétée similaire). La valeur par défaut est "espace". (Mnémonique : évident). (Ndt : pas pour moi) =item $SUBSCRIPT_SEPARATOR =item $SUBSEP =item $; Le séparateur d'indices pour l'émulation de tableaux à plusieurs dimensions. Si vous vous référez à un élément de type tableau associatif comme $foo{$a,$b,$c} Cela signifie en fait $foo{join($;, $a, $b, $c)} Mais n'utilisez pas @foo{$a,$b,$c} # Notez le @ qui signifie ($foo{$a},$foo{$b},$foo{$c}) La valeur par défaut est "\034", la même que pour le SUBSEP en B. Notez que si vos clefs contiennent des valeurs binaires il se peut qu'il n'y ait aucune valeur sûre pour "C<$^;>". (Mnémonique : la virgule (le séparateur d'indice)est un demi point-virgule. Ouais, je sais que c'est faible,mais "C<$,>" est déjà utilisé quelque chose de plus important.) Envisagez d'utiliser de "vrais" tableaux à plusieurs dimensions. =item $OFMT =item $# C'est le format de sortie des nombres. Cette variable est une pâle tentative d'émulation de la variable OFMT en B. Il y a des cas, cependant, où Perl et B ont des vues différentes sur la notion de numérique. La valeur par défaut est %.Ig, où I est la valeur de la macro DBL_DIG du F de votre système. C'est différent de la valeur par défaut de OFMT en B qui est %.6g, donc il vous faut initialiser "C<$#>" explicitement pour obtenir la valeur B. (Mnémonique : # est le signe des nombres) L'utilisation de "C<$#>" est obsolète. =item format_page_number HANDLE EXPR =item $FORMAT_PAGE_NUMBER =item $% Le numéro de la page en cours sur le canal de sortie en cours. (Mnémonique : % est le numéro de page avec B.) =item format_lines_per_page HANDLE EXPR =item $FORMAT_LINES_PER_PAGE =item $= La longueur de la page courante (en nombre de lignes imprimables) du canal de sortie en cours. Le défaut est 60. (Mnémonique : = est formé de lignes horizontales.) =item format_lines_left HANDLE EXPR =item $FORMAT_LINES_LEFT =item $- Le nombre de lignes restantes sur la page en cours du canal de sortie en cours. (Mnémonique : lignes_sur_la_page - lignes_imprimées.) =item format_name HANDLE EXPR =item $FORMAT_NAME =item $~ Le nom du format courant de rapport pour le canal de sortie sélectionné. La valeur par défaut est le nom du descripteur de fichier. (Mnémonique : frère de "C<$^>".) =item format_top_name HANDLE EXPR =item $FORMAT_TOP_NAME =item $^ Nom du format de l'en-tête de page courant pour le canal de sortie sélectionné. La valeur par défaut est le nom du descripteur de fichier suivi de _TOP. (Mnémonique : pointe vers le haut de la page.) =item format_line_break_characters HANDLE EXPR =item $FORMAT_LINE_BREAK_CHARACTERS =item $: Le jeu de caractères courants après lequel une chaîne de caractères peut être coupée pour passer à la ligne (commençant par ^) dans une sortie formatée. La valeur par défaut est S<" \n-">, pour couper sur les espaces ou les traits d'unions. (Mnémonique : en poésie un "deux-points" fait partie de la ligne.) =item format_formfeed HANDLE EXPR =item $FORMAT_FORMFEED =item $^L Ce qui est utiliser pour faire tourner la page. Défaut est "\f". =item $ACCUMULATOR =item $^A La valeur courante de la pile de la fonction write() pour formatter les lignes avec format(). Un format contient des commandes formline(), qui stockent leurs résultats dans C<$^A>. Après appel à son format, write() sort le contenu de C<$^A> et le réinitialise. Donc vous ne voyez jamais le contenu de C<$^A>, à moins que vous n'appeliez formline() vous-même, et ne regardiez le contenu. Voir L et L . =item $CHILD_ERROR =item $? Le statut retourné par la dernière fermeture d'une redirection, une commande 'anti-apostrophe' (C<``>), ou un opérateur system(). Notez que c'est le statut retourné par l'appel système wait() (ou cela lui ressemble). Le code de terminaison du sous-process est (C<$? EE 8>), et C<$? & 127> indique quel signal (s'il y a lieu) a stoppé le process, enfin C<$? & 128> indique s'il y a eu core dump. (Mnémonique : similaire à B et B.) De plus, si la variable C est supportée en C, sa valeur est retournée par $? si n'importe laquelle des fonctions C échoue. Si vous avez installé un descripteur de signal pour C, la valeur C<$?> sera la plupart du temps erronée en dehors de ce descripteur. A l'intérieur d'un sous programme C C<$?> contient la valeur qui sera passée à C. Vous pouvez modifier C<$?> dans un sous programme C pour changer le code de sortie d'un script. Sous VMS, la déclaration C fait renvoyer à C<$?> le code de sortie réel de VMS, plutôt que le code d'émulation POSIX habituel. Voir aussi L. =item $OS_ERROR =item $ERRNO =item $! Dans un contexte numérique, contient la valeur courante de errno (numéro d'erreur), avec les exceptions d'usage. (Ce qui veut dire que vous ne devez pas vous attendre à ce que la valeur de C<$!> ne soit quoi que ce soit de particulier, sauf si vous avez un retour d'erreur spécifique indiquant une erreur système). Dans un contexte textuel, contient le texte de l'erreur. Vous pouvez initialiser C<$!> pour fixer I si, par exemple, vous voulez utiliser C<"$!"> pour retourner le texte de l'erreur I, ou si vous voulez fixer la valeur de l'opérateur die(). (Mnémonique : Qu'est-ce qui a planté ?) Voir aussi L. =item $EXTENDED_OS_ERROR =item $^E Information d'erreur spécifique au système d'exploitation. Pour le moment diffère de C<$!> seulement sous VMS, OS/2 et Win32 (et MacPerl). Sur toutes les autres plateformes, C<$^E> est équivalent à C<$!>. Sous VMS, C<$^E> fournit la valeur du statut VMS de la dernière erreur système. Les informations sont plus spécifiques que celles fournit par C<$!>. Ceci est particulièrement important quand C<$!> est fixé à B. Sous OS/2, C<$^E> correspond au code d'erreur du dernier appel API soit au travers de CRT, soit depuis Perl. Sous Win32, C<$^E> retourne toujours l'information relative au dernier appel Win32 C, qui décrit le dernier code d'erreur de l'API Win32. La plupart des applications spécifiques Win32 reportent les erreurs via C<$^E>. ANSI C et UNIX positionnent C, donc les programmes Perl les plus portables utiliseront C<$!> pour remonter les messages d'erreur. Les avertissements mentionnés dans la description de C<$!> s'appliquent généralement à C<$^E>. (Mnémonique : Explication d'Erreur Additionnelle) Voir aussi L. =item $EVAL_ERROR =item $@ Le message d'erreur de syntaxe de la dernière commande eval(). Si nul, le dernier eval() s'est exécuté correctement (bien que l'opération à exécuter ait pu échouer en mode normal). (Mnémonique : "At"tention à l'erreur de syntaxe !) Attention : les messages d'avertissements ne sont pas récupérés dans cette variable. Vous pouvez toutefois construire une routine de traitement des avertissements en positionnant C<$SIG{__WARN__}> comme décrit plus loin. Voir aussi L. =item $PROCESS_ID =item $PID =item $$ Numéro du processus Perl exécutant ce script. (Mnémonique : comme en shell.) =item $REAL_USER_ID =item $UID =item $< L'uid (id utilisateur) réel du processus. (Mnémonique : l'uid d'I vous venez si vous executez setuid.) =item $EFFECTIVE_USER_ID =item $EUID =item $> L'uid effectif de ce processus. Exemple : $< = $>; # Positionne l'uid réel à la valeur de l'iud effectif ($<,$>) = ($>,$<); # Inverse les uid réel et effectif (Mnémonique : l'uid Ivers lequel vous alliez, si vous exécutez setuid.) Note : "C<$E>" et "C<$E>"peuvent être inversés seulement sur les machines supportant setreuid(). =item $REAL_GROUP_ID =item $GID =item $( Le gid (id de groupe) réel du processus. Si vous êtes sur une machine qui supporte l'appartenance simultanée à plusieurs groupes, renvoie une liste des groupes auxquels vous appartenez, séparés par des espaces. Le premier nombre retourné est le même que celui retourné par getgid(), les autres sont ceux retournés par getgroups(), avec possibilité de doublon entre l'un d'eux et le premier nombre. Toutefois une valeur assignée à "C<$(>" doit être un nombre unique utilisé pour fixer le gid réel. Donc la valeur donnée par "C<$(>" ne doit I être réassignée à "C<$(>" sans être forcée en numérique, par exemple en lui ajoutant 0. (Mnémonique : les parenthèses sont utilisées pour I les choses. Le gid réel est le groupe que vous laissez à votre I, si vous utilisez setgid.) (NdT: I = parenthèse gauche) =item $EFFECTIVE_GROUP_ID =item $EGID =item $) Le gid effectif du processus. Si vous êtes sur une machine qui supporte l'appartenance simultanée à plusieurs groupes, renvoie une liste des groupes au quels vous appartenez, séparés par des espaces. Le premier nombre retourné est le même que celui retourné par getegid(), les autres sont ceux retournés par getgroups(), avec possibilité de doublon entre l'un d'eux et le premier nombre. De la même façon, une valeur assignée à "C<$)>" doit être une liste de nombres séparés par des espaces. Le premier nombre est utilisé pour fixer le gid effectif, et les autres (si présents) sont passés à setgroups(). Pour obtenir le résultat d'une liste vide pour setgroups(), il suffit de répéter le nouveau gid effectif; c'est à dire pour forcer un gid effectif de 5 et un setgroups() vide il faut utiliser : C< $) = "5 5" >. (Mnémonique : les parenthèses sont utilisées pour I les choses. Le gid effectif est le groupe qui vous donne le bon I pour vous si vous exécutez setgid.) (NdT: I = parenthèse droite) Note : "C<$E>", "C<$E>", "C<$(>" et "C<$)>" peuvent être positionnés seulement sur les machines qui supportent les fonctions correspondantes I. "C<$(>" et "C<$)>" peuvent être inversée seulement sur les machines supportant setregid(). =item $PROGRAM_NAME =item $0 Contient le nom du fichier contenant le script Perl en cours d'exécution. Sur certains systèmes assigner une valeur à "C<$0>" modifie la zone d'argument que le programme ps(1) voit. Plus utile pour indiquer l'état courant du programme que pour cacher le programme. (Mnémonique : comme en B et B.) =item $[ L'index du premier élément dans un tableau, et du premier caractère dans une sous-chaîne de caractère. La valeur par défaut est 0, mais vous pouvez la fixer à 1 pour faire ressembler le Perl au B (ou Fortran) quand vous utilisez les index ou les fonctions index() et substr(). (Mnémonique : [ commence les index) Depuis le Perl 5, fixer la valeur de "C<$[>" est traité comme une directive de compilation et ne peut influencer le comportement des autres fichiers. Son usage est déconseillé. =item $PERL_VERSION =item $] La version + le niveau de patch / 1000 de l'interpréteur Perl. Cette variable peut être utilisée pour déterminer si l'interpréteur Perl exécutant un script est au niveau de version souhaité. (Mnémonique : Cette version du Perl est-elle accrochée droite) (Ndt : Les jeux de mots utilisés dans les mnémoniques anglais sont des plus délicats à rendre en français...) Exemple : warn "No checksumming!\n" if $] < 3.019; Voir également la documentation de C et C pour un moyen pratique d'empêcher l'exécution d'un script si l'interpréteur est trop vieux. =item $DEBUGGING =item $^D La valeur des options de débuggages. (Mnémonique : valeur de l'option B<-D>.) =item $SYSTEM_FD_MAX =item $^F Le nombre maximum de descripteurs systèmes de fichier, habituellement 2. Les descripteurs systèmes de fichiers sont passés aux processus lancés par exec(), alors que les autres descripteurs de fichiers ne le sont pas. De plus, durant un open(); les descripteurs systèmes de fichiers sont préservés même si open() échoue. (Les autre descripteurs sont fermés avant qu'un open() ne soient tenté.). Le statut fermeture-sur-exec d'un descripteur de fichier sera décidé suivant la valeur de C<$^F> au moment de l'ouverture et non au moment de l'exec(). =item $^H Le jeu de tests syntaxiques autorisé par C et les autres directives de compilation incluses dans le bloc courant. Voir la documentation de C pour plus de détails. =item $INPLACE_EDIT =item $^I La valeur courante de l'extension "édition sur place". Utilise C pour mettre hors service l'édition sur place. (Mnémonique : valeur de l'option B<-i>.) =item $^M Par défaut, le dépassement de mémoire n'est pas détectable. Cependant, s'il est compilé pour cela, Perl peut utiliser le contenu de C<$^M> comme une réserve d'urgence après un die() dû à la mémoire. Supposons que votre Perl ait été compilé avec -DPERL_EMERGENCY_SBRK et Perl's malloc. Dans ce cas $^M = 'a' x (1<<16); allouera un buffer de 64K pour utiliser en cas d'urgence. Voir le fichier F pour des informations sur la méthode pour activer cette option. Pour ne pas inciter à une utilisation intensive de cette fonction avancée, il n'y a pas de noms longs pour cette variable. =item $OSNAME =item $^O Le nom du système d'exploitation utilisé pour compiler cette copie de Perl, déterminé pendant le processus de configuration. Cette valeur est identique à C<$Config{'osname'}>. =item $PERLDB =item $^P Variable interne pour le support. Les significations des octets sont (sujet au changement) : =over 6 =item 0x01 Déboggage sur le sous programme enter/exit. =item 0x02 Déboggage ligne à ligne. =item 0x04 Annule les options d'optimisation. =item 0x08 Préserve plus de données pour les inspections interactives à venir. =item 0x10 Garde des informations sur les lignes sources où un sous-programme est défini. =item 0x20 Démarre en mode pas à pas. =back Note : Certains bits peuvent avoir un sens à la compilation uniquement, d'autres seulement à l'exécution. C'est un nouveau mécanisme, et les détails peuvent varier. =item $^R Résultat de l'évaluation de la dernière utilisation réussie d'une expression régulière L>. (Exceptées celles utilisées comme bascules.) Cette variable est en lecture/écriture. =item $^S État en cours de l'interpréteur. Non défini si l'analyse du module/eval en cours n'est pas fini (cela peut arriver dans $SIG{__DIE__} et $SIG{__WARN__}). Renvoie TRUE (vrai) si à l'intérieur d'un eval, FALSE (faux) sinon. =item $BASETIME =item $^T Heure à laquelle le script a démarré, en secondes depuis le 01/01/1970. Les valeurs retournées par les tests de fichiers B<-M>, B<-A>, et B<-C> sont basées sur cette valeur. =item $WARNING =item $^W Valeur de l'option 'warning' (avertissement), TRUE (vrai) ou FALSE (faux). (Mnémonique : comme l'option B<-w>.) =item $EXECUTABLE_NAME =item $^X Nom sous lequel l'interpréteur Perl est exécuté, vient de C en C. =item $ARGV Contient le nom du fichier courant quand on lit depuis EE. =item @ARGV Contient les arguments de la ligne de commande du script. C<$#ARGV> est généralement le nombre d'argument moins 1 car C<$ARGV[0]> est le premier argument, I le nom de la commande qui est "C<$0>". Voir "C<$0>" pour le nom de la commande. =item @INC Contient la liste des répertoires où chercher pour évaluer les constructeurs C, C, ou C. Il est constitué au départ des arguments B<-I> de la ligne de commande, suivi du chemin par défaut de la librairie Perl, probablement F, suivi de ".", pour représenter le répertoire courant. Si vous devez modifier cette variable à l'exécution vous pouvez utiliser C pour charger les librairies dépendant de la machine : use lib '/mypath/libdir/'; use SomeMod; =item @_ Dans un sous programme, le tableau @_ contient les paramètres passés à ce sous programme. Voir L. =item %INC Contient une entrée pour chacun des fichiers inclus par C ou C. La clef est le nom du fichier, la valeur est la localisation du fichier effectivement trouvé. La commande C utilise ce tableau pour déterminer si un fichier donné est déjà inclus. =item %ENV $ENV{expr} Contient les variables d'environnement. Fixer une valeur dans C change l'environnement pour les processus fils. =item %SIG $SIG{expr} Utiliser pour fixer les descripteurs de signaux pour divers signaux. Par exemple : sub handler { # Le premier argument est le nom du signal my($sig) = @_; print "Caught a SIG$sig--shutting down\n"; close(LOG); exit(0); } $SIG{'INT'} = \&handler; $SIG{'QUIT'} = \&handler; ... $SIG{'INT'} = 'DEFAULT'; # Restaure l'action par défaut $SIG{'QUIT'} = 'IGNORE'; # ignore SIGQUIT Le tableau %SIG contient uniquement les valeurs des signaux positionnés dans le script Perl. Voici d'autres exemples : $SIG{"PIPE"} = Plumber; # EFFRAYANT!! $SIG{"PIPE"} = "Plumber"; # assume main::Plumber (Pas recommandé) $SIG{"PIPE"} = \&Plumber; # Bien; assume Plumber en sous programme $SIG{"PIPE"} = Plumber(); # oops, que retourne Plumber() ?? La ligne marquée "effrayant" pose problème car c'est un mot simple, qui peut soit être interprété comme une chaîne de caractère représentant la fonction, ou qui va faire appel au sous-programme immédiatement ! Pour être sûr du résultat, il vaut mieux le mettre entre guillemets ou le référencer. *Plumber fonctionne également. Voir L. Si votre système reconnaît la fonction sigaction(), alors les gestions de signaux sont implémentés par cette fonction. Ce qui signifie que vous avez une gestion des signaux fiable. Si votre système a l'option SA_RESTART, elle est utilisée pour la gestion des signaux. Ce qui signifie que les appels systèmes qui le supporte, continuent au lieu de s'interrompre quand ils reçoivent un signal. Si vous voulez que vos appels systèmes soient interrompus par un signal, faîtes quelque chose comme : use POSIX ':signal_h'; my $alarm = 0; sigaction SIGALRM, new POSIX::SigAction sub { $alarm = 1 } or die "Error setting SIGALRM handler: $!\n"; Voir L. Certaines interruptions internes peut être mises en place avec %SIG. La routine indiquée par C<$SIG{__WARN__}> est appelée quand un message d'avertissement devrait être affiché. Le message est passé en premier argument. La présence de l'indicateur __WARN__ supprime les avertissements normaux sur STDERR. Vous pouvez vous en servir pour stocker les avertissements dans une variable, ou pour transformer les avertissements en erreurs fatales, comme ceci : local $SIG{__WARN__} = sub { die $_[0] }; eval $proggie; La routine indiquée par C<$SIG{__DIE__}> est appelée juste avant la gestion d'une erreur fatale, avec le message d'erreur comme premier argument. En sortie de la routine, le traitement de l'erreur reprend son cours normal, sauf si la routine provoque un arrêt du traitement via C, une sortie de boucle ou un die(). Le gestionnaire C<__DIE__> est explicitement désactivé pendant l'appel, de sorte que l'interruption C<__DIE__> soit possible. Même chose pour C<__WARN__>. Note : l'interruption C<$SIG{__DIE__}> est appelée même à l'intérieur d'un bloque ou d'une chaîne eval()uée. Voir L et L pour un moyen de l'empêcher. Note : C<__DIE__>/C<__WARN__> ont ceci de spécial, qu'ils peuvent être appelés pour reporter une (probable) erreur pendant l'analyse du script. Dans ce cas, l'analyseur peut être dans un état instable, donc toute tentative pour évaluer du code Perl provoquera certainement une faute de segmentation. Donc un appel entraînant une analyse du code devra être utilisée avec précaution, comme ceci : require Carp if defined $^S; Carp::confess("Un problème") if defined &Carp::confess; die "Un problème, mais je ne peux charger Carp pour les détails... Essayer de relancer avec l'option -MCarp"; Dans cet exemple, la première ligne chargera Carp I si c'est l'analyseur qui a appelé l'interruption. La deuxième ligne affichera une trace de l'échec et arrêtera le programme si Carp est disponible. La troisième ligne ne sera exécutée que si Carp n'est pas disponible. Voir L, L et L pour plus d'informations. =back =head2 Indicateurs d'Erreur Les variables L<$@>, L<$!>, L<$^E>, et L<$?> contiennent des informations à propos des différentes conditions d'erreur pouvant survenir pendant l'exécution d'un script Perl. Les variables sont données en fonction de la "distance" qui sépare le sous-système déclenchant l'erreur et le programme Perl, elles correspondent respectivement aux erreurs détectées par l'interpréteur Perl, la bibliothèque C, le système d'exploitation ou un programme externe. Pour illustrer ces différences, prenons l'exemple suivant : eval ' open PIPE, "/cdrom/install |"; @res = ; close PIPE or die "bad pipe: $?, $!"; '; Après l'exécution du code, les 4 variables peuvent être positionnées. $@ le sera si l'expression à évaluer (C) ne s'est pas compilée (cela peut se produire si C ou C ont été mal importés), ou si le code Perl exécuté pendant l'évaluation échoue via die() (soit implicitement par exemple si C est importé du module L, ou si le C après C est déclenché). Dans ce cas $@ contient l'erreur de compilation, ou l'erreur fatale (C) (qui interpolera C<$!>!), ou l'argument de C (qui interpolera C<$!> et C<$?>!). Quand le code est exécuté, open(), CPIPEE>, et C sont traduits en appelant la librairie C. $! est positionné si l'un des appels échoue. La valeur est une indication symbolique fournie par le C, par exemple C. Sur certains systèmes les appels ci-dessus à la librairie C sont ensuite traduits en appels au Kernel. Ce dernier peut utiliser des erreurs plus documentées que le C. Dans ce cas $^E contient le message du Kernel, par exemple C. Si l'appel système et la fonction C sont équivalents, alors $^E contient la même chose que $!. Finalement, $? sera différent de C<0> si le programme externe au script C échoue. La valeur haute de l'erreur peut refléter les conditions d'erreur rencontrées par le programme (cela dépend uniquement du programme), et la valeur basse le type d'échec (Erreur segmentation, accomplissement, etc.). Note : contrairement à $@, $! et $^E qui sont renseignés sur erreur, $? est renseigné à chaque utilisation de C ou fermeture (C) de redirection, en écrasant l'ancienne valeur. Pour plus de détails, voir les descriptions individuelles de L<$@>, L<$!>, L<$^E>, et L<$?>. =head1 TRADUCTION =head2 Version Cette traduction française correspond à la version anglaise distribuée avec perl 5.005_02. Pour en savoir plus concernant ces traductions, consultez L. =head2 Traducteur Fabien Martinet (ho.fmartinet@cma-cgm.com) =head2 Relecture Personne pour l'instant.