perl56delta - En ligne dans le Cloud

PROGRAMME:

Nom

perl56delta - Quoi de neuf pour perl v5.6.0

DESCRIPTION

Ce document décrit les différences entre la version 5.005 et la version 5.6.0.

Core Améliorations

Interprète clonage, fils, et concurrence
Perl 5.6.0 introduit les débuts de la prise en charge de l'exécution de plusieurs interpréteurs
simultanément dans différents threads. En conjonction avec le perl_clone() appel d'API, qui
peut être utilisé pour dupliquer sélectivement l'état d'un interprète donné, il est possible de
compiler un morceau de code une fois dans un interpréteur, cloner cet interpréteur une ou plusieurs fois,
et exécutez tous les interpréteurs résultants dans des threads distincts.

Sur la plate-forme Windows, cette fonctionnalité est utilisée pour émuler fourchette() au niveau de l'interprète.
Voir perlfork pour plus de détails à ce sujet.

Cette fonctionnalité est encore en évolution. Il est finalement destiné à être utilisé pour sélectivement
cloner un sous-programme et des données accessibles à partir de ce sous-programme dans un interpréteur séparé et
exécuter le sous-programme cloné dans un thread séparé. Comme il n'y a pas de données partagées entre les
interprètes, peu ou pas de verrouillage sera nécessaire (à moins que des parties de la table des symboles ne soient
explicitement partagé). Ceci est évidemment destiné à être un remplacement facile à utiliser pour le
prise en charge des threads existants.

La prise en charge du clonage des interprètes et de la simultanéité des interprètes peut être activée à l'aide de la
-Dusethreads Configure l'option (voir win32/Makefile pour savoir comment l'activer sous Windows.)
L'exécutable perl résultant sera fonctionnellement identique à celui qui a été construit avec
-Dmultiplicité, mais le perl_clone() L'appel API ne sera disponible que dans le premier.

-Dusethreads active la macro cpp USE_ITHREADS par défaut, qui à son tour active Perl
les changements de code source qui fournissent une séparation claire entre l'arborescence op et les données qu'il
fonctionne avec. Le premier est immuable, et peut donc être partagé entre un
interpréteur et tous ses clones, tandis que ce dernier est considéré comme local à chaque
interpréteur, et est donc copié pour chaque clone.

Notez que construire Perl avec l'option -Dusemultiplicity Configure est adéquat si vous
souhaitez exécuter plusieurs indépendant interprètes simultanément dans différents threads.
-Dusethreads ne fournit que les fonctionnalités supplémentaires du perl_clone() appel API et
autre support pour courir cloné interprètes en parallèle.

REMARQUE : Il s'agit d'une fonctionnalité expérimentale. Les détails de mise en œuvre sont
sous réserve de modifications.

Lexicalement portée avertissement catégories
Vous pouvez désormais contrôler la granularité des avertissements émis par perl à un niveau plus fin en utilisant le
pragma « utiliser les avertissements ». les avertissements et perllexwarn ont une abondante documentation à ce sujet
fonction.

Unicode et UTF-8 soutenez
Perl utilise désormais UTF-8 comme représentation interne pour les chaînes de caractères. Le "utf8" et
Les pragmas "bytes" sont utilisés pour contrôler ce support dans la portée lexicale courante. Voir
perlunicode, utf8 et bytes pour plus d'informations.

Cette fonctionnalité devrait évoluer rapidement pour prendre en charge une certaine forme de disciplines d'E/S qui
peut être utilisé pour spécifier le type de données d'entrée et de sortie (octets ou caractères). Jusqu'à
cela se produit, des modules supplémentaires de CPAN seront nécessaires pour compléter la boîte à outils pour
traiter avec Unicode.

REMARQUE : Cela doit être considéré comme une fonctionnalité expérimentale. Mise en œuvre
les détails sont sujets à changement.

Assistance pour interpoler nommé caractères
Le nouvel échappement "\N" interpole les caractères nommés dans les chaînes. Par exemple, « Salut !
\N{WHITE SMILING FACE}" est évalué comme une chaîne avec un smiley Unicode à la fin.

"notre" déclarations
Une déclaration "notre" introduit une valeur qui peut être mieux comprise comme une portée lexicale
alias symbolique à une variable globale dans le package qui était en cours où la variable était
déclaré. Ceci est surtout utile comme alternative au pragma "vars", mais fournit également
la possibilité d'introduire le typage et d'autres attributs pour ces variables. Voir "notre" dans
perfunc.

Assistance pour instruments à cordes représenté as a vecteur of ordinaux
Les littéraux de la forme "v1.2.3.4" sont maintenant analysés comme une chaîne composée de caractères avec le
ordinaux spécifiés. Il s'agit d'une manière alternative et plus lisible de construire (éventuellement
chaînes unicode) au lieu d'interpoler des caractères, comme dans « \x{1}\x{2}\x{3}\x{4} ».
Le "v" de tête peut être omis s'il y a plus de deux ordinaux, donc 1.2.3 est analysé
identique à "v1.2.3".

Les chaînes écrites sous cette forme sont également utiles pour représenter les "numéros" de version. C'est facile
pour comparer ces "numéros" de version (qui ne sont en réalité que de simples chaînes) en utilisant l'un des
opérateurs de comparaison de chaînes habituels "eq", "ne", "lt", "gt", etc., ou exécutent une chaîne au niveau du bit
opérations sur eux en utilisant "|", "&", etc.

En conjonction avec la nouvelle variable magique $^V (qui contient la version perl en tant que
chaîne), de tels littéraux peuvent être utilisés comme un moyen lisible de vérifier si vous exécutez un
version particulière de Perl :

# cela analysera également les anciennes versions de Perl
if ($^V et $^V gt v5.6.0) {
# nouvelles fonctionnalités prises en charge
}

« require » et « use » ont également une magie spéciale pour prendre en charge de tels littéraux, mais cela
une utilisation particulière doit être évitée car elle conduit à des messages d'erreur trompeurs sous
versions de Perl qui ne prennent pas en charge les chaînes vectorielles. L'utilisation d'un numéro de version correct
assurer un comportement correct dans toutes les versions de Perl :

nécessite 5.006 ; # vérification d'exécution pour la version 5.6
utiliser 5.006_001 ; # vérification du temps de compilation pour la version 5.6.1

De plus, "sprintf" et "printf" prennent en charge l'indicateur de format spécifique à Perl %v pour imprimer les ordinaux de
caractères dans des chaînes arbitraires :

printf "v%vd", $^V; # imprime la version actuelle, telle que "v5.5.650"
printf "%*vX", ":", $addr; # formate l'adresse IPv6
printf "%*vb", " ", $bits ; # affiche la chaîne de bits

Voir "Constructeurs de valeurs scalaires" dans perldata pour plus d'informations.

Agencement des Perl version numérotage Système
A partir de Perl version 5.6.0, la convention de numéro de version a été changée en
schéma « entier pointé » que l'on trouve plus couramment dans les projets open source.

Les versions de maintenance de v5.6.0 seront publiées en tant que v5.6.1, v5.6.2 etc. La prochaine
les séries de développement suivant la v5.6.0 seront numérotées v5.7.x, commençant par v5.7.0, et
la prochaine version de production majeure suivant la v5.6.0 sera la v5.8.0.

Le module anglais définit maintenant $PERL_VERSION sur $^V (une valeur de chaîne) plutôt que $] (un
valeur numérique). (Il s'agit d'une incompatibilité potentielle. Envoyez-nous un rapport via perlbug si
vous êtes concerné par cela.)

La syntaxe v1.2.3 est également désormais légale en Perl. Voir « Prise en charge des chaînes représentées comme un
vecteur d'ordinaux" pour en savoir plus à ce sujet.

