• NOM
• DESCRIPTION
  • Noms Prédéfinis
  • Indicateurs d'Erreur
• TRADUCTION

NOM

perlvar - Variables Prédéfinies en Perl

DESCRIPTION

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 awk.

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}.

$ARG

$_

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 :

• Diverses fonctions, notamment les fonctions comme ord() et int(), ainsi que tous les tests sur les fichiers (-f, -d) à l'exception de -t, qui utilise par défaut STDIN.

• Diverses fonctions de liste comme print() et unlink().

• Les opérations de recherche m//, s///, et tr/// quand elles n'utilisent pas l'opérateur =~.

• La variable d'itération par défaut dans une boucle foreach si aucune autre variable n'est précisée.

• La variable implicite d'itération dans les fonctions grep() et map().

• La variable par défaut où est stocké un enregistrement quand le résultat de <FH> s'auto-teste et représente le critère unique d'un while. Attention : en dehors d'un test while cela n'arrive pas.

(Moyen mnémonique: Sous-ligné est sous-entendu dans certaines opérations.)

$<digits>

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.

$MATCH

$&

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.

$PREMATCH

$`

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 : ` précède souvent une chaîne de caractère entre guillemets). Variable en lecture seule.

$POSTMATCH

$'

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 : ` suit souvent une chaîne de caractère entre guillemets). Variable en lecture seule. Exemple :

    $_ = 'abcdefghi';
    /def/;
    print "$`:$&:$'\n";         # affiche abc:def:ghi

$LAST_PAREN_MATCH

$+

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.

$MULTILINE_MATCHING

$*

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 ``$*'' 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 ``^'' et de ``$''. Un retour ligne peut être recherché même si $* == 0.

L'utilisation de ``$*'' est obsolète dans les Perls modernes, et supplantée par les modificateurs de recherche /s et /m.

input_line_number HANDLE EXPR

$INPUT_LINE_NUMBER

$NR

$.

Le numéro de ligne courante du dernier fichier depuis lequel vous avez lu (ou sur lequel vous avez utilisez seek ou tell). Une fermeture explicite d'un fichier réinitialise le numéro de ligne. Comme ``<>'' ne provoque pas de fermeture explicite, le numéro de ligne augmente au travers des fichiers ARGV (voir les exemples sous eof()). Localiser $. 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``)

input_record_separator HANDLE EXPR

$INPUT_RECORD_SEPARATOR

$RS

$/

Le séparateur d'enregistrement en lecture, par défaut retour-ligne. Fonctionne comme la variable RS en awk, 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 à undef pour lire jusqu'à la fin du fichier. Notez que le fixer à "\n\n" est légèrement différent que le fixer à "" si le fichier contient plusieurs lignes vides consécutives. Le positionner à "" traitera deux lignes vides consécutives (ou plus) comme une seule. Le positionner à "\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 $/;
    $_ = <FH>;          # 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);
    $_ = <FILE>;

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 sysread, 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.

autoflush HANDLE EXPR

$OUTPUT_AUTOFLUSH

$|

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; $| 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)

output_field_separator HANDLE EXPR

$OUTPUT_FIELD_SEPARATOR

$OFS

$,

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 awk, initialisez cette variable comme vous le feriez de la variable OFS du awk pour spécifier ce qui doit être imprimer entre chaque champs. (Mnémonique : Ce qui est imprimé quand vous avez une , dans vos champs)

output_record_separator HANDLE EXPR

$OUTPUT_RECORD_SEPARATOR

$ORS

$\

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 awk, initialisez cette variable comme vous le feriez de la variable ORS du awk pour spécifier ce qui doit être sorti en fin de traitement. (Mnémonique : positionnez ``$\'' au lieu d'ajouter \n à la fin de chaque impression. Ou : Comme $/, mais c'est ce que vous ``obtenez'' du Perl.) (NdT. get back = ``obtenez'', \ = backslash)

$LIST_SEPARATOR

$"

Même chose que ``$,'', 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)

$SUBSCRIPT_SEPARATOR

$SUBSEP

$;

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 awk. Notez que si vos clefs contiennent des valeurs binaires il se peut qu'il n'y ait aucune valeur sûre pour ``$^;''. (Mnémonique : la virgule (le séparateur d'indice)est un demi point-virgule. Ouais, je sais que c'est faible,mais ``$,'' est déjà utilisé quelque chose de plus important.)

Envisagez d'utiliser de ``vrais'' tableaux à plusieurs dimensions.

$OFMT

$#

C'est le format de sortie des nombres. Cette variable est une pâle tentative d'émulation de la variable OFMT en awk. Il y a des cas, cependant, où Perl et awk ont des vues différentes sur la notion de numérique. La valeur par défaut est %.ng, où n est la valeur de la macro DBL_DIG du float.h de votre système. C'est différent de la valeur par défaut de OFMT en awk qui est %.6g, donc il vous faut initialiser ``$#'' explicitement pour obtenir la valeur awk. (Mnémonique : # est le signe des nombres)

L'utilisation de ``$#'' est obsolète.

format_page_number HANDLE EXPR

$FORMAT_PAGE_NUMBER

$%

Le numéro de la page en cours sur le canal de sortie en cours. (Mnémonique : % est le numéro de page avec nroff.)

format_lines_per_page HANDLE EXPR

$FORMAT_LINES_PER_PAGE

$=

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.)

format_lines_left HANDLE EXPR

$FORMAT_LINES_LEFT

$-

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.)

format_name HANDLE EXPR

$FORMAT_NAME

$~

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 ``$^''.)

format_top_name HANDLE EXPR

$FORMAT_TOP_NAME

$^

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.)

format_line_break_characters HANDLE EXPR

$FORMAT_LINE_BREAK_CHARACTERS

$:

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 " \n-", pour couper sur les espaces ou les traits d'unions. (Mnémonique : en poésie un ``deux-points'' fait partie de la ligne.)

format_formfeed HANDLE EXPR

$FORMAT_FORMFEED

$^L

Ce qui est utiliser pour faire tourner la page. Défaut est ``\f''.

$ACCUMULATOR

$^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 $^A. Après appel à son format, write() sort le contenu de $^A et le réinitialise. Donc vous ne voyez jamais le contenu de $^A, à moins que vous n'appeliez formline() vous-même, et ne regardiez le contenu. Voir la page de manuel perlform et formline() .

$CHILD_ERROR

$?

Le statut retourné par la dernière fermeture d'une redirection, une commande 'anti-apostrophe' (``), 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 ($? >> 8), et $? & 127 indique quel signal (s'il y a lieu) a stoppé le process, enfin $? & 128 indique s'il y a eu core dump. (Mnémonique : similaire à sh et ksh.)

De plus, si la variable h_errno est supportée en C, sa valeur est retournée par $? si n'importe laquelle des fonctions gethost*() échoue.

Si vous avez installé un descripteur de signal pour SIGHLD, la valeur $? sera la plupart du temps erronée en dehors de ce descripteur.

A l'intérieur d'un sous programme END $? contient la valeur qui sera passée à exit(). Vous pouvez modifier $? dans un sous programme END pour changer le code de sortie d'un script.

Sous VMS, la déclaration use vmsish 'status' fait renvoyer à $? le code de sortie réel de VMS, plutôt que le code d'émulation POSIX habituel.

Voir aussi Indicateurs d'Erreur.

$OS_ERROR

$ERRNO