Pour faire face à l'utilisation par le nouveau système de version d'au moins trois chiffres significatifs pour chaque
composant de version, la méthode utilisée pour incrémenter le numéro de sous-version a également changé
légèrement. Nous supposons que les versions antérieures à la v5.6.0 ont incrémenté la subversion
composant par multiples de 10. Les versions postérieures à la v5.6.0 les incrémenteront de 1. Ainsi,
en utilisant la nouvelle notation, 5.005_03 est le "même" que v5.5.30, et la première maintenance
la version suivant la v5.6.0 sera la v5.6.1 (qui doit être lue comme équivalente à une
valeur à virgule flottante de 5.006_001 dans l'ancien format, stockée dans $]).

New syntaxe pour déclarant sous-programme attributs
Auparavant, si vous vouliez marquer un sous-programme comme étant un appel de méthode ou comme nécessitant un
automatique fermer à clé() lorsqu'il est entré, vous deviez déclarer qu'avec un pragma "use attrs" dans
le corps du sous-programme. Cela peut maintenant être accompli avec la syntaxe de déclaration, comme
ce:

sub mymethod : méthode verrouillée ;
...
sous mymethod : méthode verrouillée {
...
}

sous autre méthode :verrouillé :méthode;
...
sous autre méthode :verrouillé :méthode {
...
}

(Notez que seul le premier ":" est obligatoire et que les espaces blancs entourant le ":" sont
optionnel.)

AutoSplit.pm et SelfLoader.pm ont été mis à jour pour conserver les attributs avec les stubs
ils fournissent. Voir les attributs.

Fichier et annuaire poignées Vous pouvez be autovivifié
Semblable à la façon dont les constructions telles que "$x->[0]" autovivifient une référence, gèrent les constructeurs
(ouvrir(), opendir(), tuyau(), paire de sockets(), sysopen(), socket ()et J'accepte()) à présent
autovivifier un descripteur de fichier ou de répertoire si le descripteur qui lui est passé est un non initialisé
variable scalaire. Cela permet aux constructions telles que "open(my $fh, ...)" et "open(local
$fh,...)" à utiliser pour créer des descripteurs de fichiers qui seront facilement fermés automatiquement
lorsque la portée se termine, à condition qu'il n'y ait pas d'autres références à eux. Ceci en grande partie
élimine le besoin de typeglobs lors de l'ouverture des descripteurs de fichiers qui doivent être transmis, comme
dans l'exemple suivant :

sous myopen {
ouvre mon $fh, "@_"
ou mourir "Impossible d'ouvrir '@_': $!";
renvoie $fh ;
}

{
mon $f = monopen("
imprimer <$f> ;
# $f implicitement fermé ici
}

ouvrir() avec plus que deux arguments
If ouvrir() reçoit trois arguments au lieu de deux, le deuxième argument est utilisé comme
mode et le troisième argument est considéré comme le nom du fichier. Ceci est principalement utile pour
protection contre les comportements magiques involontaires de la forme traditionnelle à deux arguments. Voir
"ouvrir" dans perlfunc.

64-bits soutenez
Toute plate-forme qui a des entiers 64 bits soit

(1) nativement comme longs ou ints
(2) via des drapeaux spéciaux du compilateur
(3) en utilisant long long ou int64_t

est capable d'utiliser des "quads" (entiers de 64 bits) comme suit :

· constantes (décimales, hexadécimales, octales, binaires) dans le code

· arguments à octobre() et hexa ()

· arguments à impression(), printf () et sprintf() (préfixes de drapeau ll, L, q)

· imprimé comme tel

· paquet() et déballer() Formats "q" et "Q"

· en arithmétique de base : + - * / % (NOTE : fonctionnement proche des bornes de l'entier
les valeurs peuvent produire des résultats surprenants)

· en arithmétique binaire : & | ^ ~ << >> (REMARQUE : ceux-ci étaient auparavant forcés à avoir une largeur de 32 bits
mais fonctionne maintenant sur toute la largeur native.)

· vec()

Notez qu'à moins que vous n'ayez le cas (a), vous devrez configurer et compiler Perl en utilisant
l'indicateur de configuration -Duse64bitint.

REMARQUE : les indicateurs de configuration -Duselonglong et -Duse64bits ont été
obsolète. Utilisez plutôt -Duse64bitint.

Il existe en fait deux modes de 64 bits : le premier est obtenu à l'aide de Configure
-Duse64bitint et le second utilisant Configure -Duse64bitall. La différence est que
le premier est minimal et le second maximal. Le premier fonctionne dans plus d'endroits que
le second.

Le "use64bitint" ne fait que ce qui est nécessaire pour obtenir des entiers 64 bits dans Perl (cela
peut signifier, par exemple, l'utilisation de "longs longs") alors que votre mémoire peut encore être limitée à 2
gigaoctets (parce que vos pointeurs peuvent toujours être de 32 bits). Notez que le nom "64bitint"
n'implique pas que votre compilateur C utilisera des "int" 64 bits (cela pourrait, mais ce n'est pas le cas
devoir): le "use64bitint" signifie que vous pourrez avoir un scalaire large de 64 bits
valeurs.

Le "use64bitall" va jusqu'au bout en essayant de basculer également des entiers (s'il le peut),
longs (et pointeurs) à 64 bits. Cela peut créer un binaire encore plus incompatible
Perl que -Duse64bitint : l'exécutable résultant peut ne pas s'exécuter du tout dans une boîte 32 bits, ou
vous devrez peut-être redémarrer/reconfigurer/reconstruire votre système d'exploitation pour qu'il soit compatible 64 bits.

Les systèmes natifs 64 bits comme Alpha et Cray n'ont besoin ni de -Duse64bitint ni de -Duse64bitall.

Dernier point mais non le moindre : notez qu'en raison de l'habitude de Perl de toujours utiliser des nombres à virgule flottante,
les quads ne sont toujours pas de vrais entiers. Quand les quads dépassent leurs limites
(0...18_446_744_073_709_551_615 unsigned,
-9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they are silently promoted
aux nombres à virgule flottante, après quoi ils commenceront à perdre en précision (dans leur
chiffres).

REMARQUE : la prise en charge 64 bits est encore expérimentale sur la plupart des plates-formes.
Le support existant ne couvre que le modèle de données LP64. En particulier, le
Le modèle de données LLP64 n'est pas encore pris en charge. Bibliothèques et système 64 bits
Les API sur de nombreuses plates-formes ne se sont pas stabilisées - votre kilométrage peut varier.

Grande filet soutenez
Si vous avez des systèmes de fichiers qui prennent en charge les "fichiers volumineux" (fichiers de plus de 2 gigaoctets), vous
peut maintenant également être capable de les créer et d'y accéder à partir de Perl.

REMARQUE : l'action par défaut consiste à activer la prise en charge des fichiers volumineux, si
disponible sur la plateforme.

Si la prise en charge des fichiers volumineux est activée et que vous avez une constante Fcntl O_LARGEFILE, le
O_LARGEFILE est automatiquement ajouté aux drapeaux de sysopen().

Attention, à moins que votre système de fichiers ne prenne également en charge les "fichiers clairsemés" cherchant à
pétaoctets peuvent être déconseillés.

Notez qu'en plus d'exiger un système de fichiers approprié pour créer des fichiers volumineux, vous pouvez également
besoin d'ajuster votre par-processus (ou votre par-système, ou par-process-groupe, ou par-utilisateur-
group) limites maximales de taille de fichier avant d'exécuter des scripts Perl qui tentent de gérer des fichiers volumineux,
surtout si vous avez l'intention d'écrire de tels fichiers.

Enfin, en plus des limites de taille de fichier maximale de votre groupe de processus/processus, vous pouvez avoir
des limites de quota sur vos systèmes de fichiers qui vous empêchent (votre identifiant d'utilisateur ou votre identifiant de groupe d'utilisateurs) de
en utilisant des fichiers volumineux.

L'ajustement de vos limites de processus/utilisateur/groupe/système de fichiers/système d'exploitation est hors de portée
du langage de base de Perl. Pour les limites de processus, vous pouvez essayer d'augmenter les limites en utilisant votre
commande limites/limit/ulimit du shell avant d'exécuter Perl. L'extension BSD::Resource (pas
inclus avec la distribution Perl standard) peut également être utile, il offre la
interface getrlimit/setrlimit qui peut être utilisée pour ajuster les limites d'utilisation des ressources de processus,
y compris la limite de taille de fichier maximale.

Long double
Dans certains systèmes, vous pouvez utiliser des doubles longs pour améliorer la portée et la précision de
vos nombres à virgule flottante double précision (c'est-à-dire les nombres de Perl). Utiliser Configurer
-Duselongdouble pour activer ce support (s'il est disponible).

"Suite morceaux"
Vous pouvez "Configurer -Dusemorebits" pour activer à la fois le support 64 bits et le long double
soutien.

Renforcer la compréhension soutenez pour sorte() sous-programmes
Les sous-routines Perl avec un prototype de "($$)", et les XSUB en général, peuvent désormais être utilisées comme tri
sous-programmes. Dans les deux cas, les deux éléments à comparer sont passés comme d'habitude
paramètres dans @_. Voir "trier" dans perlfunc.

Pour les sous-programmes de tri non prototypes, le comportement historique de passage des éléments à
comparée car les variables globales $a et $b restent inchangées.

"sorte $coderef @foo" permis
sorte() n'a pas accepté une référence de sous-programme comme fonction de comparaison précédemment
versions. Ceci est désormais autorisé.

Fichier globuleux mis en œuvre intérieurement
Perl utilise maintenant l'implémentation File::Glob du globe () opérateur automatiquement. Cette
évite d'utiliser un processus csh externe et les problèmes qui y sont associés.

REMARQUE : Il s'agit actuellement d'une fonctionnalité expérimentale. Interfaces et
la mise en œuvre est sujette à changement.

Assistance pour COMMENCER blocs
En plus de " BEGIN ", " INIT ", " END ", " DESTROY " et " AUTOLOAD ", des sous-routines nommées " CHECK "
sont maintenant spéciaux. Ceux-ci sont mis en file d'attente lors de la compilation et se comportent de la même manière que les blocs END,
sauf qu'ils sont appelés à la fin de la compilation plutôt qu'à la fin de l'exécution.
Ils ne peuvent pas être appelés directement.

POSIX caractère classe syntaxe [: :] soutenu
Par exemple, pour faire correspondre les caractères alphabétiques, utilisez /[[:alpha:]]/. Voir perlre pour plus de détails.

Rapidité pseudo-aléatoire nombre générateur
Dans 5.005_0x et versions antérieures, perl's rand () fonction a utilisé la bibliothèque C rand(3) fonction. Comme
de 5.005_52, Configurer les tests pour drand48(), aléatoire ()et rand () (dans cet ordre) et pioche
le premier qu'il trouve.

Ces changements devraient se traduire par de meilleurs nombres aléatoires de rand ().

Agencement des "qw//" opérateur
L'opérateur "qw//" est maintenant évalué au moment de la compilation dans une vraie liste au lieu d'être
remplacé par un appel d'exécution à "split()". Cela supprime le mauvais comportement déroutant de
"qw//" dans un contexte scalaire, qui avait hérité ce comportement de diviser().

Ainsi:

$foo = ($bar) = qw(abc); print "$foo|$bar\n" ;

affiche désormais correctement "3|a", au lieu de "2|a".

Rapidité pire cas humain of hashes
De petits changements dans l'algorithme de hachage ont été mis en œuvre afin d'améliorer la
distribution des bits de poids faible dans la valeur hachée. On s'attend à ce que cela donne mieux
performances sur des touches qui sont des séquences répétées.

paquet() le format «Z» soutenu
Le nouveau type de format « Z » est utile pour compresser et décompresser les chaînes à zéro terminal. Voir
"pack" en perlfunc.

paquet() le format modificateur '!' soutenu
Le nouveau modificateur de type de format '!' est utile pour emballer et déballer les shorts natifs, les ints,
et longtemps. Voir "pack" dans perlfunc.

paquet() et déballer() soutenez dénombré instruments à cordes
Le caractère de modèle '/' peut être utilisé pour spécifier un type de chaîne compté à emballer ou
déballé. Voir "pack" dans perlfunc.

Commentaires in paquet() modèles
Le caractère '#' dans un modèle introduit un commentaire jusqu'à la fin de la ligne. Cette
facilite la documentation de paquet() modèles.

Faible
Dans les versions précédentes de Perl, vous ne pouviez pas mettre en cache les objets afin de permettre leur suppression
si la dernière référence de l'extérieur du cache est supprimée. La référence dans le cache serait
tenir un compte de référence sur l'objet et les objets ne seraient jamais détruits.

Un autre problème familier est celui des références circulaires. Lorsqu'un objet se référence lui-même,
son compteur de référence ne descendrait jamais à zéro, et il ne serait pas détruit jusqu'à ce que le
le programme est sur le point de se terminer.

Les références faibles résolvent ce problème en vous permettant d'"affaiblir" n'importe quelle référence, c'est-à-dire de la rendre non
compte dans le décompte de référence. Lorsque la dernière référence non faible à un objet est
supprimé, l'objet est détruit et toutes les références faibles à l'objet sont
automatiquement undef-ed.

Pour utiliser cette fonctionnalité, vous avez besoin du package Devel::WeakRef de CPAN, qui contient
documentation supplémentaire.

REMARQUE : Il s'agit d'une fonctionnalité expérimentale. Les détails sont sujets à changement.

binaire numéros soutenu
Les nombres binaires sont désormais pris en charge en tant que littéraux, dans les formats s?printf et "oct()":

$réponse = 0b101010 ;
printf "La réponse est : %b\n", oct("0b101010");

Lvaleur sous-programmes
Les sous-routines peuvent désormais renvoyer des lvalues ​​modifiables. Voir "Sous-routines Lvalue" dans perlsub.

REMARQUE : Il s'agit d'une fonctionnalité expérimentale. Les détails sont sujets à changement.

Certain flèches Au cours de cette réunion, Matthew a obtenu de précieux conseils et Linda lui a demandé de la tenir au courant de ses progrès. be omis in en cours à travers
Perl permet désormais d'omettre la flèche dans de nombreuses constructions impliquant des appels de sous-programme
par des références. Par exemple, "$foo[10]->('foo')" peut maintenant être écrit
"$foo[10]('foo')". Ceci est assez similaire à la façon dont la flèche peut être omise de
"$foo[10]->{'foo'}". Notez cependant que la flèche est toujours requise pour
"foo(10)->('barre')".

Boolean affectation opérateurs sommes-nous le droit lvaleurs
Les constructions telles que "($a ||= 2) += 1" sont désormais autorisées.

existe() is soutenu on sous-programme noms
Le manuel de formation existe() Builtin fonctionne maintenant sur les noms de sous-programmes. Un sous-programme est considéré comme existant
s'il a été déclaré (même implicitement). Voir "existe" dans perlfunc pour des exemples.

existe() et delete () sommes-nous soutenu on tableau éléments
Le manuel de formation existe() et delete () Les fonctions intégrées fonctionnent désormais également sur des tableaux simples. Le comportement est
similaire à celui des éléments de hachage.

existe() peut être utilisé pour vérifier si un élément du tableau a été initialisé. Cela évite
éléments de tableau autovivifiants qui n'existent pas. Si le tableau est lié, le EXISTE() méthode
dans le package lié correspondant sera invoqué.

delete () peut être utilisé pour supprimer un élément du tableau et le retourner. L'élément de tableau
à cette position revient à son état non initialisé, de sorte que le test du même élément
avec existe() retournera faux. S'il se trouve que l'élément est celui de la fin, le
la taille du tableau diminue également jusqu'à l'élément le plus élevé qui teste vrai pour existe(), ou
0 si aucun de ces éléments n'est trouvé. Si le tableau est lié, le EFFACER() méthode dans le correspondant
package lié sera invoqué.

Voir "existe" dans perlfunc et "delete" dans perlfunc pour des exemples.

Pseudo-hachages travail mieux
Déréférencer certains types de valeurs de référence dans un pseudo-hash, comme "$ph->{foo}[1]",
a été accidentellement refusé. Cela a été corrigé.

Lorsqu'il est appliqué à un élément de pseudo-hash, existe() indique maintenant si la valeur spécifiée
existe, pas seulement si la clé est valide.

delete () fonctionne maintenant sur des pseudo-hachages. Lorsqu'on lui donne un élément ou une tranche de pseudo-hachage, il supprime
les valeurs correspondant aux clés (mais pas les clés elles-mêmes). Voir "Pseudo-hachages :
Utiliser un tableau comme hachage" dans perlref.

Les tranches de pseudo-hash avec des clés constantes sont désormais optimisées pour les recherches de tableau au moment de la compilation.

Les affectations de liste aux tranches de pseudo-hachage sont désormais prises en charge.

Le pragma "fields" permet désormais de créer des pseudo-hachages, via champs::nouveau() et
champs::phash(). Voir les champs.

REMARQUE : Le type de données pseudo-hachage continue d'être expérimental.
Se limiter aux éléments d'interface fournis par le
Fields pragma fournira une protection contre tout changement futur.

Automatique rinçage of sortie tampons
fourchette(), exécutable(), système(), qx// et pipe ouvrir()s maintenant vider les tampons de tous les fichiers ouverts pour
sortie lorsque l'opération a été tentée. Cela élimine principalement la mise en mémoire tampon confuse
incidents subis par les utilisateurs ignorant comment Perl gère en interne les E/S.

Ceci n'est pas pris en charge sur certaines plates-formes comme Solaris où un
l'implémentation de fflush(NULL) n'est pas disponible.

Rapidité diagnostic on dénué de sens descripteur de fichier
Des constructions telles que "open( )" et "fermer( )" sont des erreurs de compilation.
lu à partir de descripteurs de fichiers qui n'étaient ouverts que pour l'écriture produira désormais des avertissements (tout comme
l'écriture dans des descripteurs de fichiers en lecture seule le fait).

Où possible, tamponné données, mis au rebut grâce au dupé contribution descripteur de fichier
"open(NEW, "<&OLD")" tente maintenant de supprimer toutes les données précédemment lues et
tamponné en "OLD" avant de duper le manche. Sur les plates-formes où cela est autorisé, le
la prochaine opération de lecture sur "NEW" renverra les mêmes données que l'opération correspondante sur
"VIEILLE". Auparavant, il aurait renvoyé les données du début du disque suivant
bloquer à la place.

eof() a le même et les sites anciens la magie as <>
"eof()" retournerait vrai si aucune tentative de lecture à partir de "<>" n'avait encore été faite. "eof()" a
a été modifié pour avoir un peu de magie, il ouvre maintenant les fichiers "<>".

binmode() Vous pouvez be d'utiliser à set :crlf et :cru modes
binmode() accepte maintenant un deuxième argument qui spécifie une discipline pour le handle dans
question. Les deux pseudo-disciplines ":raw" et ":crlf" sont actuellement supportées sous DOS-
plateformes dérivées. Voir "binmode" dans perlfunc et ouvrir.

"-T" test de filet reconnaît UTF-8 codée fichiers as "texte"
L'algorithme utilisé pour le test de fichier "-T" a été amélioré pour identifier correctement l'UTF-8
contenu sous forme de "texte".

système(), recule et pipe ouvert maintenant Réfléchir exécutable() échec
Sous Unix et plates-formes similaires, système(), qx() et open(FOO, "cmd |") etc., sont implémentés
via fourchette() et exécutable(). Lorsque le sous-jacent exécutable() échoue, les versions antérieures n'ont pas signalé
correctement l'erreur, puisque le exécutable() se trouvait dans un processus différent.

Le processus enfant communique maintenant avec le parent au sujet de l'erreur lors du lancement du
commande externe, qui permet à ces constructions de retourner avec leur valeur d'erreur habituelle et
définir $!.

Agencement des diagnostic
Les numéros de ligne ne sont plus supprimés (dans les circonstances les plus probables) pendant la
phase de destruction.

Les diagnostics émis par le code exécuté dans des threads autres que le thread principal sont désormais
accompagné de l'ID du fil.

Les caractères nuls intégrés dans les diagnostics s'affichent désormais réellement. Ils avaient l'habitude de tronquer le
message dans les versions précédentes.

$foo::a et $foo::b sont désormais exemptés des avertissements "erreur de frappe possible" uniquement si sorte() is
rencontré dans le paquet "foo".

Les échappements alphabétiques non reconnus rencontrés lors de l'analyse des constructions de guillemets génèrent désormais un
attention, car ils peuvent adopter une nouvelle sémantique dans les versions ultérieures de Perl.

De nombreux diagnostics rapportent maintenant le fonctionnement interne dans lequel l'avertissement a été provoqué, comme
Sun:

Utilisation de la valeur non initialisée dans la concaténation (.) à (eval 1) ligne 1.
Utilisation de la valeur non initialisée en impression à (eval 1) ligne 1.

Les diagnostics qui se produisent dans eval peuvent également signaler le numéro de fichier et de ligne où le
eval est localisé, en plus du numéro de séquence eval et du numéro de ligne dans le
le texte évalué lui-même. Par example:

Pas assez d'arguments pour le scalaire à (eval 4)[newlib/perl5db.pl:1411] ligne 2, à EOF

Diagnostics suivre STDERR
La sortie de diagnostic va maintenant vers le fichier sur lequel le handle "STDERR" pointe, à la place
d'aller toujours au "stderr" de la bibliothèque d'exécution C sous-jacente.

Plus cohérent fermer à l'exécution humain
Sur les systèmes qui prennent en charge un indicateur de fermeture à l'exécution sur les descripteurs de fichiers, l'indicateur est désormais défini pour tout
poignées créées par tuyau(), paire de sockets(), socket ()et J'accepte(), si cela est justifié par
la valeur de $^F qui peut être en vigueur. Les versions antérieures ont négligé de définir le drapeau pour
poignées créées avec ces opérateurs. Voir "pipe" en perlfunc, "socketpair" en perlfunc,
"socket" dans perlfunc, "accept" dans perlfunc et "$^F" dans perlvar.

écrituresys() facilité d'utilisation
L'argument de longueur de "syswrite()" est devenu facultatif.

Rapidité syntaxe chèques on entre parenthèses unaire opérateurs
Des expressions telles que :

impression définie(&foo,&bar,&baz);
print uc("foo","bar","baz");
undef($foo,&bar);

était accidentellement autorisé dans les versions antérieures et produisait un comportement imprévisible.
Certains ont produit des avertissements auxiliaires lorsqu'ils sont utilisés de cette manière ; d'autres ont fait le mal en silence
chose.

Les formes entre parenthèses de la plupart des opérateurs unaires qui attendent un seul argument garantissent désormais
qu'ils ne sont pas appelés avec plus d'un argument, ce qui rend les cas indiqués ci-dessus syntaxe
les erreurs. Le comportement habituel de :

impression définie &foo, &bar, &baz;
print uc "foo", "bar", "baz" ;
undef $foo, &bar;

reste inchangé. Voir perlop.

Bit opérateurs soutenez plein indigène entier largeur
Les opérateurs de bits (& | ^ ~ << >>) opèrent maintenant sur toute la largeur intégrale native (l'exact
dont la taille est disponible dans $Config{ivsize}). Par exemple, si votre plate-forme est soit
64 bits nativement ou si Perl a été configuré pour utiliser des entiers 64 bits, ces opérations
s'appliquent à 8 octets (contre 4 octets sur les plates-formes 32 bits). Pour la portabilité, assurez-vous de
masquer les bits en excès dans le résultat de "~" unaire, par exemple, "~$x & 0xffffffff".

Agencement des Sécurité Caractéristiques
Plus d'opérations potentiellement dangereuses altèrent leurs résultats pour une sécurité améliorée.

Les champs "passwd" et "shell" renvoyés par le obtenir (), getpwnam()et getpwuid() sommes-nous
maintenant entaché, car l'utilisateur peut affecter son propre mot de passe crypté et son propre shell de connexion.

La variable modifiée par shmread(), et les messages renvoyés par msgrcv() (et son objet-
interface orientée IPC::SysV::Msg::rcv) sont également entachées, car d'autres
les processus peuvent modifier les messages et les segments de mémoire partagée à leurs propres fins néfastes.

Plus fonctionnel mot nu prototype (*)
Les prototypes Bareword ont été rationalisés pour leur permettre d'être utilisés pour remplacer les fonctions intégrées
qui acceptent les mots nus et les interprètent d'une manière spéciale, comme "exiger" ou "faire".

Les arguments prototypés comme « * » seront désormais visibles dans le sous-programme sous la forme d'un simple
scalaire ou comme référence à un typeglob. Voir "Prototypes" dans perlsub.

"exiger" et "faire" Au cours de cette réunion, Matthew a obtenu de précieux conseils et Linda lui a demandé de la tenir au courant de ses progrès. be remplacé
Les opérations "require" et "do 'file'" peuvent être remplacées localement en important des sous-routines de
le même nom dans le package en cours (ou globalement en les important dans le
CORE::GLOBAL :: espace de noms). Le remplacement de « require » affectera également « use », à condition que le
override est visible au moment de la compilation. Voir « Remplacer les fonctions intégrées » dans perlsub.

$^X les variables Au cours de cette réunion, Matthew a obtenu de précieux conseils et Linda lui a demandé de la tenir au courant de ses progrès. maintenant avons noms plus long que UN caractère
Auparavant, $^X était synonyme de ${"\cX"}, mais $^XY était une erreur de syntaxe. Maintenant variable
les noms qui commencent par un caractère de contrôle peuvent être arbitrairement longs. Cependant, pour
raisons de compatibilité, ces variables doit être écrit avec des accolades explicites, comme "${^XY}"
par example. "${^XYZ}" est synonyme de ${"\cXYZ"}. Noms de variables avec plus d'un
caractère de contrôle, tel que "${^XY^Z}", sont illégaux.

L'ancienne syntaxe n'a pas changé. Comme précédemment, `^X' peut être soit un contrôle littéral-X
caractère ou la séquence de deux caractères « caret » plus « X ». Lorsque les accolades sont omises, le
le nom de la variable s'arrête après le caractère de contrôle. Ainsi "$^XYZ" continue d'être synonyme
avec "$^X . "YZ"" comme avant.

Comme auparavant, les variables lexicales peuvent ne pas avoir de noms commençant par des caractères de contrôle. Comme
avant, les variables dont les noms commencent par un caractère de contrôle sont toujours forcées d'être dans
paquet 'principal'. Toutes ces variables sont réservées pour des extensions futures, à l'exception de celles qui
commencent par "^_", qui peuvent être utilisés par les programmes utilisateurs et sont garantis de ne pas acquérir
une signification particulière dans toute future version de Perl.

New variable $^C reflète "-c" interrupteur
$^C a une valeur booléenne qui indique si perl est exécuté en mode compilation uniquement (c'est-à-dire
via le commutateur "-c"). Étant donné que les blocs BEGIN sont exécutés dans de telles conditions, cette
La variable permet au code perl de déterminer si les actions qui n'ont de sens qu'en temps normal
courir sont justifiés. Voir perlvar.

New variable $^V contient Perl version as a un magnifique
$^V contient le numéro de version de Perl sous la forme d'une chaîne composée de caractères dont les ordinaux
correspondent aux numéros de version, c'est-à-dire v5.6.0. Cela peut être utilisé dans des comparaisons de chaînes.

Voir « Prise en charge des chaînes représentées comme un vecteur d'ordinaux » pour un exemple.

Optionnel Y2K avertissements
Si Perl est construit avec la macro cpp "PERL_Y2KWARN" définie, il émet des avertissements facultatifs
lors de la concaténation du nombre 19 avec un autre nombre.

Ce comportement doit être spécifiquement activé lors de l'exécution de Configure. Voir INSTALLER et
LISEZ-MOI.Y2K.

Arrays maintenant toujours interpoler développement entre guillemets instruments à cordes
Dans les chaînes entre guillemets doubles, les tableaux s'interpolent désormais, quoi qu'il arrive. Le comportement au début
versions de perl 5 était que les tableaux seraient interpolés en chaînes si le tableau avait été
mentionné avant que la chaîne ne soit compilée, sinon Perl déclencherait une compilation fatale.
erreur de temps. Dans les versions 5.000 à 5.003, l'erreur était

Le @exemple littéral nécessite désormais une barre oblique inverse

Dans les versions 5.004_01 à 5.6.0, l'erreur était

Dans la chaîne, @example doit maintenant être écrit sous la forme \@example

L'idée ici était d'habituer les gens à écrire "fred\@example.com" quand ils
voulaient un signe "@" littéral, tout comme ils ont toujours écrit "Rendez-moi mon \$5" quand
ils voulaient un signe "$" littéral.

A partir de 5.6.1, lorsque Perl voit maintenant un signe "@" dans une chaîne entre guillemets, il toujours
tente d'interpoler un tableau, que le tableau ait ou non été utilisé ou
déjà déclaré. L'erreur fatale a été rétrogradée en un avertissement facultatif :

Interpolation involontaire possible de @example dans la chaîne

Cela vous avertit que "[email protected]" va se transformer en " fred.com " si vous ne le faites pas
barre oblique inverse le "@". Voir http://perl.plover.com/at-error.html pour plus de détails sur le
histoire ici.

@- et @+ fournir début/fin compensations of regex allumettes
Les nouvelles variables magiques @- et @+ fournissent respectivement les décalages de début et de fin,
de $&, $1, $2, etc. Voir perlvar pour plus de détails.

Modules et Pragmatique

Modules
attributs
Bien qu'utilisé en interne par Perl comme un pragma, ce module fournit également un moyen de récupérer
attributs de sous-programme et de variable. Voir les attributs.

B La suite Perl Compiler a été largement retravaillée pour cette version. Plus de
la suite de tests Perl standard réussit lorsqu'elle est exécutée sous le compilateur, mais il y a toujours un
un chemin important à parcourir pour obtenir des exécutables compilés de qualité de production.

REMARQUE : La suite du compilateur reste très expérimentale. le
le code généré peut ne pas être correct, même lorsqu'il parvient à s'exécuter
sans erreurs.

référence
Dans l'ensemble, les résultats de Benchmark présentent une erreur moyenne plus faible et une meilleure précision de synchronisation.

Vous pouvez maintenant exécuter des tests pour n secondes au lieu de deviner le bon nombre de tests à
run : par exemple, timethes(-5, ...) exécutera chaque code pendant au moins 5 secondes CPU. Zéro comme
le "nombre de répétitions" signifie "pendant au moins 3 secondes CPU". Le format de sortie a
aussi changé. Par example:

utiliser Benchmark;$x=3;timethes(-5,{a=>sub{$x*$x},b=>sub{$x**2}})

va maintenant afficher quelque chose comme ceci :

Benchmark : exécuter a, b, chacun pendant au moins 5 secondes CPU...
a : 5 secondes d'horloge murale (5.77 usr + 0.00 sys = 5.77 CPU) à 200551.91/s (n=1156516)
b : 4 secondes d'horloge murale ( 5.00 usr + 0.02 sys = 5.02 CPU) à 159605.18/s (n=800686)

Nouvelles fonctionnalités : "chacun pendant au moins N secondes CPU...", "wallclock secs", et le "@
opérations/CPU seconde (n=opérations)".

tempsces() renvoie maintenant une référence à un hachage d'objets Benchmark contenant le test
résultats, indexés sur les noms des tests.

cette fois-ci() renvoie désormais le champ d'itérations dans l'objet de résultat Benchmark au lieu de
0.

tempsces(), cette fois-ci(), Et la nouvelle cmpthèse() (voir ci-dessous) peut également prendre un format
spécificateur de « aucun » pour supprimer la sortie.

Une nouvelle fonction compte le() est juste comme le temps() sauf que cela prend du TEMPS au lieu de
un COMPTE.

Une nouvelle fonction cmpthèse() imprime un graphique comparant les résultats de chaque test renvoyé
d'un tempsces() appeler. Pour chaque paire de tests possible, le pourcentage de vitesse
la différence (itres/sec ou secondes/iter) s'affiche.

Pour plus de détails, voir Benchmark.

Chargeur d'octets
Le ByteLoader est une extension dédiée pour générer et exécuter le bytecode Perl. Voir
Chargeur d'octets.

constant
Les références peuvent maintenant être utilisées.

La nouvelle version autorise également un trait de soulignement de début dans les noms constants, mais interdit un
double trait de soulignement (comme dans "__LINE__"). Certains autres noms sont interdits ou
mis en garde contre, y compris BEGIN, END, etc. Certains noms qui ont été forcés dans main :
utilisé pour échouer silencieusement dans certains cas; maintenant, ils sont fatals (en dehors de main::) et un
avertissement facultatif (à l'intérieur de main::). La capacité de détecter si une constante avait
été défini avec un nom donné a été ajouté.

Voir constante.

noms de personnages
Ce pragma implémente l'échappement de chaîne "\N". Voir les prénoms.

Données::Dumper
Un paramètre "Maxdepth" peut être spécifié pour éviter de s'aventurer trop profondément dans les données profondes
structure. Voir Données::Dumper.

L'implémentation XSUB de Décharger() est maintenant appelé automatiquement si le paramètre "Useqq"
n'est pas utilisé.

Le vidage des objets "qr//" fonctionne correctement.

DB "DB" est un module expérimental qui expose une abstraction propre au débogage de Perl
API.

DB_Fichier
DB_File peut maintenant être construit avec Berkeley DB versions 1, 2 ou 3. Voir
"ext/DB_File/Changes".

Développeur ::DProf
Devel::DProf, un profileur de code source Perl a été ajouté. Voir Devel::DProf et
dprofpp.

Développeur ::Coup d'oeil
Le module Devel::Peek donne accès à la représentation interne de Perl
variables et données. C'est un outil de débogage de données pour le programmeur XS.

Valeur de vidage
Le module Dumpvalue fournit des copies d'écran des données Perl.

DynaLoader
DynaLoader prend désormais en charge un dl_unload_file() fonctionner sur des plates-formes prenant en charge
déchargement d'objets partagés à l'aide dlclose().

Perl peut également s'arranger pour décharger tous les objets partagés d'extension chargés par
Perl. Pour activer cela, construisez Perl avec l'option Configurer
"-Accflags=-DDL_UNLOAD_ALL_AT_EXIT". (Cela peut être utile si vous utilisez Apache avec
mod_perl.)

Anglais
$PERL_VERSION représente désormais $^V (une valeur de chaîne) plutôt que $] (une valeur numérique
valeur).

Env Env prend désormais en charge l'accès aux variables d'environnement telles que PATH en tant que variables de tableau.

Fonction
Plus de constantes Fcntl ajoutées : F_SETLK64, F_SETLKW64, O_LARGEFILE pour les fichiers volumineux (plus
plus de 4 Go) accès (REMARQUE : le fichier O_LARGEFILE est automatiquement ajouté à sysopen() drapeaux si
la prise en charge des fichiers volumineux a été configurée, comme par défaut), verrouillage Free/Net/OpenBSD
indicateurs de comportement F_FLOCK, F_POSIX, Linux F_SHLCK et O_ACCMODE : le masque combiné de
O_RDONLY, O_WRONLY et O_RDWR. le chercher()/recherche système() constantes SEEK_SET, SEEK_CUR,
et SEEK_END sont disponibles via la balise ":seek". le mod()/stat () constantes S_IF*
et les fonctions S_IS* sont disponibles via la balise ":mode".

Fichier::Comparer
A comparer_texte() fonction a été ajoutée, ce qui permet des fonctions de comparaison personnalisées.
Voir Fichier::Comparer.

Fichier::Rechercher
File::Find fonctionne désormais correctement lorsque le voulait() la fonction est soit chargée automatiquement, soit une
référence symbolique.

Un bogue qui faisait que File::Find perdait la trace du répertoire de travail lors de l'élagage top-
répertoires de niveau a été corrigé.

File::Find prend désormais en charge plusieurs autres options pour contrôler son comportement. Ça peut
suivre les liens symboliques si l'option "suivre" est spécifiée. Activer le "no_chdir"
L'option fera File::Find ignorer le changement de répertoire actuel lors de la marche
répertoires. L'indicateur "untaint" peut être utile lors de l'exécution avec les vérifications de souillure activées.

Voir Fichier::Rechercher.

Fichier::Globe
Cette extension implémente la globalisation de fichiers de style BSD. Par défaut, il sera également utilisé
pour la mise en œuvre interne de la globe () opérateur. Voir Fichier::Glob.

Fichier::Spéc.
De nouvelles méthodes ont été ajoutées au module File::Spec : devnull() renvoie le nom de
le périphérique null (/dev/null sous Unix) et tmpdir() le nom du répertoire temporaire
(normalement / Tmp sous Unix). Il existe maintenant également des méthodes pour convertir entre absolu et
noms de fichiers relatifs : abs2rel() et rel2abs(). Pour la compatibilité avec les systèmes d'exploitation
qui spécifient les noms de volumes dans les chemins de fichiers, le chemin divisé(), splitdir()et rép_cat()
des méthodes ont été ajoutées.

Fichier::Spec::Fonctions
Le nouveau module File::Spec::Functions fournit une interface de fonction au File::Spec
module. Permet la sténographie

$nom complet = catfile($dir1, $dir2, $file);

au lieu de

$fullname = File::Spec->catfile($dir1, $dir2, $file);

Getopt :: Long
Getopt::Long License a changé pour permettre la Perl Artististic License ainsi que le
GPL. Auparavant, il s'agissait uniquement de GPL, ce qui gênait les applications non GPL qui voulaient
pour utiliser Getopt::Long.

Getopt::Long encourage l'utilisation de Pod::Usage pour produire des messages d'aide. Par example:

utilisez Getopt::Long;
utiliser Pod::Usage;
mon $man = 0 ;
mon $help = 0 ;
GetOptions('help|?' => \$help, man => \$man) ou pod2usage(2);
pod2usage(1) si $help ;
pod2usage(-exitstatus => 0, -verbose => 2) si $man ;

__FINIR__

=head1 NOM

sample - Utilisation de Getopt::Long et Pod::Usage

=head1 RÉSUMÉ

exemple [options] [fichier ...]

Options :
-aide bref message d'aide
-man documentation complète

=tête1 OPTIONS

=plus de 8

=item B<-help>

Imprimez un bref message d'aide et quittez.

=item B<-homme>

Imprime la page de manuel et quitte.

= retour

=tête1 DESCRIPTION

B lira le(s) fichier(s) d'entrée donné(s) et fera quelque chose
utile avec son contenu.

=couper

Voir Pod::Usage pour plus de détails.

Un bogue qui empêchait le rappel non optionnel <> d'être spécifié comme premier
l'argument a été corrigé.

Pour spécifier les caractères < et > comme entrées d'options, utilisez ><. Notez cependant que
la modification des démarreurs d'options est fortement déconseillée.

IO écrire () et écrituresys() acceptera désormais une forme à argument unique de l'appel, par exemple
cohérence avec Perl écrituresys().

Vous pouvez désormais créer un IO::Socket::INET basé sur TCP sans forcer une tentative de connexion.
Cela vous permet de configurer ses options (comme le rendre non bloquant) puis d'appeler
relier () manuellement.

Un bug qui empêchait le IO::Socket::protocole() accesseur de ne jamais retourner le
la valeur correcte a été corrigée.

IO::Socket::connect utilise désormais des IO non bloquants au lieu de alarme() se connecter
délais d'attente.

IO::Socket::accept utilise maintenant sélectionner() au lieu de alarme() pour faire des temps morts.

IO::Socket::INET->nouveau définit maintenant $! correctement en cas d'échec. $@ est toujours défini pour l'arrière
compatibilité.

JPL Java Perl Lingo est maintenant distribué avec Perl. Voir jpl/README pour plus d'informations.

lib "use lib" élimine désormais toutes les entrées en double à la fin. "no lib" supprime tous les noms
entrées.

Math :: BigInt
Les opérations au niveau du bit "<<", ">>", "&", "|" et "~" sont désormais prises en charge sur les bigints.

Mathématiques::Complexe
Les méthodes d'accès Re, Im, arg, abs, rho et theta peuvent désormais également agir comme des mutateurs
(accesseur $z->Ré(), mutateur $z->Re(3)).

La méthode de classe "display_format" et la méthode d'objet correspondante
"display_format", en plus d'accepter un seul argument, peut maintenant aussi accepter un
hachage de paramètre. Les clés reconnues d'un hachage de paramètre sont "style", qui correspond à
l'ancien cas à un paramètre, et deux nouveaux paramètres : "format", qui est un
printf ()-style chaîne de format (la valeur par défaut est généralement "%.15g", vous pouvez revenir à la
par défaut en définissant la chaîne de format sur "undef") utilisée pour les deux parties d'un complexe
nombre, et "polar_pretty_print" (par défaut à true), qui contrôle si une tentative
est fait pour essayer de reconnaître les petits multiples et les rationnels de pi (2pi, pi/2) au
argument (angle) d'un nombre complexe polaire.

Le changement potentiellement perturbateur est que, dans le contexte de la liste, les deux méthodes sont désormais retourner le
paramètre hachage, au lieu de la seule valeur du paramètre "style".

Mathématiques :: Trig
Un peu de trigonométrie radiale (cylindrique et sphérique), coordonnée radiale
conversions, et la distance du grand cercle ont été ajoutées.

Pod :: Analyseur, Pod :: InputObjects
Pod::Parser est une classe de base pour analyser et sélectionner des sections de la documentation du pod
à partir d'un flux d'entrée. Ce module s'occupe d'identifier les paragraphes de pod et
commandes dans l'entrée et transfère les paragraphes et les commandes analysés aux commandes définies par l'utilisateur
des méthodes libres de les interpréter ou de les traduire comme bon leur semble.

Pod::InputObjects définit certains objets d'entrée nécessaires à Pod::Parser, et pour les
les utilisateurs de Pod::Parser qui ont besoin de plus d'informations sur une commande en plus de son nom et de son texte.

Depuis la version 5.6.0 de Perl, Pod::Parser est désormais l'"analyseur de base" officiellement sanctionné
code" recommandé pour tous les traducteurs pod2xxx. Pod::Text (pod2text) et
Pod::Man (pod2man) ont déjà été convertis pour utiliser Pod::Parser et des efforts pour
convert Pod::HTML (pod2html) sont déjà en cours. Pour toutes questions ou commentaires
à propos de l'analyse des pods et des problèmes de traduction et des utilitaires, veuillez utiliser le
[email protected] liste de diffusion.

Pour plus d'informations, veuillez consulter Pod::Parser et Pod::InputObjects.

Pod :: Vérificateur, vérificateur de pod
Cet utilitaire vérifie la syntaxe correcte des fichiers pod, selon perlpod. Évident
les erreurs sont signalées comme telles, tandis que des avertissements sont imprimés pour les erreurs qui peuvent être
traité avec grâce. La liste de contrôle n'est pas encore complète. Voir Pod :: Checker.

Pod :: ParseUtils, Pod :: Find
Ces modules fournissent un ensemble de gadgets utiles principalement pour les traducteurs de pods.
Pod::Find parcourt les structures de répertoires et renvoie les fichiers de pod trouvés, ainsi que leurs
noms canoniques (comme "File::Spec::Unix"). Pod::ParseUtils contient Pod::Liste (utile
pour stocker les informations de la liste des pods), Pod::Lien hypertexte (pour analyser le contenu de "L<>"
séquences) et Pod :: Cache (pour mettre en cache des informations sur les fichiers pod, par exemple, les nœuds de lien).

Pod ::Sélectionner, podselect
Pod::Select est une sous-classe de Pod::Parser qui fournit une fonction nommée "podselect()"
pour filtrer les sections spécifiées par l'utilisateur de la documentation brute du pod à partir d'un flux d'entrée.
podselect est un script qui permet d'accéder à Pod::Select parmi d'autres scripts à
utilisé comme filtre. Voir Pod::Select.

Pod :: Utilisation, pod2usage
Pod::Usage fournit la fonction "pod2usage()" pour imprimer les messages d'utilisation d'un Perl
script basé sur sa documentation de pod intégrée. le pod2usage() la fonction est généralement
utile à tous les auteurs de scripts car il leur permet d'écrire et de maintenir une seule source
(les pods) pour la documentation, éliminant ainsi le besoin de créer et de maintenir des fichiers redondants
texte du message d'utilisation composé d'informations déjà présentes dans les pods.

Il existe également un script pod2usage qui peut être utilisé à partir d'autres types de scripts pour
imprimer les messages d'utilisation des pods (même pour les scripts non-Perl avec des pods intégrés dans
commentaires).

Pour plus de détails et des exemples, veuillez consulter Pod::Usage.

Pod::Text et Pod::Man
Pod::Text a été réécrit pour utiliser Pod::Parser. Tandis que pod2text() est encore disponible
pour une compatibilité descendante, le module dispose désormais d'une nouvelle interface préférée. Voir
Pod : : Texte pour les détails. Le nouveau module Pod::Text est facilement sous-classé pour des ajustements
à la sortie, et deux de ces sous-classes (Pod::Text::Termcap pour le gras de style page de manuel et
soulignement à l'aide des informations termcap et Pod::Text::Color pour le balisage avec la couleur ANSI
séquences) sont désormais standard.

pod2man a été transformé en un module, Pod::Man, qui utilise également Pod::Parser. Dans le
processus, plusieurs bogues en suspens liés aux citations dans les en-têtes de section, citation de
les échappements de code et les listes imbriquées ont été corrigés. pod2man est maintenant un script wrapper
autour de ce module.

Fichier_SDBM
Une méthode EXISTS a été ajoutée à ce module (et sdbm_exists() a été ajouté à
la bibliothèque sdbm sous-jacente), donc on peut maintenant appeler existe sur un hachage lié SDBM_File et
obtenir le résultat correct, plutôt qu'une erreur d'exécution.

Un bogue qui peut avoir causé une perte de données lorsque plus d'un bloc de disque est lu
de la base de données en un seul ALLER CHERCHER() a été réparé.

Sys :: Syslog
Sys::Syslog utilise désormais des XSUB pour accéder aux fonctionnalités de syslog.h, il n'en a donc plus besoin
syslog.ph existe.

Sys::Nom d'hôte
Sys::Hostname utilise maintenant des XSUB pour appeler la bibliothèque C obtenir le nom d'hôte() or ton nom() si ils
exister.

Terme : : ANSICouleur
Term::ANSICor est un module très simple pour fournir un accès facile et lisible au
Couleur ANSI et séquences d'échappement de surbrillance, prises en charge par la plupart des terminaux ANSI
émulateurs. Il est maintenant inclus en standard.

Heure::Local
Le manuel de formation heurelocale() et heuregm() fonctions utilisées pour renvoyer silencieusement de faux résultats lorsque le
la date est tombée en dehors de la plage d'entiers de la machine. Ils sont désormais systématiquement crever() si le
la date se situe dans une plage non prise en charge.

Win32
La valeur de retour d'erreur dans le contexte de la liste a été modifiée pour toutes les fonctions qui renvoient
une liste de valeurs. Auparavant, ces fonctions renvoyaient une liste avec un seul élément
"undef" si une erreur s'est produite. Maintenant, ces fonctions renvoient la liste vide dans ces
situations. Ceci s'applique aux fonctions suivantes :

Win32 ::FsType
Win32 :: GetOSVersion

Les fonctions restantes sont inchangées et continuent à renvoyer "undef" en cas d'erreur même dans
contexte de liste.

La fonction Win32::SetLastError(ERROR) a été ajoutée en complément de la
Win32 :: GetLastError () la fonction.

Le nouveau Win32::GetFullPathName(FILENAME) renvoie le chemin d'accès absolu complet pour
FILENAME dans un contexte scalaire. Dans le contexte de la liste, il renvoie une liste à deux éléments contenant
le nom de répertoire complet et le nom de fichier. Voir Win32.

Chargeur XS
L'extension XSLoader est une alternative plus simple à DynaLoader. Voir XSLoader.

Filtres DBM
Une nouvelle fonctionnalité appelée "Filtres DBM" a été ajoutée à tous les modules DBM--DB_File,
GDBM_File, NDBM_File, ODBM_File et SDBM_File. Les filtres DBM ajoutent quatre nouvelles méthodes à
chaque module DBM :

filtre_store_key
filtre_store_value
filtre_fetch_key
filtre_fetch_value

Ceux-ci peuvent être utilisés pour filtrer les paires clé-valeur avant que les paires ne soient écrites dans le
base de données ou juste après leur lecture à partir de la base de données. Voir perldbmfilter pour plus
</br>L’Information.

Pragmatique
"use attrs" est désormais obsolète et n'est fourni qu'à des fins de compatibilité descendante. C'était
remplacé par la syntaxe "sub :attributs". Voir « Attributs de sous-programmes » dans perlsub et
attributs.

Le pragma des avertissements lexicaux, « use warnings ; », pour contrôler les avertissements facultatifs. Voir perllexwarn.

"use filetest" pour contrôler le comportement des filetests ("-r" "-w" ...). Actuellement un seul
subpragma implémenté, "use filetest 'access';", qui utilise accès(2) ou équivalent à
vérifier les autorisations au lieu d'utiliser état(2) comme d'habitude. Cela est important dans les systèmes de fichiers où
il existe des ACL (listes de contrôle d'accès) : état(2) peut mentir, mais accès(2) sait mieux.

Le pragma "open" peut être utilisé pour spécifier des disciplines par défaut pour les constructeurs de handles (par exemple
ouvrir()) et pour qx//. Les deux pseudo-disciplines ":raw" et ":crlf" sont actuellement
pris en charge sur les plates-formes dérivées du DOS (c'est-à-dire où binmode n'est pas un no-op). Voir également
"binmode() peut être utilisé pour définir les modes :crlf et :raw".

Services Publics Modifications

dprofpp
"dprofpp" est utilisé pour afficher les données de profil générées à l'aide de "Devel::DProf". Voir dprofpp.

trouver2perl
L'utilitaire "find2perl" utilise maintenant les fonctionnalités améliorées du module File::Find. le
Les options -depth et -follow sont prises en charge. La documentation du pod est également incluse dans le
scripts.

h2xs
L'outil "h2xs" peut désormais fonctionner en conjonction avec "C::Scan" (disponible sur CPAN) pour
analyser automatiquement les fichiers d'en-tête réels. Les options "-M", "-a", "-k" et "-o" sont
neuf.

perlcc
"perlcc" prend désormais en charge les backends C et Bytecode. Par défaut, il génère une sortie à partir de
le backend C simple plutôt que le backend C optimisé.

La prise en charge des plates-formes non Unix a été améliorée.

perldoc
"perldoc" a été retravaillé pour éviter d'éventuelles failles de sécurité. Il ne laissera pas par défaut
lui-même être exécuté en tant que superutilisateur, mais vous pouvez toujours utiliser le -U interrupteur pour essayer de le faire tomber
privilèges d'abord.

Le manuel de formation Perl Debugger
De nombreuses corrections de bugs et améliorations ont été ajoutées à perl5db.pl, le débogueur Perl. L'aide
la documentation a été réorganisée. Les nouvelles commandes incluent "< ?", "> ?" et "{ ?" lister
actions en cours, « l'homme page de documentation" pour exécuter votre visionneuse de documents sur un ensemble de documents perl et la prise en charge de
options citées. Les informations d'aide ont été réorganisées et devraient être à nouveau visibles si
vous utilisez moins comme votre téléavertisseur. Une faille de sécurité sérieuse a été bouchée--vous devriez
supprimer immédiatement toutes les anciennes versions du débogueur Perl tel qu'installé dans la précédente
les versions, jusqu'à perl3, de votre système pour éviter d'être mordu par cela.

Agencement des Documentation

De nombreux fichiers README spécifiques à la plate-forme font désormais partie de l'installation de perl. Voir
perl pour la liste complète.

perlapi.pod
La liste officielle des fonctions publiques de l'API Perl.

perlboot.pod
Un tutoriel pour les débutants sur Perl orienté objet.

perlcompile.pod
Une introduction à l'utilisation de la suite Perl Compiler.

perldbmfilter.pod
Un document pratique sur l'utilisation de la fonction de filtrage DBM.

perldebug.pod
Tout le matériel sans rapport avec l'exécution du débogueur Perl, ainsi que tout le contenu de bas niveau
les détails qui risquaient d'écraser l'utilisateur occasionnel du débogueur, ont été déplacés de
l'ancienne page de manuel à l'entrée suivante ci-dessous.

perldebguts.pod
Cette nouvelle page de manuel contient du matériel de niveau excessivement bas non lié au Perl
débogueur, mais légèrement lié au débogage de Perl lui-même. Il contient également des arcanes
détails internes sur le fonctionnement du processus de débogage qui peuvent n'être intéressants que pour
développeurs de débogueurs Perl.

perlfork.pod
Notes sur le fourchette() émulation actuellement disponible pour la plate-forme Windows.

perlfilter.pod
Une introduction à l'écriture de filtres source Perl.

perlhack.pod
Quelques directives pour pirater le code source de Perl.

perlintern.pod
Une liste de fonctions internes dans le code source Perl. (La liste est actuellement vide.)

perllexwarn.pod
Informations d'introduction et de référence sur les catégories d'avertissement à portée lexicale.

numéroperl.pod
Informations détaillées sur les nombres tels qu'ils sont représentés en Perl.

perlopentut.pod
Un tutoriel sur l'utilisation ouvrir() de manière efficace.

perlreftut.pod
Un tutoriel qui présente l'essentiel des références.

perltootc.pod
Un tutoriel sur la gestion des données de classe pour les modules objet.

perltodo.pod
Discussion sur les fonctionnalités les plus souvent recherchées qui pourraient un jour être prises en charge par Perl.

perlunicode.pod
Une introduction aux fonctionnalités de prise en charge d'Unicode dans Perl.

Arts de la scène améliorations

Simple sorte() grâce à { $a <=> $b } et le comme sommes-nous optimisé
Beaucoup de commun sorte() les opérations à l'aide d'un simple bloc inline sont désormais optimisées pour accélérer
la performance.

Optimisé missions à lexical les variables
Certaines opérations dans le RHS des instructions d'affectation ont été optimisées pour définir directement
la variable lexicale sur le LHS, éliminant les frais généraux de copie redondants.

Plus rapide sous-programme en cours
Des changements mineurs dans la façon dont les appels de sous-programme sont traités en interne offrent des améliorations marginales
en performance.

delete (), chaque(), valeurs () et hachage itération sommes-nous plus rapide
Les valeurs de hachage renvoyées par delete (), chaque(), valeurs () et les hachages dans un contexte de liste sont
les valeurs réelles dans le hachage, au lieu de copies. Cela se traduit par une bien meilleure
performances, car il élimine les copies inutiles dans la plupart des situations.

en un clic et Configuration Améliorations

-Dusthreads veux dire quelque chose différent
L'indicateur -Dusethreads active désormais la prise en charge expérimentale des threads basée sur un interpréteur en
défaut. Pour obtenir la saveur des fils expérimentaux qui étaient dans 5.005 à la place, vous devez
exécutez Configure avec "-Dusethreads -Duse5005threads".

Depuis la version 5.6.0, la prise en charge des threads d'interprétation manque toujours de moyen de créer de nouveaux threads
de Perl (c'est-à-dire, "use Thread;" ne fonctionnera pas avec les threads interpréteurs). "utiliser le fil ;"
continue d'être disponible lorsque vous spécifiez l'option -Duse5005threads pour Configurer, les bogues
et tout.

REMARQUE : la prise en charge des threads reste une fonctionnalité expérimentale.
Les interfaces et la mise en œuvre sont soumises à des changements soudains et drastiques.

New Configurez drapeaux
Les nouveaux indicateurs suivants peuvent être activés sur la ligne de commande Configure en exécutant Configure
avec "-Dflag".

utiliser la multiplicité
usethreads useithreads (nouveaux threads d'interprétation : pas encore d'API Perl)
usethreads use5005threads (threads tels qu'ils étaient dans 5.005)

use64bitint (égal à 'use64bits' désormais obsolète)
utiliser64bitall

utiliserlongdouble
utiliserplus de bits
utiliser de gros fichiers
useocks (seulement SOCKS v5 pris en charge)

Filetage et 64 bits maintenant plus audacieux
Les options de configuration permettant l'utilisation de threads et l'utilisation de 64 bits sont désormais plus
audacieux dans le sens où ils n'ont plus de liste explicite des systèmes d'exploitation connus
threads/capacités 64 bits. En d'autres termes : si votre système d'exploitation dispose des
API et types de données, vous devriez pouvoir simplement les utiliser, pour les threads par
Configure -Dusethreads, et pour 64 bits soit explicitement par Configure -Duse64bitint ou
implicitement si votre système a des types de données de 64 bits. Voir aussi "Prise en charge 64 bits".

Long Double
Certaines plates-formes ont des « doubles longs », des nombres à virgule flottante d'une portée encore plus grande que
"doubles" ordinaires. Pour activer l'utilisation de longs doubles pour les scalaires de Perl, utilisez -Duselongdouble.

-Dusemorebits
Vous pouvez activer à la fois -Duse64bitint et -Duselongdouble avec -Dusemorebits. Voir également
« prise en charge 64 bits ».

-D'utiliserdes fichiers volumineux
Certaines plates-formes prennent en charge des API système capables de gérer des fichiers volumineux (généralement,
fichiers de plus de deux gigaoctets). Perl essaiera d'utiliser ces API si vous demandez
-D'utiliserdes fichiers volumineux.

Voir « Prise en charge des fichiers volumineux » pour plus d'informations.

installerusrbinperl
Vous pouvez utiliser "Configure -Uinstallusrbinperl" qui fait que installperl ignore l'installation
perl aussi comme /usr/bin/perl. Ceci est utile si vous préférez ne pas modifier / usr / bin pour certains
raison ou une autre mais nuisible car de nombreux scripts supposent de trouver Perl dans /usr/bin/perl.

CHAUSSETTES soutenez
Vous pouvez utiliser "Configure -Dusesocks" qui amène Perl à rechercher le protocole proxy SOCKS
bibliothèque (v5, pas v4). Pour plus d'informations sur SOCKS, voir :

http://www.socks.nec.com/

"-UNE" drapeau
Vous pouvez "post-éditer" les variables Configure à l'aide du commutateur Configure "-A". L'édition
se produit immédiatement après que les fichiers d'indices spécifiques à la plate-forme ont été traités mais avant
le processus de configuration proprement dit démarre. Exécutez "Configurer -h" pour connaître le "-A" complet
syntaxe.

Renforcer la compréhension en un clic Partages de fichiers
La structure de l'installation a été enrichie pour améliorer le support pour le maintien
plusieurs versions de perl, pour fournir des emplacements pour les modules, scripts et
pages de manuel et pour faciliter la maintenance des modules, scripts et pages de manuel ajoutés localement. Voir
la section sur les répertoires d'installation dans le fichier INSTALL pour plus de détails. Pour
la plupart des utilisateurs construisent et installent à partir des sources, les valeurs par défaut devraient être correctes.

Si vous avez précédemment utilisé "Configure -Dsitelib" ou "-Dsitearch" pour définir des valeurs spéciales pour
répertoires de bibliothèque, vous pouvez envisager d'utiliser le nouveau paramètre "-Dsiteprefix"
plutôt. De plus, si vous souhaitez réutiliser un fichier config.sh d'une version antérieure de perl,
vous devez être sûr de vérifier que Configure fait des choix judicieux pour les nouveaux répertoires.
Voir INSTALLER pour plus de détails.

Plateforme groupe de neurones change

Appareils plates-formes
· Les Mach CThreads (NEXTSTEP, OPENSTEP) sont désormais pris en charge par l'extension Thread.

· GNU/Hurd est désormais pris en charge.

· Rhapsody/Darwin est désormais pris en charge.

· EPOC est désormais pris en charge (sur Psion 5).

· Le port cygwin (anciennement cygwin32) a été grandement amélioré.

DOS
· Perl fonctionne maintenant avec djgpp 2.02 (et 2.03 alpha).

· Les noms de variables d'environnement ne sont plus convertis en majuscules.

· Les codes de sortie incorrects des backticks ont été corrigés.

· Ce port continue à utiliser son propre globbing intégré (pas File::Glob).

OS390 (OpenEdition MVS)
La prise en charge de cette plate-forme EBCDIC n'a pas été renouvelée dans cette version. Il y a
difficultés à concilier la standardisation de Perl sur UTF-8 comme sa représentation interne
pour les caractères avec le jeu de caractères EBCDIC, car les deux sont incompatibles.

Il n'est pas clair si les futures versions renouvelleront la prise en charge de cette plate-forme, mais le
possibilité existe.

VMS
Nombreuses révisions et extensions pour la configuration, la construction, les tests et l'installation
processus pour s'adapter aux changements de base et aux options spécifiques au VMS.

Développez le code de gestion %ENV pour permettre le mappage d'exécution vers les noms logiques, les symboles CLI et la CRTL
tableau environ.

Extension du code d'invocation de sous-processus pour accepter les spécifications de fichier comme "verbes" de commande.

Ajouter au traitement de la ligne de commande Perl la possibilité d'utiliser les types de fichiers par défaut et de reconnaître
"2>&1" de style Unix.

Extension des routines File::Spec::VMS et intégration dans ExtUtils::MM_VMS.

Extension d'ExtUtils::MM_VMS pour gérer les extensions complexes de manière plus flexible.

Les mots nus au début des chemins de syntaxe Unix peuvent être traités comme du texte plutôt que comme uniquement logiques
des noms.

Traduction sécurisée facultative de plusieurs noms logiques utilisés en interne par Perl.

Correction de bugs divers et portage du nouveau code de base vers VMS.

Nous remercions volontiers les nombreuses personnes qui ont contribué aux correctifs VMS, aux tests,
et des idées.

Win32
Perl peut maintenant émuler fourchette() en interne, à l'aide de plusieurs interpréteurs s'exécutant dans différents
threads concurrents. Cette prise en charge doit être activée au moment de la génération. Voir perlfork pour
des informations détaillées.

Lorsqu'on lui donne un nom de chemin qui se compose uniquement d'un nom de lecteur, tel que "A :", opendir() et
stat () utilisez maintenant le répertoire de travail actuel pour le lecteur plutôt que la racine du lecteur.

Les fonctions XSUB intégrées dans l'espace de noms Win32 :: sont documentées. Voir Win32.

$^X contient maintenant le nom de chemin complet de l'exécutable en cours d'exécution.

A Win32 :: GetLongPathName() fonction est fournie pour compléter Win32 :: GetFullPathName() et
Win32 :: GetShortPathName(). Voir Win32.

POSIX ::uname() est pris en charge.

system(1,...) renvoie désormais de véritables ID de processus plutôt que des descripteurs de processus. tuer() accepte
n'importe quel identifiant de processus réel, plutôt que de renvoyer strictement les valeurs de system(1,...).

Pour une meilleure compatibilité avec Unix, "kill(0, $pid)" peut maintenant être utilisé pour tester si un
processus existe.

Le module "Shell" est pris en charge.

Un meilleur support pour la construction de Perl sous command.com dans Windows 95 a été ajouté.

Les scripts sont lus en mode binaire par défaut pour autoriser ByteLoader (et le mécanisme de filtrage
en général) pour fonctionner correctement. Pour des raisons de compatibilité, le descripteur de fichier DATA sera défini sur texte
mode si un retour chariot est détecté à la fin de la ligne contenant le __END__ ou
jeton __DATA__ ; sinon, le descripteur de fichier DATA restera ouvert en mode binaire. Plus tôt
versions ouvraient toujours le descripteur de fichier DATA en mode texte.

Le manuel de formation globe () opérateur est implémenté via l'extension "File::Glob", qui prend en charge glob
syntaxe du shell C. Cela augmente la flexibilité du globe () opérateur, mais il
peuvent être des problèmes de compatibilité pour les programmes qui reposaient sur l'ancienne syntaxe de globalisation. Si vous
voulez préserver la compatibilité avec l'ancienne syntaxe, vous voudrez peut-être exécuter perl avec
"-MFile::DosGlob". Pour plus de détails et d'informations sur la compatibilité, voir File::Glob.

Important bug correctifs

on vide fichiers
Avec $/ défini sur "undef", "slurping" un fichier vide renvoie une chaîne de longueur zéro (au lieu de
de "undef", comme c'était le cas) la première fois que le HANDLE est lu après que $/ est défini sur "undef".
D'autres lectures donnent "undef".

Cela signifie que ce qui suit ajoutera "foo" à un fichier vide (il ne faisait rien auparavant) :

perl -0777 -pi -e 's/^/foo/' fichier_vide

Le comportement de :

perl -pi -e 's/^/foo/' fichier_vide

est inchangé (il continue à laisser le fichier vide).

" eval '...'" améliorations
Numéros de ligne (comme reflété par votre interlocuteur() et la plupart des diagnostics) dans "eval '...'" étaient
souvent incorrect lorsqu'il s'agit de documents. Cela a été corrigé.

Recherches lexicales pour les variables apparaissant dans "eval '...'" dans les fonctions qui ont été
eux-mêmes appelés dans un "eval '...'" cherchaient le mauvais endroit pour les lexiques. le
la recherche lexicale se termine désormais correctement à la limite du bloc du sous-programme.

L'utilisation de "return" dans "eval {...}" a empêché $@ d'être réinitialisé correctement lorsqu'aucun
une exception s'est produite dans l'eval. Cela a été corrigé.

L'analyse de ces documents était autrefois imparfaite lorsqu'ils apparaissaient en remplacement
expression dans "eval 's/.../.../e'". Cela a été corrigé.

Tous compilation erreurs sommes-nous oui erreurs
Certaines « erreurs » rencontrées au moment de la compilation ont été générées par nécessité car des avertissements ont suivi
par la fin éventuelle du programme. Cela a permis de signaler davantage d'erreurs de ce type dans un
une seule exécution, plutôt que de provoquer un arrêt brutal à la première erreur rencontrée.

Le mécanisme de signalement de telles erreurs a été réimplémenté pour la file d'attente au moment de la compilation
erreurs et les signaler à la fin de la compilation comme de vraies erreurs plutôt que comme
mises en garde. Cela résout les cas où des messages d'erreur ont fui sous la forme d'avertissements
lorsque le code a été compilé au moment de l'exécution en utilisant "eval STRING", et permet également à de telles erreurs d'être
piégé de manière fiable à l'aide de "eval "..."".

Implicitement fonds à capital fermé descripteurs de fichiers sommes-nous plus sûre
Parfois, les descripteurs de fichiers fermés implicitement (comme lorsqu'ils sont localisés, et Perl
les ferme automatiquement en quittant la portée) pourrait par inadvertance définir $? ou $!. Cette
a été corrigé.

Comportement of liste tranches is plus cohérent
Lors de la prise d'une tranche d'une liste littérale (par opposition à une tranche d'un tableau ou d'un hachage), Perl
utilisé pour renvoyer une liste vide si le résultat était composé de toutes les valeurs undef.

Le nouveau comportement est de produire une liste vide si (et seulement si) la liste d'origine était vide.
Prenons l'exemple suivant:

@a = (1,undef,undef,2)[2,1,2] ;

L'ancien comportement aurait eu pour résultat que @a n'aurait aucun élément. Le nouveau comportement garantit
il a trois éléments indéfinis.

A noter en particulier que le comportement des tranches des cas suivants reste inchangé :

@a = ()[1,2] ;
@a = (getpwent)[7,0] ;
@a = (tout_retour_liste_vide())[2,1,2] ;
@a = @b[2,1,2] ;
@a = @c{'a','b','c'} ;

Voir perldata.

"(\$)" prototype et $foo{a}
Un prototype de référence scalaire autorise désormais correctement un élément de hachage ou de tableau dans cet emplacement.

"aller à &sous" et CHARGEMENT AUTOMATIQUE
La construction "goto &sub" fonctionne correctement lorsque &sub est chargé automatiquement.

"-mot nu" permis sous "utilisation entier"
La citation automatique des mots nus précédés de "-" ne fonctionnait pas dans les versions antérieures lorsque le
Le pragma "integer" a été activé. Cela a été corrigé.

Les échecs in DÉTRUIRE()
Lorsque le code d'un destructeur lançait une exception, celle-ci passait inaperçue dans les versions antérieures de
Perl, à moins que quelqu'un ne regarde dans $@ juste après le point où se trouve le destructeur
arrivé à courir. Ces échecs sont désormais visibles sous forme d'avertissements lorsque les avertissements sont activés.

Locale bogues fixé
printf () et sprintf() réinitialisé précédemment les paramètres régionaux numériques sur les paramètres régionaux "C" par défaut.
Cela a été corrigé.

Les nombres formatés en fonction des paramètres régionaux numériques locaux (comme l'utilisation d'une virgule décimale
au lieu d'un point décimal) provoquait des avertissements "n'est pas numérique", même lorsque les opérations
l'accès à ces chiffres a produit des résultats corrects. Ces avertissements ont été supprimés.

Mémoire fuites
La construction "eval 'return sub {...}'" pouvait parfois provoquer une fuite de mémoire. Cela a été corrigé.

Les opérations qui ne sont pas des constructeurs de descripteurs de fichiers sont utilisées pour perdre de la mémoire lorsqu'elles sont utilisées sur invalid
handles de fichiers. Cela a été corrigé.

Les constructions qui modifiaient @_ pouvaient échouer à désallouer des valeurs dans @_ et ainsi perdre de la mémoire.
Cela a été corrigé.

Faux sous-programme bouts après manqué sous-programme en cours
Perl pouvait parfois créer des stubs de sous-programmes vides lorsqu'un sous-programme n'était pas trouvé dans le
paquet. De tels cas ont empêché les recherches de méthode ultérieures de progresser dans les packages de base.
Cela a été corrigé.

Entacher échecs sous "-U"
Lors de l'exécution en mode non sécurisé, les violations de teinte peuvent parfois provoquer des échecs silencieux. Cette
a été réparé.

FIN blocs et le "-c" interrupteur
Versions antérieures utilisées pour exécuter BEGIN et END bloque lorsque Perl est exécuté en mode compilation seule.
Comme ce n'est généralement pas le comportement attendu, les blocs END ne sont plus exécutés
lorsque le commutateur "-c" est utilisé, ou si la compilation échoue.

Voir "Prise en charge des blocs CHECK" pour savoir comment exécuter les choses lorsque la phase de compilation se termine.

Potentiel à fuite DONNEES descripteurs de fichiers
L'utilisation du jeton "__DATA__" crée un descripteur de fichier implicite pour le fichier qui contient le
jeton. Il est de la responsabilité du programme de le fermer lorsqu'il a fini de le lire.

Cette mise en garde est maintenant mieux expliquée dans la documentation. Voir perldata.

New or Changé Diagnostics

La variable "%s" %s masque la déclaration précédente dans le même %s
(W divers) Une variable "my" ou "our" a été redéclarée dans le périmètre courant ou
déclaration, éliminant ainsi tout accès à l'instance précédente. C'est
presque toujours une erreur typographique. Notez que la variable précédente existera toujours
jusqu'à la fin de la portée ou jusqu'à ce que tous les référents de fermeture soient détruits.

"mon sous" pas encore implémenté
(F) Les sous-programmes à portée lexicale ne sont pas encore implémentés. N'essayez pas encore.

"notre" variable %s redéclarée
(W misc) Vous semblez avoir déjà déclaré le même global une fois dans le courant
portée lexicale.

'!' autorisé uniquement après les types %s
(F) Le '!' est autorisé dans paquet() et déballer() seulement après certains types. Voir "pack" dans
perfunc.

/ ne peut pas compter
(F) Vous aviez un modèle de décompression indiquant une chaîne de longueur comptée, mais vous avez également
spécifié une taille explicite pour la chaîne. Voir "pack" dans perlfunc.

/ doit être suivi de a, A ou Z
(F) Vous aviez un modèle de décompression indiquant une chaîne de longueur comptée, qui doit être
suivi de l'une des lettres a, A ou Z pour indiquer quel type de chaîne doit être
déballé. Voir "pack" dans perlfunc.

/ doit être suivi de a*, A* ou Z*
(F) Vous aviez un modèle de pack indiquant une chaîne de longueur comptée, actuellement le seul
les choses dont la longueur peut être comptée sont a*, A* ou Z*. Voir "pack" dans perlfunc.

/ doit suivre un type numérique
(F) Vous aviez un modèle de décompression qui contenait un '#', mais cela ne suivait pas certains
spécification de déballage numérique. Voir "pack" dans perlfunc.

/%s/ : échappement non reconnu \\%c passé
(W regexp) Vous avez utilisé une combinaison antislash-caractère qui n'est pas reconnue par Perl.
Cette combinaison apparaît dans une variable interpolée ou un régulier délimité par "'"
expression. Le personnage a été compris littéralement.

/%s/ : échappement \\%c non reconnu dans la classe de caractères transmise
(W regexp) Vous avez utilisé une combinaison antislash-caractère qui n'est pas reconnue par Perl
à l'intérieur des classes de personnages. Le personnage a été compris littéralement.

/%s/ devrait probablement être écrit comme "%s"
(syntaxe W) Vous avez utilisé un motif où Perl s'attendait à trouver une chaîne, comme dans le
premier argument pour "rejoindre". Perl traitera le résultat vrai ou faux de la correspondance
pattern contre $_ comme chaîne, ce qui n'est probablement pas ce que vous aviez en tête.

%s() appelé trop tôt pour vérifier le prototype
(prototype W) Vous avez appelé une fonction qui a un prototype avant que l'analyseur ne voit un
définition ou déclaration pour cela, et Perl n'a pas pu vérifier que l'appel est conforme à
Le Prototype. Vous devez soit ajouter une déclaration de prototype précoce pour le
sous-programme en question, ou déplacer la définition du sous-programme avant l'appel pour obtenir
vérification appropriée du prototype. Sinon, si vous êtes certain d'appeler le
fonctionner correctement, vous pouvez mettre une esperluette avant le nom pour éviter l'avertissement.
Voir perlsub.

L'argument %s n'est pas un élément HASH ou ARRAY
(F) L'argument de existe() doit être un élément de hachage ou de tableau, tel que :

$foo{$bar}
$ref->{"susie"}[12]

L'argument %s n'est pas un élément ou une tranche HASH ou ARRAY
(F) L'argument de delete () doit être un élément de hachage ou de tableau, tel que :

$foo{$bar}
$ref->{"susie"}[12]

ou une tranche de hachage ou de tableau, telle que :

@foo[$bar, $baz, $xyzzy]
@{$ref->[12]}{"susie", "queue"}

L'argument %s n'est pas un nom de sous-programme
(F) L'argument de existe() pour "existe &sub" doit être un nom de sous-programme, et non un
appel de sous-programme. "existe &sub()" générera cette erreur.

L'attribut de package %s peut entrer en conflit avec le futur mot réservé : %s
(W réservé) Un nom d'attribut en minuscules a été utilisé avec un gestionnaire spécifique au package.
Ce nom pourrait avoir un sens pour Perl lui-même un jour, même si ce n'est pas encore le cas.
Peut-être devriez-vous plutôt utiliser un nom d'attribut à casse mixte. Voir les attributs.

(en cours de nettoyage) %s
(W misc) Ce préfixe indique généralement qu'un DÉTRUIRE() méthode a soulevé l'indiqué
exception. Étant donné que les destructeurs sont généralement appelés par le système à des points arbitraires
pendant l'exécution, et souvent un grand nombre de fois, l'avertissement n'est émis qu'une seule fois
pour un nombre quelconque d'échecs qui, autrement, entraîneraient l'envoi du même message
répété.

L'échec des rappels d'utilisateurs envoyés à l'aide de l'indicateur "G_KEEPERR" peut également entraîner
cet avertissement. Voir "G_KEEPERR" dans perlcall.

<> doit être entre guillemets
(F) Vous avez écrit "exiger " alors que vous auriez dû écrire "require 'file'".

Tenter de se joindre
(F) Vous avez essayé de rejoindre un fil à partir de lui-même, ce qui est une tâche impossible. Vous
peut-être rejoindre le mauvais fil, ou vous devrez peut-être déplacer le joindre() à un autre
fil.

Mauvais modèle de substitution évalué
(F) Vous avez utilisé le commutateur /e pour évaluer le remplacement d'une substitution, mais perl
a trouvé une erreur de syntaxe dans le code à évaluer, très probablement une accolade droite inattendue
'}'.

piscine réalloc() ignoré
(S) Une routine interne appelée réalloc() sur quelque chose qui n'avait jamais été malloc ()ed
en premier lieu. Obligatoire, mais peut être désactivé en définissant une variable d'environnement
"PERL_BADFREE" à 1.

Bareword trouvé au conditionnel
(W bareword) Le compilateur a trouvé un bareword où il attendait un conditionnel, qui
indique souvent qu'un || ou && a été analysé comme faisant partie du dernier argument du
construction précédente, par exemple :

ouvrir FOO || mourir;

Cela peut également indiquer une constante mal orthographiée qui a été interprétée comme un mot nu :

utiliser la constante TYPO => 1 ;
if (TYOP) { print "foo" }

Le pragma "strict" est utile pour éviter de telles erreurs.

Numéro binaire > 0b11111111111111111111111111111111 non portable
(W portable) Le nombre binaire que vous avez spécifié est supérieur à 2**32-1 (4294967295) et
donc non portable entre les systèmes. Voir perlport pour en savoir plus sur la portabilité
préoccupations.

Taille du vecteur de bits > 32 non portable
(W portable) L'utilisation de tailles vectorielles de bits supérieures à 32 n'est pas portable.

Débordement de buffer dans prime_env_iter : %s
(W interne) Un avertissement propre à VMS. Alors que Perl se préparait à itérer sur
%ENV, il a rencontré un nom logique ou une définition de symbole trop long, il a donc été
tronqué à la chaîne indiquée.

Impossible de vérifier le système de fichiers du script "%s"
(P) Pour une raison quelconque, vous ne pouvez pas vérifier le système de fichiers du script pour nosuid.

Impossible de déclarer la classe pour %s non scalaire dans "%s"
(S) Actuellement, seules les variables scalaires peuvent être déclarées avec un qualificatif de classe spécifique dans un
"ma" ou "notre" déclaration. La sémantique peut être étendue pour d'autres types de variables
dans le futur.

Impossible de déclarer %s dans "%s"
(F) Seules les variables scalaires, de tableau et de hachage peuvent être déclarées comme variables "my" ou "our".
Ils doivent avoir des identifiants ordinaires comme noms.

Impossible d'ignorer le signal CHLD, forçage par défaut
(signal W) Perl a détecté qu'il est exécuté avec le signal SIGCHLD (parfois
connu sous le nom de SIGCLD) désactivé. Étant donné que la désactivation de ce signal interférera avec le bon
détermination de l'état de sortie des processus fils, Perl a réinitialisé le signal à son
valeur par défaut. Cette situation indique généralement que le programme parent en vertu duquel
Perl peut être en cours d'exécution (par exemple, cron) est très négligent.

Impossible de modifier l'appel de sous-routine non-lvalue
(F) Les sous-programmes destinés à être utilisés dans le contexte lvalue doivent être déclarés comme tels, voir
"Lvalue subroutines" dans perlsub.

Impossible de lire CRTL environ
(S) Un avertissement propre au VMS. Perl a essayé de lire un élément de %ENV à partir du CRTL
tableau d'environnement interne et a découvert que le tableau était manquant. Vous devez comprendre
où votre CRTL a égaré son environnement ou défini PERL_ENV_TABLES (voir perlvms) donc
cet environ n'est pas recherché.

Impossible de supprimer %s : %s, fichier ignoré
(S) Vous avez demandé une modification sur place sans créer de fichier de sauvegarde. Perl n'a pas pu
supprimer le fichier d'origine pour le remplacer par le fichier modifié. Le dossier a été laissé
non modifié.

Impossible de renvoyer %s à partir du sous-programme lvalue
(F) Perl a détecté une tentative de retour de lvalues ​​illégales (telles que temporaires ou en lecture seule
valeurs) à partir d'un sous-programme utilisé comme lvalue. Ce n'est pas autorisé.

Ne peut pas affaiblir une non-référence
(F) Vous avez tenté d'affaiblir quelque chose qui n'était pas une référence. Seules les références peuvent
être affaibli.

Classe de caractères [:%s:] inconnue
(F) La classe dans la syntaxe de la classe de caractères [: :] est inconnue. Voir perle.

La syntaxe de la classe de caractères [%s] appartient aux classes de caractères
(W unsafe) La classe de caractères construit [: :], [= =] et [. .] aller à l'intérieur caractère
classes, les [] font partie de la construction, par exemple : /[012[:alpha:]345]/. Note
que [= =] et [. .] ne sont pas actuellement mis en œuvre ; ce sont simplement des espaces réservés pour
futurs agrandissements.

La constante n'est pas la référence %s
(F) Une valeur constante (peut-être déclarée à l'aide du pragma "use constant") est en train d'être
déréférencé, mais cela revient au mauvais type de référence. Le message indique
le type de référence qui était attendu. Cela indique généralement une erreur de syntaxe dans
déréférencement de la valeur constante. Voir « Fonctions constantes » dans perlsub et constant.

constante (%s) : %s
(F) L'analyseur a trouvé des incohérences soit en essayant de définir un
constante ou lorsque vous essayez de trouver le nom du caractère spécifié dans l'échappement "\N{...}".
Peut-être avez-vous oublié de charger le pragma "overload" ou "charnames" correspondant ? Voir
charnames et surcharge.

CORE::%s n'est pas un mot-clé
(F) L'espace de noms CORE :: est réservé aux mots-clés Perl.

defined(@array) est obsolète
(D) défini() n'est généralement pas utile sur les tableaux car il vérifie un indéfini
scalaire valeur. Si vous voulez voir si le tableau est vide, utilisez simplement "if (@array) { # not
vide }" par exemple.

defined(%hash) est obsolète
(D) défini() n'est généralement pas utile sur les hachages car il vérifie un indéfini
scalaire valeur. Si vous voulez voir si le hachage est vide, utilisez simplement "if (%hash) { # not
vide }" par exemple.

N'a pas produit d'en-tête valide
Voir Erreur de serveur.

(Vouliez-vous dire « local » au lieu de « notre » ?)
(W misc) N'oubliez pas que "our" ne localise pas la variable globale déclarée. Vous avez
l'a encore déclaré dans la même portée lexicale, ce qui semble superflu.

Le document ne contient aucune donnée
Voir Erreur de serveur.

la saisie effective de %s a échoué
(F) Dans le cadre du pragma « use filetest », la commutation des uids réels et effectifs ou
les gids ont échoué.

false [] plage "%s" dans l'expression régulière
(W regexp) Une plage de classes de caractères doit commencer et se terminer par un caractère littéral, et non
une autre classe de caractères comme "\d" ou "[:alpha:]". Le "-" dans votre fausse plage est
interprété comme un "-" littéral. Pensez à citer le "-", "\-". Voir perle.

Descripteur de fichier %s ouvert uniquement pour la sortie
(W io) Vous avez essayé de lire à partir d'un descripteur de fichier ouvert uniquement en écriture. Si vous aviez l'intention
qu'il s'agisse d'un descripteur de fichier en lecture/écriture, vous deviez l'ouvrir avec "+<" ou "+>" ou "+>>"
au lieu de "<" ou rien. Si vous aviez uniquement l'intention de lire à partir du fichier, utilisez "<".
Voir "open" dans perlfunc.

troupeau() sur le handle de fichier fermé %s
(W fermé) Le descripteur de fichier que vous essayez de troupeau() s'est fermé quelque temps
avant maintenant. Vérifiez votre flux logique. troupeau() fonctionne sur les descripteurs de fichiers. Es-tu
essayer d'appeler troupeau() sur un dirhandle du même nom ?

Le symbole global "%s" nécessite un nom de package explicite
(F) Vous avez dit "use strict vars", ce qui indique que toutes les variables doivent soit être
portée lexicalement (en utilisant "my"), déclarée au préalable en utilisant "our", ou explicitement
qualifié pour dire dans quel package se trouve la variable globale (en utilisant "::").

Nombre hexadécimal > 0xffffffff non portable
(W portable) Le nombre hexadécimal que vous avez spécifié est supérieur à 2**32-1 (4294967295)
et donc non portable entre les systèmes. Voir perlport pour en savoir plus sur la portabilité
préoccupations.

Valeur d'environnement CRTL mal formée « %s »
(W interne) Un avertissement propre à VMS. Perl a essayé de lire le fichier interne du CRTL
environ array, et rencontré un élément sans le délimiteur "=" utilisé pour séparer
clés à partir des valeurs. L'élément est ignoré.

Message mal formé dans prime_env_iter : |%s|
(W interne) Un avertissement propre à VMS. Perl a essayé de lire un nom logique ou une CLI
définition du symbole lors de la préparation de l'itération sur %ENV et n'a pas vu le résultat attendu
délimiteur entre la clé et la valeur, la ligne a donc été ignorée.

Chiffre binaire non valide %s
(F) Vous avez utilisé un chiffre autre que 0 ou 1 dans un nombre binaire.

Chiffre binaire illégal %s ignoré
(chiffre W) Vous avez peut-être essayé d'utiliser un chiffre autre que 0 ou 1 dans un nombre binaire.
L'interprétation du nombre binaire s'est arrêtée avant le chiffre incriminé.

Nombre de bits illégal dans vec
(F) Le nombre de bits dans vec() (le troisième argument) doit être une puissance de deux de 1 à
32 (ou 64, si votre plate-forme le prend en charge).

Débordement d'entier dans le nombre %s
(W overflow) Le nombre hexadécimal, octal ou binaire que vous avez spécifié soit comme
littéral ou comme argument pour hexa () or octobre() est trop grand pour votre architecture, et a
été converti en un nombre à virgule flottante. Sur une architecture 32 bits, la plus grande
le nombre hexadécimal, octal ou binaire représentable sans débordement est 0xFFFFFFFF,
037777777777, ou 0b11111111111111111111111111111111 respectivement. Notez que Perl
promeut de manière transparente tous les nombres en une représentation à virgule flottante
en interne--sous réserve d'erreurs de perte de précision dans les opérations ultérieures.

Attribut %s non valide : %s
L'attribut indiqué pour une sous-routine ou une variable n'a pas été reconnu par Perl ou par
un gestionnaire fourni par l'utilisateur. Voir les attributs.

Attributs %s non valides : %s
Les attributs indiqués pour une sous-routine ou une variable n'étaient pas reconnus par Perl ou
par un gestionnaire fourni par l'utilisateur. Voir les attributs.

invalide [] plage "%s" dans regexp
La plage incriminée est maintenant affichée explicitement.

Caractère de séparation %s non valide dans la liste d'attributs
(F) Quelque chose d'autre qu'un deux-points ou un espace a été vu entre les éléments d'un
liste d'attributs. Si l'attribut précédent avait une liste de paramètres entre parenthèses, peut-être
cette liste a été terminée trop tôt. Voir les attributs.

Caractère de séparation non valide %s dans la liste des attributs de sous-programme
(F) Quelque chose d'autre qu'un deux-points ou un espace blanc a été vu entre les éléments d'un
liste d'attributs de sous-programme. Si l'attribut précédent avait un paramètre entre parenthèses
liste, peut-être que cette liste a été terminée trop tôt.

échec de la sortie effective de %s
(F) Dans le cadre du pragma « use filetest », la commutation des uids réels et effectifs ou
les gids ont échoué.

Les sous-titres Lvalue renvoyant %s ne sont pas encore implémentés
(F) En raison des limitations de l'implémentation actuelle, les valeurs de tableau et de hachage ne peuvent pas être
retourné dans les sous-programmes utilisés dans le contexte lvalue. Voir "Sous-routines Lvalue" dans perlsub.

Méthode %s non autorisée
Voir Erreur de serveur.

%sbrace%s manquant sur \N{}
(F) Syntaxe incorrecte du littéral du nom de caractère "\N{charname}" entre guillemets doubles
contexte

Commande manquante dans le tuyau ouvert
(Tuyau W) Vous avez utilisé la construction "open(FH, "| command")" ou "open(FH, "command |")",
mais la commande était manquante ou vide.

Nom manquant dans "mon sous"
(F) La syntaxe réservée aux sous-programmes à portée lexicale exige qu'ils aient une
nom avec lequel on peut les trouver.

Aucun %s spécifié pour -%c
(F) Le commutateur de ligne de commande indiqué a besoin d'un argument obligatoire, mais vous n'avez pas
un spécifié.

Aucun nom de package autorisé pour la variable %s dans "our"
(F) Les noms de variables complets ne sont pas autorisés dans "nos" déclarations, car cela
n'a pas beaucoup de sens avec la sémantique existante. Une telle syntaxe est réservée pour le futur
Extensions.

Aucun espace autorisé après -%c
(F) L'argument du commutateur de ligne de commande indiqué doit suivre immédiatement après
l'interrupteur, sans espaces intermédiaires.

aucune information de décalage UTC ; en supposant que l'heure locale est UTC
(S) Un avertissement propre au VMS. Perl n'a pas pu trouver le décalage horaire local, donc
il suppose que l'heure système locale est équivalente à UTC. Si ce n'est pas le cas, définissez le
nom logique SYS$TIMEZONE_DIFFERENTIAL pour traduire le nombre de secondes qui
doivent être ajoutés à UTC pour obtenir l'heure locale.

Numéro octal > 037777777777 non portable
(W portable) Le nombre octal que vous avez spécifié est supérieur à 2**32-1 (4294967295) et
donc non portable entre les systèmes. Voir perlport pour en savoir plus sur la portabilité
préoccupations.

Voir aussi perlport pour écrire du code portable.

panique : del_backref
(P) Échec d'une vérification de cohérence interne lors de la tentative de réinitialisation d'une référence faible.

panique : kid popen errno read
(F) l'enfant fourchu a renvoyé un message incompréhensible à propos de son errno.

panique : magic_killbackrefs
(P) Échec d'une vérification de cohérence interne lors de la tentative de réinitialisation de toutes les références faibles à
un objet.

Parenthèses manquantes autour de la liste "%s"
(W parenthèse) Vous avez dit quelque chose comme

mon $foo, $bar = @_;

quand tu voulais dire

mon ($foo, $bar) = @_;

N'oubliez pas que "my", "our" et "local" sont plus étroitement liés que la virgule.

Interpolation involontaire possible de %s dans la chaîne
(W ambigu) Auparavant, Perl essayait de deviner si vous vouliez un tableau
interpolé ou un @ littéral. Il ne le fait plus ; les tableaux sont maintenant toujours
interpolé en chaînes. Cela signifie que si vous essayez quelque chose comme :

impression "[email protected]";

et que le tableau @example n'existe pas, Perl va imprimer "fred.com", qui est
probablement pas ce que vous vouliez. Pour obtenir un signe "@" littéral dans une chaîne, mettez une barre oblique inverse
avant, comme vous le feriez pour obtenir un signe "$" littéral.

Possible bogue de l'an 2 : %s
(W y2k) Vous concaténez le nombre 19 avec un autre nombre, qui pourrait être un
problème potentiel de l'an 2000.

pragma "attrs" est obsolète, utilisez "sub NAME : ATTRS" à la place
(W obsolète) Vous avez écrit quelque chose comme ceci :

sous doit
{
utiliser attrs qw (verrouillé);
}

Vous devez utiliser la nouvelle syntaxe de déclaration à la place.

sous doit : verrouillé
{
...

Le pragma "use attrs" est désormais obsolète et n'est fourni que pour
compatibilité. Voir "Attributs de sous-programme" dans perlsub.

Fin prématurée des en-têtes de script
Voir Erreur de serveur.

Nombre de répétitions dans les débordements de pack
(F) Vous ne pouvez pas spécifier un nombre de répétitions si grand qu'il déborde de vos entiers signés.
Voir "pack" dans perlfunc.

Nombre de répétitions dans les débordements de déballage
(F) Vous ne pouvez pas spécifier un nombre de répétitions si grand qu'il déborde de vos entiers signés.
Voir "déballer" dans perlfunc.

réalloc() de la mémoire libérée ignorée
(S) Une routine interne appelée réalloc() sur quelque chose qui avait déjà été libéré.

La référence est déjà faible
(W divers) Vous avez tenté d'affaiblir une référence déjà faible. Cela a
aucun effet.

setpgrp ne peut pas prendre d'arguments
(F) Votre système a le setpgrp() de BSD 4.2, qui ne prend aucun argument, contrairement à POSIX
setpgid(), qui prend un ID de processus et un ID de groupe de processus.

Étrange *+ ?{} sur une expression de longueur nulle
(W regexp) Vous avez appliqué un quantificateur d'expression régulière à un endroit où il ne fait
sens, comme sur une assertion de largeur nulle. Essayez de mettre le quantificateur à l'intérieur du
affirmation à la place. Par exemple, la manière de faire correspondre "abc" à condition qu'elle soit suivie
par trois répétitions de "xyz" est "/abc(?=(?:xyz){3})/", et non "/abc(?=xyz){3}/".

la commutation effective %s n'est pas implémentée
(F) Tant que sous le pragma "utiliser filetest", nous ne pouvons pas basculer le réel et l'effectif
uids ou gids.

Ce Perl ne peut pas réinitialiser les éléments d'environnement CRTL (%s)
Ce Perl ne peut pas définir les éléments d'environnement CRTL (%s=%s)
(W interne) Avertissements propres au VMS. Vous avez tenté de modifier ou de supprimer un élément de
le tableau environ interne du CRTL, mais votre copie de Perl n'a pas été construite avec un CRTL qui
contenait le setenv() une fonction. Vous devrez reconstruire Perl avec un CRTL qui le fait,
ou redéfinir PERL_ENV_TABLES (voir perlvms) pour que le tableau environ ne soit pas la cible
du changement de %ENV qui a produit l'avertissement.

Trop tard pour exécuter le bloc %s
(W void) Un bloc CHECK ou INIT est défini pendant l'exécution proprement dite, lorsque le
l'occasion de les exécuter est déjà passée. Peut-être que vous chargez un fichier avec
"require" ou "do" alors que vous devriez utiliser "use" à la place. Ou peut-être devriez-vous mettre
le "require" ou "do" à l'intérieur d'un bloc BEGIN.

Inconnu ouvrir() mode '%s'
(F) Le deuxième argument de 3-argument ouvrir() ne fait pas partie de la liste des modes valides :
"<", ">", ">>", "+<", "+>", "+>>", "-|", "|-".

Le processus inconnu %x a envoyé un message à prime_env_iter : %s
(P) Une erreur propre à VMS. Perl lisait des valeurs pour %ENV avant de parcourir
et quelqu'un d'autre a inséré un message dans le flux de données attendu par Perl. Quelques uns
très confus, ou peut-être essayant de subvertir la population de %ENV de Perl pour de mauvais
fins pratiques.

Échappement non reconnu \\%c passé
(W misc) Vous avez utilisé une combinaison antislash-caractère qui n'est pas reconnue par Perl.
Le personnage a été compris littéralement.

Paramètre d'attribut non terminé dans la liste d'attributs
(F) Le lexer a vu une parenthèse ouvrante (gauche) lors de l'analyse d'un attribut
liste, mais le caractère de parenthèse fermante (droite) correspondant n'a pas été trouvé. Tu peux
besoin d'ajouter (ou de supprimer) une barre oblique inverse pour équilibrer vos parenthèses. Voir
attributs.

Liste d'attributs non terminée
(F) Le lexer a trouvé autre chose qu'un simple identifiant au début d'un
attribut, et ce n'était pas un point-virgule ou le début d'un bloc. Peut-être avez-vous résilié
trop tôt la liste des paramètres de l'attribut précédent. Voir les attributs.

Paramètre d'attribut non terminé dans la liste d'attributs de sous-programme
(F) Le lexer a vu un caractère de parenthèse d'ouverture (gauche) lors de l'analyse d'un sous-programme
liste d'attributs, mais la parenthèse fermante (droite) correspondante n'a pas été trouvée.
Vous devrez peut-être ajouter (ou supprimer) une barre oblique inverse pour que vos parenthèses
équilibre.

Liste d'attributs de sous-programmes non terminés
(F) Le lexer a trouvé autre chose qu'un simple identifiant au début d'un
sous-programme, et ce n'était pas un point-virgule ou le début d'un bloc. Peut-être toi
terminé trop tôt la liste des paramètres de l'attribut précédent.

La valeur du symbole CLI "%s" est trop longue
(W misc) Un avertissement propre à VMS. Perl a essayé de lire la valeur d'un élément %ENV
à partir d'une table de symboles CLI et a trouvé une chaîne résultante de plus de 1024 caractères.
La valeur de retour a été tronquée à 1024 caractères.

Le numéro de version doit être un nombre constant
(P) La tentative de traduction d'une instruction "use Module nn LIST" en son équivalent
Le bloc "BEGIN" a trouvé une incohérence interne avec le numéro de version.

New tests

lib/attrs
Tests de compatibilité pour "sub : attrs" vs l'ancien "use attrs".

lib/env
Teste la nouvelle capacité scalaire de l'environnement (par exemple, "use Env qw($BAR);").

lib/env-tableau
Teste la capacité du nouveau tableau d'environnement (par exemple, "use Env qw(@PATH);").

lib/io_const
Constantes IO (SEEK_*, _IO*).

lib/io_dir
Méthodes d'E/S liées à l'annuaire (nouveau, lecture, fermeture, rembobinage, suppression liée).

lib/io_multihomed
Sockets INET avec hôtes multirésidents.

lib/io_poll
IO sondage().

lib/io_unix
Prises UNIX.

op/attrs
Tests de régression pour "my ($x,@y,%z) : attrs" et .

opération/test de fichier
Opérateurs de test de fichiers.

op/lex_assign
Vérifiez les opérations qui accèdent aux objets pad (lexicaux et temporaires).

op/exists_sub
Vérifiez les opérations "existe &sub".

Incompatible Modifications

Perl Source Incompatibilités
Sachez que tous les nouveaux avertissements qui ont été ajoutés ou les anciens qui ont été améliorés sont
pas modifications considérées comme incompatibles.

Étant donné que tous les nouveaux avertissements doivent être explicitement demandés via le commutateur "-w" ou les "avertissements"
pragma, c'est finalement la responsabilité du programmeur de s'assurer que les avertissements sont
activé judicieusement.

CHECK est un nouveau mot-clé
Toutes les définitions de sous-routine nommées CHECK sont désormais spéciales. Voir "/" Prise en charge de CHECK
blocs "" pour plus d'informations.

Le traitement des tranches de liste de undef a changé
Il existe une incompatibilité potentielle dans le comportement des tranches de liste qui sont composées
entièrement de valeurs indéfinies. Voir "Le comportement des tranches de liste est plus cohérent".

Le format de $English::PERL_VERSION est différent
Le module anglais définit maintenant $PERL_VERSION sur $^V (une valeur de chaîne) plutôt que $] (un
valeur numérique). Il s'agit d'une incompatibilité potentielle. Envoyez-nous un rapport via perlbug si
vous en êtes affecté.

Voir « Amélioration du système de numérotation des versions de Perl » pour les raisons de ce changement.

Les littéraux de la forme 1.2.3 s'analysent différemment
Auparavant, les littéraux numériques contenant plus d'un point étaient interprétés comme un
nombre à virgule flottante concaténé avec un ou plusieurs nombres. Ces "chiffres" sont maintenant
analysés comme des chaînes composées des ordinaux spécifiés.

Par exemple, "print 97.98.99" était utilisé pour afficher 97.9899 dans les versions antérieures, mais maintenant
imprime "abc".

Voir "Prise en charge des chaînes représentées sous la forme d'un vecteur d'ordinaux".

Générateur de nombres pseudo-aléatoires éventuellement modifié
Les programmes Perl qui dépendent de la reproduction d'un ensemble spécifique de nombres pseudo-aléatoires peuvent
produire maintenant une sortie différente en raison des améliorations apportées à la rand () intégré. Tu peux
utilisez "sh Configure -Drandfunc=rand" pour obtenir l'ancien comportement.

Voir "Meilleur générateur de nombres pseudo-aléatoires".

La fonction de hachage pour les clés de hachage a changé
Même si les hachages Perl ne préservent pas l'ordre, l'ordre apparemment aléatoire
rencontré lors de l'itération sur le contenu d'un hachage est en fait déterminé par le
algorithme de hachage utilisé. Des améliorations de l'algorithme peuvent produire un ordre aléatoire qui
is différent de celui des versions précédentes, en particulier lors de l'itération sur les hachages.

Voir "Meilleur comportement des hachages dans le pire des cas" pour plus d'informations.

"undef" échoue sur les valeurs en lecture seule
L'utilisation de l'opérateur "undef" sur une valeur en lecture seule (telle que $1) a le même effet que
assigner "undef" à la valeur readonly--il lève une exception.

Le bit Close-on-exec peut être défini sur les poignées de tuyau et de douille
Les poignées de canal et de socket sont également désormais soumises au comportement de fermeture à l'exécution déterminé
par la variable spéciale $^F.

Voir "Comportement de fermeture à l'exécution plus cohérent".

L'écriture de "$$1" pour signifier "${$}1" n'est pas prise en charge
Perl 5.004 a déprécié l'interprétation de $$1 et similaire dans l'interpolation
chaînes pour signifier "$$ . "1"", mais toujours autorisé.

Dans Perl 5.6.0 et versions ultérieures, "$$1" signifie toujours "${$1}".

delete (), chaque(), valeurs () et "\(%h)"
opérer sur des alias vers des valeurs, pas des copies

delete (), chaque(), valeurs () et les hachages (par exemple "\(%h)") dans un contexte de liste renvoient le
valeurs réelles dans le hachage, au lieu de copies (comme c'était le cas dans les versions précédentes).
Les idiomes typiques pour l'utilisation de ces constructions copient les valeurs renvoyées, mais cela peut rendre
une différence significative lors de la création de références aux valeurs renvoyées. Clés dans le
hash sont toujours renvoyés sous forme de copies lors de l'itération sur un hachage.

Voir également "delete (), chaque(), valeurs () et l'itération de hachage sont plus rapides".

vec(EXPR,OFFSET,BITS) applique les puissances de deux BITS
vec() génère une erreur d'exécution si l'argument BITS n'est pas une puissance de deux valide
entier.

Le texte de certaines sorties de diagnostic a changé
La plupart des références aux opérations internes de Perl dans les diagnostics ont été modifiées pour être
plus descriptif. Cela peut être un problème pour les programmes qui peuvent s'appuyer à tort sur le
texte exact des diagnostics pour un bon fonctionnement.

"%@" a été retiré
La variable spéciale non documentée "%@" qui accumulait les erreurs "d'arrière-plan"
(comme ceux qui se produisent dans DÉTRUIRE()) a été supprimée, car elle pourrait
entraîner potentiellement des fuites de mémoire.

Entre parenthèses ne pas() se comporte comme un opérateur de liste
L'opérateur "non" tombe maintenant sous le "si cela ressemble à une fonction, il se comporte comme un
règle de fonction ».

Par conséquent, la forme entre parenthèses peut être utilisée avec "grep" et "map". Ce qui suit
La construction était auparavant une erreur de syntaxe, mais elle fonctionne comme prévu maintenant :

grep pas($_), @choses ;

D'autre part, l'utilisation de "not" avec une tranche de liste littérale peut ne pas fonctionner. Ce qui suit
construction précédemment autorisée :

imprimer pas (1,2,3)[0] ;

doit être écrit avec des parenthèses supplémentaires maintenant :

imprimer pas((1,2,3)[0]);

Le comportement reste inchangé lorsque "not" n'est pas suivi de parenthèses.

La sémantique du prototype de mot nu "(*)" a changé
La sémantique du prototype de mot nu "*" a changé. Perl 5.005 toujours contraint
arguments scalaires simples à un typeglob, ce qui n'était pas utile dans les situations où le
La sous-routine doit faire la distinction entre un scalaire simple et un typeglob. Le nouveau comportement
est de ne pas contraindre les arguments de mots nus à un typeglob. La valeur sera toujours visible
comme simple scalaire ou comme référence à un typeglob.

Voir "Prototype bareword plus fonctionnel (*)".

La sémantique des opérateurs de bits peut avoir changé sur les plates-formes 64 bits
Si votre plate-forme est nativement 64 bits ou si Perl a été configuré pour être utilisé
Entiers 64 bits, c'est-à-dire que $Config{ivsize} vaut 8, il peut y avoir une incompatibilité potentielle
dans le comportement des opérateurs numériques au niveau du bit (& | ^ ~ << >>). Ces opérateurs avaient l'habitude de
fonctionnent strictement sur les 32 bits inférieurs des entiers dans les versions précédentes, mais maintenant
fonctionnent sur toute la largeur intégrale native. En particulier, notez que "~" unaire
produira des résultats différents sur les plateformes qui ont des $Config{ivsize} différents. Pour
portabilité, assurez-vous de masquer les bits en excès dans le résultat de "~" unaire, par exemple,
"~$x & 0xffffffff".

Voir "Les opérateurs de bits prennent en charge la pleine largeur d'entier natif".

Plus d'éléments intégrés entachent leurs résultats
Comme décrit dans "Fonctionnalités de sécurité améliorées", il peut y avoir plus de sources de souillure dans un
Programme Perl.

Pour éviter ces nouveaux comportements de souillure, vous pouvez construire Perl avec l'option Configurer
"-Accflags=-DINCOMPLETE_TAINTS". Attention, le binaire perl qui suit peut ne pas être sûr.

C Source Incompatibilités
"PERL_POLLUANT"
La version 5.005 a protégé les anciens noms de symboles globaux en fournissant des macros de préprocesseur
pour la compatibilité de la source d'extension. Depuis la version 5.6.0, ces préprocesseurs
les définitions ne sont pas disponibles par défaut. Vous devez compiler explicitement perl avec
"-DPERL_POLLUTE" pour obtenir ces définitions. Pour les extensions utilisant encore l'ancien
symboles, cette option peut être spécifiée via MakeMaker :

perl Makefile.PL POLLUTE=1

"PERL_IMPLICIT_CONTEXT"
Cette nouvelle option de construction fournit un ensemble de macros pour toutes les fonctions de l'API, de sorte qu'un
L'argument implicite de contexte d'interpréteur/thread est passé à chaque fonction d'API. Comme un
résultat de cela, quelque chose comme "sv_setsv(foo,bar)" équivaut à une invocation de macro qui
se traduit en fait par quelque chose comme "Perl_sv_setsv(my_perl,foo,bar)". Alors que c'est
on s'attend généralement à ce qu'il n'y ait pas de problèmes importants de compatibilité des sources, le
la différence entre une macro et un véritable appel de fonction devra être prise en compte.

Cela signifie qu'il y is un problème de compatibilité source à la suite de cela si votre
les extensions tentent d'utiliser des pointeurs vers l'une des fonctions de l'API Perl.

Notez que le problème ci-dessus n'est pas pertinent pour la construction par défaut de Perl, dont
les interfaces continuent de correspondre à celles des versions précédentes (mais sous réserve des autres options
décrit ici).

Voir "Arrière-plan et PERL_IMPLICIT_CONTEXT" dans perlguts pour des informations détaillées sur le
ramifications de la construction de Perl avec cette option.

REMARQUE : PERL_IMPLICIT_CONTEXT est automatiquement activé chaque fois que Perl est construit
avec l'un des -Dusethreads, -Dusemultiplicity, ou les deux. Ce n'est pas
destiné à être activé par les utilisateurs pour le moment.

"PERL_POLLUTE_MALLOC"
L'activation de malloc de Perl dans la version 5.005 et les versions antérieures provoquait l'espace de noms du
famille de fonctions malloc du système à être usurpées par les versions Perl, puisque par
par défaut, ils utilisaient les mêmes noms. En plus de causer des problèmes sur des plates-formes qui ne
permettre le remplacement propre de ces fonctions, cela signifiait également que les versions du système
ne pouvait pas être appelé dans les programmes qui utilisaient le malloc de Perl. Versions précédentes de Perl
ont permis de supprimer ce comportement avec HIDEMYMALLOC et EMBEDMYMALLOC
définitions du préprocesseur.

Depuis la version 5.6.0, la famille de fonctions malloc de Perl a des noms par défaut distincts
à partir des versions du système. Vous devez compiler explicitement perl avec
"-DPERL_POLLUTE_MALLOC" pour obtenir l'ancien comportement. HIDEMYMALLOC et EMBEDMYMALLOC
n'ont aucun effet, car le comportement qu'ils ont activé est désormais celui par défaut.

Notez que ces fonctions ne pas constituent l'API d'allocation de mémoire de Perl. Voir "Mémoire
Allocation" dans perlguts pour plus d'informations à ce sujet.

Compatibilité C Source API Modifications
"PATCHLEVEL" est maintenant "PERL_VERSION"
Les macros cpp "PERL_REVISION", "PERL_VERSION", et "PERL_SUBVERSION" sont maintenant
disponible par défaut à partir de perl.h et reflète la révision de base, le niveau de correctif et
subversion respectivement. "PERL_REVISION" n'avait pas d'équivalent antérieur, alors que
"PERL_VERSION" et "PERL_SUBVERSION" étaient auparavant disponibles en tant que "PATCHLEVEL" et
"SUBVERSION".

Les nouveaux noms polluent moins le cpp espace de noms et refléter ce que les nombres
se sont imposés dans la pratique courante. Pour des raisons de compatibilité, les anciens noms sont toujours
pris en charge lorsque patchlevel.h est explicitement inclus (comme requis auparavant), il y a donc
aucune incompatibilité de source du changement.

binaire Incompatibilités
En général, la version par défaut de cette version devrait être compatible binaire pour
extensions construites avec la version 5.005 ou ses versions de maintenance. Cependant, spécifique
les plates-formes peuvent avoir une compatibilité binaire rompue en raison de modifications des valeurs par défaut utilisées dans
fichiers d'astuces. Par conséquent, assurez-vous de toujours vérifier les fichiers README spécifiques à la plate-forme
pour toute note contraire.

Les constructions usethreads ou usemultiplicity sont pas binaire compatible avec le correspondant
construit en 5.005.

Sur les plates-formes nécessitant une liste explicite d'exportations (AIX, OS/2 et Windows, entre autres
d'autres), les symboles purement internes tels que les fonctions d'analyseur et les opcodes d'exécution ne sont pas
exporté par défaut. Perl 5.005 exportait toutes les fonctions, qu'elles soient ou non
étaient considérés comme faisant partie de l'API publique ou non.

Pour la liste complète des fonctions d'API publiques, voir perlapi.

Connu Problèmes

Fil à coudre tester échecs
Les sous-tests 19 et 20 du test lib/thr5005.t sont connus pour échouer en raison de problèmes fondamentaux
dans l'implémentation du threading 5.005. Ces erreurs ne sont pas nouvelles : Perl 5.005_0x présente les
mêmes bugs, mais je n'avais pas ces tests.

EBCDIC plates-formes pas soutenu
Dans les versions antérieures de Perl, les environnements EBCDIC comme OS390 (également connu sous le nom d'Open Edition
MVS) et VM-ESA étaient pris en charge. En raison des changements requis par le support UTF-8 (Unicode),
les plates-formes EBCDIC ne sont pas prises en charge dans Perl 5.6.0.

In 64-bits HP-UX le lib/io_multihomed tester Au cours de cette réunion, Matthew a obtenu de précieux conseils et Linda lui a demandé de la tenir au courant de ses progrès. accrocher
Le test lib/io_multihomed peut se bloquer dans HP-UX si Perl a été configuré pour être 64 bits.
Étant donné que les autres plates-formes 64 bits ne se bloquent pas dans ce test, HP-UX est suspect. Tous les autres
les tests réussissent dans HP-UX 64 bits. Le test tente de créer et de se connecter à "multihomed"
sockets (sockets qui ont plusieurs adresses IP).

L'ÉTAPE SUIVANTE 3.3 POSIX tester échec
Dans NEXTSTEP 3.3p2, l'implémentation du strftime(3) dans les bibliothèques du système d'exploitation
est buggé : le format %j numérote les jours d'un mois à partir de zéro, ce qui, tout en étant
logique pour les programmeurs, entraînera l'échec des sous-tests 19 à 27 du test lib/posix.

Tru64 (alias Ressources UNIX, aka DÉC OSF/1) lib/sdbm tester échec avec gcc
Si compilé avec gcc 2.95, le test lib/sdbm échouera (vidage du noyau). La solution est d'utiliser
fournisseur cc, il est livré avec le système d'exploitation et produit un bon code.

UNICOS/mk CC échecs pendant Configurez courir
Dans UNICOS/mk, les erreurs suivantes peuvent apparaître lors de l'exécution de Configure :

Deviner quels symboles votre compilateur C et votre préprocesseur définissent...
CC-20 cc : ERREUR Fichier = try.c, Ligne = 3
...
mauvais commutateur yylook 79bad commutateur yylook 79bad commutateur yylook 79bad commutateur yylook 79 # ifdef A29K
...
4 erreurs détectées dans la compilation de "try.c".

Le coupable est l'awk cassé d'UNICOS/mk. L'effet est heureusement plutôt doux : Perl
lui-même n'est pas affecté par l'erreur, seul l'utilitaire h2ph fourni avec Perl, et
qui est plutôt rarement nécessaire de nos jours.

flèche opérateur et tableaux
Lorsque l'argument de gauche de l'opérateur fléché "->" est un tableau, ou l'opérateur "scalaire"
fonctionnant sur un tableau, le résultat de l'opération doit être considéré comme erroné. Pour
Exemple:

@x->[2]
scalaire(@x)->[2]

Ces expressions obtiendront des erreurs d'exécution dans une future version de Perl.

Expérimental Caractéristiques
Comme indiqué ci-dessus, de nombreuses fonctionnalités sont encore expérimentales. Interfaces et implémentation
de ces fonctionnalités sont susceptibles d'être modifiées et, dans des cas extrêmes, même susceptibles d'être supprimées dans
une future version de Perl. Ces fonctionnalités incluent les éléments suivants :

Threads
Unicode
Prise en charge de 64-bit
Lvalue sous-routines
Des références faibles
Le type de données pseudo-hachage
La suite Compilateur
Implémentation interne de la globalisation des fichiers
Le module BD
Le code d'expression régulière construit :
"(?{ code })" et "(??{ code })"

Obsolète Diagnostics

La syntaxe de la classe de caractères [: :] est réservée aux futures extensions
(W) Dans les classes de caractères d'expression régulière ([]), la syntaxe commençant par "[:"
et se terminant par ":]" est réservé pour les extensions futures. Si vous devez représenter
ces séquences de caractères à l'intérieur d'une classe de caractères d'expression régulière, il suffit de citer le
crochets avec la barre oblique inverse : "\[:" et ":\]".

Nom logique mal formé |%s| dans prime_env_iter
(W) Un avertissement propre au VMS. Un nom logique a été rencontré lors de la préparation de
itérer sur %ENV qui viole les règles syntaxiques régissant les noms logiques. Parce que
il ne peut pas être traduit normalement, il est ignoré et n'apparaîtra pas dans %ENV. Cette
peut être un événement bénin, car certains progiciels peuvent modifier directement la logique
tables de noms et introduire des noms non standard, ou cela peut indiquer qu'un nom logique
le tableau a été corrompu.

Dans la chaîne, @%s doit maintenant être écrit comme \@%s
La description de cette erreur disait :

(Un jour, il supposera simplement qu'un @ sans barre oblique inverse
interpole un tableau.)

Ce jour est venu, et cette erreur fatale a été supprimée. Il a été remplacé par un
avertissement non fatal à la place. Voir "Les tableaux sont désormais toujours interpolés entre guillemets doubles
chaînes" pour plus de détails.

Probable problème de priorité sur %s
(W) Le compilateur a trouvé un mot nu là où il attendait un conditionnel, qui souvent
indique qu'un || ou && a été analysé comme faisant partie du dernier argument du précédent
construire, par exemple :

ouvrir FOO || mourir;

expression rationnelle trop grande
(F) L'implémentation actuelle des expressions régulières utilise des shorts comme décalages d'adresse
dans une chaîne. Malheureusement, cela signifie que si l'expression régulière se compile en
plus long que 32767, ça va exploser. Habituellement, lorsque vous voulez une expression régulière, cela
big, il existe une meilleure façon de le faire avec plusieurs instructions. Voir perler.

Utilisation de "$$ " pour signifier "${$} " est obsolète
(D) Les versions Perl antérieures à 5.004 ont mal interprété tout marqueur de type suivi de "$" et d'un
chiffre. Par exemple, "$$0" a été incorrectement interprété comme signifiant "${$}0" au lieu de "${$0}".
Ce bogue est (principalement) corrigé dans Perl 5.004.

Cependant, les développeurs de Perl 5.004 n'ont pas pu corriger complètement ce bogue, car à
au moins deux modules largement utilisés dépendent de l'ancienne signification de "$$0" dans une chaîne. Alors Perl
5.004 interprète toujours "$$ " à l'ancienne (cassé) à l'intérieur des chaînes ; mais il
génère ce message comme un avertissement. Et en Perl 5.005, ce traitement spécial sera
cesser.

Reporting Bugs

Si vous trouvez ce que vous pensez être un bogue, vous pouvez consulter les articles récemment publiés sur le
groupe de discussion comp.lang.perl.misc. Il peut également y avoir des informations sur http://www.perl.com/perl/
, la page d'accueil de Perl.

Si vous pensez avoir un bogue non signalé, veuillez exécuter le bug perl programme inclus avec
votre libération. Assurez-vous de réduire votre bogue à un cas de test minuscule mais suffisant. Votre bogue
rapport, avec la sortie de "perl -V", sera envoyé à [email protected] être
analysés par l'équipe de portage de Perl.

Utilisez perl56delta en ligne à l'aide des services onworks.net