$!

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 $! 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 $! pour fixer errno si, par exemple, vous voulez utiliser "$!" pour retourner le texte de l'erreur n, ou si vous voulez fixer la valeur de l'opérateur die(). (Mnémonique : Qu'est-ce qui a planté ?)

Voir aussi Indicateurs d'Erreur.

$EXTENDED_OS_ERROR

$^E

Information d'erreur spécifique au système d'exploitation. Pour le moment diffère de $! seulement sous VMS, OS/2 et Win32 (et MacPerl). Sur toutes les autres plateformes, $^E est équivalent à $!.

Sous VMS, $^E fournit la valeur du statut VMS de la dernière erreur système. Les informations sont plus spécifiques que celles fournit par $!. Ceci est particulièrement important quand $! est fixé à EVMSERR.

Sous OS/2, $^E correspond au code d'erreur du dernier appel API soit au travers de CRT, soit depuis Perl.

Sous Win32, $^E retourne toujours l'information relative au dernier appel Win32 GetLastError(), qui décrit le dernier code d'erreur de l'API Win32. La plupart des applications spécifiques Win32 reportent les erreurs via $^E. ANSI C et UNIX positionnent errno, donc les programmes Perl les plus portables utiliseront $! pour remonter les messages d'erreur.

Les avertissements mentionnés dans la description de $! s'appliquent généralement à $^E. (Mnémonique : Explication d'Erreur Additionnelle)

Voir aussi Indicateurs d'Erreur.

$EVAL_ERROR

$@

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 $SIG{__WARN__} comme décrit plus loin.

Voir aussi Indicateurs d'Erreur.

$PROCESS_ID

$PID

$$

Numéro du processus Perl exécutant ce script. (Mnémonique : comme en shell.)

$REAL_USER_ID

$UID

$<

L'uid (id utilisateur) réel du processus. (Mnémonique : l'uid d'OU vous venez si vous executez setuid.)

$EFFECTIVE_USER_ID

$EUID

$>

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 VERSvers lequel vous alliez, si vous exécutez setuid.) Note : ``$<'' et ``$>''peuvent être inversés seulement sur les machines supportant setreuid().

$REAL_GROUP_ID

$GID

$(

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 à ``$('' doit être un nombre unique utilisé pour fixer le gid réel. Donc la valeur donnée par ``$('' ne doit pas être réassignée à ``$('' sans être forcée en numérique, par exemple en lui ajoutant 0.

(Mnémonique : les parenthèses sont utilisées pour GROUPER les choses. Le gid réel est le groupe que vous laissez à votre GAUCHE, si vous utilisez setgid.) (NdT: GAUCHE = parenthèse gauche)

$EFFECTIVE_GROUP_ID

$EGID

$)

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 à ``$)'' 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 :

 $) = "5 5" 

.

(Mnémonique : les parenthèses sont utilisées pour GROUPER les choses. Le gid effectif est le groupe qui vous donne le bon DROIT pour vous si vous exécutez setgid.) (NdT: DROIT = parenthèse droite)

Note : ``$<'', ``$>'', ``$('' et ``$)'' peuvent être positionnés seulement sur les machines qui supportent les fonctions correspondantes set[re][ug]id(). ``$('' et ``$)'' peuvent être inversée seulement sur les machines supportant setregid().

$PROGRAM_NAME

$0

Contient le nom du fichier contenant le script Perl en cours d'exécution. Sur certains systèmes assigner une valeur à ``$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 sh et ksh.)

$[

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 awk (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 ``$['' est traité comme une directive de compilation et ne peut influencer le comportement des autres fichiers. Son usage est déconseillé.

$PERL_VERSION

$]

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 use VERSION et require VERSION pour un moyen pratique d'empêcher l'exécution d'un script si l'interpréteur est trop vieux.

$DEBUGGING

$^D

La valeur des options de débuggages. (Mnémonique : valeur de l'option -D.)

$SYSTEM_FD_MAX

$^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 $^F au moment de l'ouverture et non au moment de l'exec().

$^H

Le jeu de tests syntaxiques autorisé par use strict et les autres directives de compilation incluses dans le bloc courant. Voir la documentation de strict pour plus de détails.

$INPLACE_EDIT

$^I

La valeur courante de l'extension ``édition sur place''. Utilise undef pour mettre hors service l'édition sur place. (Mnémonique : valeur de l'option -i.)

$^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 $^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 INSTALL 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.

$OSNAME

$^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 à $Config{'osname'}.

$PERLDB

$^P

Variable interne pour le support. Les significations des octets sont (sujet au changement) :

1. x01

   Déboggage sur le sous programme enter/exit.

2. x02

   Déboggage ligne à ligne.

3. x04

   Annule les options d'optimisation.

4. x08

   Préserve plus de données pour les inspections interactives à venir.

5. x10

   Garde des informations sur les lignes sources où un sous-programme est défini.

6. x20

   Démarre en mode pas à pas.

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.

$^R

Résultat de l'évaluation de la dernière utilisation réussie d'une expression régulière (?{ code }). (Exceptées celles utilisées comme bascules.) Cette variable est en lecture/écriture.

$^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.

$BASETIME

$^T

Heure à laquelle le script a démarré, en secondes depuis le 01/01/1970. Les valeurs retournées par les tests de fichiers -M, -A, et -C sont basées sur cette valeur.

$WARNING

$^W

Valeur de l'option 'warning' (avertissement), TRUE (vrai) ou FALSE (faux). (Mnémonique : comme l'option -w.)

$EXECUTABLE_NAME

$^X

Nom sous lequel l'interpréteur Perl est exécuté, vient de argv[0] en C.

$ARGV

Contient le nom du fichier courant quand on lit depuis <>.

@ARGV

Contient les arguments de la ligne de commande du script. $#ARGV est généralement le nombre d'argument moins 1 car $ARGV[0] est le premier argument, pas le nom de la commande qui est ``$0''. Voir ``$0'' pour le nom de la commande.

@INC

Contient la liste des répertoires où chercher pour évaluer les constructeurs do EXPR, require, ou use. Il est constitué au départ des arguments -I de la ligne de commande, suivi du chemin par défaut de la librairie Perl, probablement /usr/local/lib/perl, suivi de ``.'', pour représenter le répertoire courant. Si vous devez modifier cette variable à l'exécution vous pouvez utiliser use lib pour charger les librairies dépendant de la machine :

    use lib '/mypath/libdir/';
    use SomeMod;

@_

Dans un sous programme, le tableau @_ contient les paramètres passés à ce sous programme. Voir perlsub.

%INC

Contient une entrée pour chacun des fichiers inclus par do ou require. La clef est le nom du fichier, la valeur est la localisation du fichier effectivement trouvé. La commande require utilise ce tableau pour déterminer si un fichier donné est déjà inclus.

%ENV $ENV{expr}

Contient les variables d'environnement. Fixer une valeur dans ENV change l'environnement pour les processus fils.

%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 perlsub.

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 POSIX.

Certaines interruptions internes peut être mises en place avec %SIG. La routine indiquée par $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 $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 goto, une sortie de boucle ou un die(). Le gestionnaire __DIE__ est explicitement désactivé pendant l'appel, de sorte que l'interruption __DIE__ soit possible. Même chose pour __WARN__.

Note : l'interruption $SIG{__DIE__} est appelée même à l'intérieur d'un bloque ou d'une chaîne eval()uée. Voir die et $^S pour un moyen de l'empêcher.

Note : __DIE__/__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 sauf 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 die, warn et eval pour plus d'informations.

Indicateurs d'Erreur

Les variables $@, $!, $^E, et $? 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 = <PIPE>;
         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 (eval) ne s'est pas compilée (cela peut se produire si open ou close ont été mal importés), ou si le code Perl exécuté pendant l'évaluation échoue via die() (soit implicitement par exemple si open est importé du module Fatal, ou si le die après close est déclenché). Dans ce cas $@ contient l'erreur de compilation, ou l'erreur fatale (Fatal) (qui interpolera $!!), ou l'argument de die (qui interpolera $! et $?!).

Quand le code est exécuté, open(), <PIPE>, et close 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 Fichier ou chemin introuvable.

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 CDROM non fermé. Si l'appel système et la fonction C sont équivalents, alors $^E contient la même chose que $!.

Finalement, $? sera différent de 0 si le programme externe au script /cdrom/install é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 wait ou fermeture (close) de redirection, en écrasant l'ancienne valeur.

Pour plus de détails, voir les descriptions individuelles de $@, $!, $^E, et $?.

TRADUCTION

Fabien Martinet (ho.fmartinet@cma-cgm.com)