perl56delta - Online na nuvem

PROGRAMA:

NOME

perl56delta - o que há de novo no perl v5.6.0

DESCRIÇÃO

Este documento descreve as diferenças entre as versões 5.005 e 5.6.0.

Setores de Melhorias

Intérprete clonagem, tópicos, e simultaneidade
Perl 5.6.0 apresenta o início do suporte para a execução de vários intérpretes
simultaneamente em diferentes threads. Em conjunto com o perl_clone () Chamada API, que
pode ser usado para duplicar seletivamente o estado de qualquer intérprete, é possível
compilar um pedaço de código uma vez em um interpretador, clonar esse interpretador uma ou mais vezes,
e execute todos os interpretadores resultantes em threads distintos.

Na plataforma Windows, este recurso é usado para emular garfo() ao nível do intérprete.
Veja perlfork para detalhes sobre isso.

Este recurso ainda está em evolução. Eventualmente destina-se a ser usado de forma seletiva
clonar uma sub-rotina e dados acessíveis a partir dessa sub-rotina em um interpretador separado e
execute a sub-rotina clonada em uma thread separada. Uma vez que não há dados compartilhados entre os
intérpretes, pouco ou nenhum bloqueio será necessário (a menos que partes da tabela de símbolos sejam
compartilhada explicitamente). Obviamente, pretende-se que seja um substituto fácil de usar para o
suporte a threads existentes.

O suporte para clonagem de intérpretes e simultaneidade de intérpretes pode ser habilitado usando o
- Opção de configuração do Dusethreads (consulte win32 / Makefile para saber como habilitá-lo no Windows).
O executável perl resultante será funcionalmente idêntico ao que foi construído com
-Dmultiplicidade, mas o perl_clone () A chamada API só estará disponível no primeiro.

-Dusethreads habilita a macro cpp USE_ITHREADS por padrão, que por sua vez habilita Perl
mudanças no código-fonte que fornecem uma separação clara entre a árvore operacional e os dados que
opera com. O primeiro é imutável e, portanto, pode ser compartilhado entre um
intérprete e todos os seus clones, enquanto o último é considerado local para cada
intérprete e, portanto, é copiado para cada clone.

Observe que construir Perl com a opção -Dusemultiplicity Configure é adequado se você
deseja executar vários de treinadores em Entrevista Motivacional intérpretes simultaneamente em diferentes threads.
-Dusethreads fornece apenas a funcionalidade adicional do perl_clone () Chamada API e
outro suporte para correr clonado intérpretes simultaneamente.

NOTA: este é um recurso experimental. Os detalhes de implementação são
sujeito a mudanças.

Lexicamente escopo aviso Categorias
Agora você pode controlar a granularidade dos avisos emitidos pelo perl em um nível mais preciso usando o
pragma de "usar avisos". avisos e perllexwarn têm documentação copiosa sobre este
recurso.

Unicode e UTF-8 ajuda
Perl agora usa UTF-8 como sua representação interna para cadeias de caracteres. O "utf8" e
Os pragmas "bytes" são usados ​​para controlar este suporte no escopo léxico atual. Ver
perlunicode, utf8 e bytes para mais informações.

Espera-se que esse recurso evolua rapidamente para oferecer suporte a alguma forma de disciplinas de I / O que
pode ser usado para especificar o tipo de dados de entrada e saída (bytes ou caracteres). Até
isso acontecer, serão necessários módulos adicionais do CPAN para completar o kit de ferramentas para
lidar com Unicode.

NOTA: Este deve ser considerado um recurso experimental. Implementação
os detalhes estão sujeitos a alterações.

Suporte for interpolando nomeado caracteres
O novo escape "\ N" interpola caracteres nomeados dentro de strings. Por exemplo, "Olá!
\ N {ROSTO SORRISO BRANCO} "é avaliado como uma string com um rosto sorridente Unicode no final.

"nosso" declarações
Uma declaração "nossa" apresenta um valor que pode ser melhor entendido como um escopo léxico
alias simbólico para uma variável global no pacote que era atual onde a variável estava
declarado. Isso é principalmente útil como uma alternativa ao pragma "vars", mas também fornece
a oportunidade de introduzir a digitação e outros atributos para tais variáveis. Veja "nosso" em
perlfunc.

Suporte for cordas representado as a vetor of ordinais
Literais da forma "v1.2.3.4" agora são analisados ​​como uma string composta de caracteres com o
ordinais especificados. Esta é uma forma alternativa e mais legível de construir (possivelmente
Unicode) em vez de caracteres de interpolação, como em "\ x {1} \ x {2} \ x {3} \ x {4}". o
"v" inicial pode ser omitido se houver mais de dois ordinais, então 1.2.3 é analisado no
igual a "v1.2.3".

Strings escritos neste formulário também são úteis para representar "números" de versão. Isso é fácil
para comparar esses "números" de versão (que são apenas strings simples) usando qualquer um dos
operadores usuais de comparação de strings "eq", "ne", "lt", "gt", etc., ou executam string bit a bit
operações neles usando "|", "&", etc.

Em conjunto com a nova variável mágica $ ^ V (que contém a versão perl como um
string), esses literais podem ser usados ​​como uma forma legível de verificar se você está executando um
versão particular do Perl:

# isto irá analisar em versões mais antigas do Perl também
if ($ ^ V e $ ^ V gt v5.6.0) {
# novos recursos suportados
}

"require" e "use" também têm alguma magia especial para suportar tais literais, mas isso
uso particular deve ser evitado porque leva a mensagens de erro enganosas sob
versões do Perl que não suportam strings vetoriais. Usar um número de versão verdadeiro irá
garanta o comportamento correto em todas as versões do Perl:

requer 5.006; # verificação de tempo de execução para v5.6
use 5.006_001; # verificação de tempo de compilação para v5.6.1

Além disso, "sprintf" e "printf" suportam o sinalizador de formato específico de Perl% v para imprimir ordinais de
caracteres em strings arbitrárias:

printf "v% vd", $ ^ V; # imprime a versão atual, como "v5.5.650"
printf "% * vX", ":", $ addr; # formatos de endereço IPv6
printf "% * vb", "", $ bits; # exibe bitstring

Consulte "Construtores de valor escalar" em perldata para obter informações adicionais.

Melhorado Perl versão numeração sistema.
A partir do Perl versão 5.6.0, a convenção do número da versão foi alterada para um
Esquema de "número inteiro pontilhado" que é mais comumente encontrado em projetos de código aberto.

As versões de manutenção da v5.6.0 serão lançadas como v5.6.1, v5.6.2 etc.
a série de desenvolvimento após a v5.6.0 será numerada como v5.7.x, começando com v5.7.0, e
o próximo grande lançamento de produção após a v5.6.0 será a v5.8.0.

O módulo em inglês agora define $ PERL_VERSION para $ ^ V (um valor de string) em vez de $] (um
valor numérico). (Esta é uma incompatibilidade potencial. Envie-nos um relatório via perlbug se
você é afetado por isso.)

A sintaxe v1.2.3 agora também é válida em Perl. Veja "Suporte para strings representadas como um
vetor de ordinais "para mais informações.

Para lidar com o uso do novo sistema de controle de versão de pelo menos três dígitos significativos para cada
componente de versão, o método usado para incrementar o número de subversão também mudou
levemente. Assumimos que as versões anteriores à v5.6.0 têm incrementado a subversão
componente em múltiplos de 10. As versões posteriores à v5.6.0 irão incrementá-los em 1. Assim,
usando a nova notação, 5.005_03 é o "mesmo" que v5.5.30, e a primeira manutenção
versão posterior a v5.6.0 será v5.6.1 (que deve ser lida como equivalente a um
valor de ponto flutuante de 5.006_001 no formato antigo, armazenado em $]).

Novo sintaxe for declarando sub-rotina atributos
Anteriormente, se você quisesse marcar uma sub-rotina como sendo uma chamada de método ou exigindo um
automático trancar() quando ele é inserido, você deve declarar que com um pragma "use attrs" em
o corpo da sub-rotina. Isso agora pode ser feito com a sintaxe de declaração, como
esta:

sub mymethod: método bloqueado;
...
sub mymethod: método bloqueado {
...
}

suboutro método: bloqueado: método;
...
suboutro método: bloqueado: método {
...
}

(Observe como apenas o primeiro ":" é obrigatório e o espaço em branco ao redor do ":" é
opcional.)

AutoSplit.pm e SelfLoader.pm foram atualizados para manter os atributos com os stubs
eles providenciam. Veja os atributos.

Envie o e anuário alças pode be autovivificado
Semelhante a como construções como "$ x -> [0]" autovivificam uma referência, manipulam construtores
(abrir(), opendir (), tubo(), socketpair (), sysopen (), soquete () e aceitar ()) agora
autovivificar um identificador de arquivo ou diretório se o identificador passado para eles não for inicializado
variável escalar. Isso permite as construções como "open (my $ fh, ...)" e "open (local
$ fh, ...) "para ser usado para criar manipuladores de arquivos que serão convenientemente fechados automaticamente
quando o escopo termina, desde que não haja outras referências a eles. Isso em grande parte
elimina a necessidade de tipos de vinho ao abrir identificadores de arquivo que devem ser passados, como
no exemplo a seguir:

sub myopen {
abra meu $ fh, "@_"
ou morrer "Não é possível abrir '@_': $!";
return $ fh;
}

{
meu $ f = myopen ("
imprimir <$ f>;
# $ f implicitamente fechado aqui
}

abrir() com mais do que dois argumentos
If abrir() recebe três argumentos em vez de dois, o segundo argumento é usado como o
modo e o terceiro argumento é considerado o nome do arquivo. Isso é principalmente útil para
protegendo contra comportamento mágico não intencional da forma tradicional de dois argumentos. Ver
"abrir" em perlfunc.

64-bit ajuda
Qualquer plataforma que tenha números inteiros de 64 bits

(1) nativamente como longos ou ints
(2) por meio de sinalizadores de compilador especiais
(3) usando long long ou int64_t

é capaz de usar "quads" (inteiros de 64 bits) da seguinte forma:

· Constantes (decimal, hexadecimal, octal, binário) no código

· Argumentos para out () e hex ()

· Argumentos para impressão(), printf () e sprintf () (prefixos de bandeira ll, L, q)

· Impresso como tal

· pacote() e desempacotar () formatos "q" e "Q"

· Em aritmética básica: + - * /% (NOTA: operando perto dos limites do inteiro
valores podem produzir resultados surpreendentes)

· Em aritmética de bits: & | ^ ~ << >> (NOTA: estes costumavam ser forçados a ter 32 bits de largura
mas agora opera em toda a largura nativa.)

· vec ()

Observe que a menos que você tenha o caso (a), você terá que configurar e compilar Perl usando
o sinalizador de configuração -Duse64bitint.

NOTA: Os sinalizadores de configuração -Duselonglong e -Duse64bits foram
descontinuada. Em vez disso, use -Duse64bitint.

Na verdade, existem dois modos de 64 bits: o primeiro é obtido usando Configurar
-Duse64bitint e o segundo usando Configurar -Duse64bitall. A diferença é que
o primeiro é mínimo e o segundo é máximo. O primeiro funciona em mais lugares do que
o segundo.

O "use64bitint" faz apenas o necessário para obter inteiros de 64 bits em Perl (este
pode significar, por exemplo, o uso de "longos"), enquanto sua memória ainda pode ser limitada a 2
gigabytes (porque seus ponteiros ainda podem ser de 32 bits). Observe que o nome "64bitint"
não implica que seu compilador C usará "int" s de 64 bits (pode, mas não
tem que): o "use64bitint" significa que você poderá ter um escalar de 64 bits de largura
valores.

O "use64bitall" vai até o fim, tentando alternar também números inteiros (se puder),
longs (e ponteiros) para ser de 64 bits. Isso pode criar um binário ainda mais incompatível
Perl do que -Duse64bitint: o executável resultante pode não ser executado em uma caixa de 32 bits, ou
você pode ter que reiniciar / reconfigurar / reconstruir seu sistema operacional para reconhecer os 64 bits.

Os sistemas nativos de 64 bits como Alpha e Cray não precisam de -Duse64bitint nem -Duse64bitall.

Por último, mas não menos importante: observe que, devido ao hábito do Perl de sempre usar números de ponto flutuante,
os quads ainda não são inteiros verdadeiros. Quando quads ultrapassam seus 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
para números de ponto flutuante, após o qual eles começarão a perder precisão (em seu menor
dígitos).

NOTA: o suporte de 64 bits ainda é experimental na maioria das plataformas.
O suporte existente cobre apenas o modelo de dados LP64. Em particular, o
O modelo de dados LLP64 ainda não é compatível. Bibliotecas e sistema de 64 bits
APIs em muitas plataformas não se estabilizaram - sua milhagem pode variar.

Grande lima ajuda
Se você tiver sistemas de arquivos que suportam "arquivos grandes" (arquivos maiores que 2 gigabytes), você
agora também pode ser capaz de criá-los e acessá-los a partir do Perl.

NOTA: A ação padrão é habilitar o suporte a arquivos grandes, se
disponíveis na plataforma.

Se o suporte a arquivos grandes estiver ativado e você tiver uma constante Fcntl O_LARGEFILE, o
O_LARGEFILE é adicionado automaticamente aos sinalizadores de sysopen ().

Esteja ciente de que, a menos que seu sistema de arquivos também suporte "arquivos esparsos", buscando muitos
petabytes podem ser desaconselháveis.

Observe que além de exigir um sistema de arquivos adequado para fazer arquivos grandes, você também pode
precisa ajustar seu por processo (ou por sistema, ou por grupo de processo, ou por usuário
grupo) limites máximos de tamanho de arquivo antes de executar scripts Perl que tentam lidar com arquivos grandes,
especialmente se você pretende gravar esses arquivos.

Finalmente, além de seus limites máximos de tamanho de arquivo de grupo de processo / processo, você pode ter
limites de cota em seus sistemas de arquivos que impedem você (seu ID de usuário ou ID de grupo de usuários) de
usando arquivos grandes.

Ajustar seus limites de processo / usuário / grupo / sistema de arquivos / sistema operacional está fora do escopo
da linguagem central Perl. Para limites de processo, você pode tentar aumentar os limites usando seu
o comando limits / limit / ulimit do shell antes de executar Perl. A extensão BSD :: Resource (não
incluído com a distribuição Perl padrão) também pode ser útil, ele oferece o
interface getrlimit / setrlimit que pode ser usada para ajustar os limites de uso de recursos do processo,
incluindo o limite máximo de tamanho de arquivo.

longo duplos
Em alguns sistemas, você pode ser capaz de usar duplas longas para aumentar o alcance e a precisão de
seus números de ponto flutuante de precisão dupla (ou seja, os números de Perl). Use Configure
- Use o dobro para habilitar este suporte (se estiver disponível).

"mais bits "
Você pode "Configurar -Dusemorebits" para ligar o suporte de 64 bits e o duplo longo
.

Eficiência ajuda for ordenar() sub-rotinas
Sub-rotinas Perl com um protótipo de "($$)", e XSUBs em geral, agora podem ser usadas como classificação
sub-rotinas. Em qualquer caso, os dois elementos a serem comparados são passados ​​normalmente
parâmetros em @_. Veja "classificar" em perlfunc.

Para sub-rotinas de classificação não padronizadas, o comportamento histórico de passar os elementos a serem
em comparação com as variáveis ​​globais $ a e $ b permanecem inalteradas.

"ordenar $ coderef @foo " permitidas
ordenar() não aceitou uma referência de sub-rotina como a função de comparação anteriormente
versões. Isso agora é permitido.

Envie o globulando implementado internamente
Perl agora usa a implementação File :: Glob do glob () operador automaticamente. Esse
evita o uso de um processo csh externo e os problemas associados a ele.

NOTA: Este é atualmente um recurso experimental. Interfaces e
implementação estão sujeitas a alterações.

Suporte for VERIFICAÇÃO blocos
Além de "BEGIN", "INIT", "END", "DESTROY" e "AUTOLOAD", sub-rotinas chamadas "CHECK"
agora são especiais. Eles são enfileirados durante a compilação e se comportam de forma semelhante aos blocos END,
exceto que eles são chamados no final da compilação e não no final da execução.
Eles não podem ser chamados diretamente.

POSIX personagem classe sintaxe [: :] suportado
Por exemplo, para combinar caracteres alfabéticos, use / [[: alfa:]]/. Veja perlre para detalhes.

Melhor pseudo-aleatório número gerador
Em 5.005_0x e anteriores, perl's rand () função usou a biblioteca C rand(3) função. Como
de 5.005_52, Configurar testes para drand48 (), aleatório () e rand () (nessa ordem) e escolhe
o primeiro que encontra.

Essas mudanças devem resultar em melhores números aleatórios de rand ().

Melhorado "qw //" operador
O operador "qw //" agora é avaliado em tempo de compilação em uma lista verdadeira em vez de ser
substituído por uma chamada de tempo de execução para "split ()". Isso remove o mau comportamento confuso de
"qw //" no contexto escalar, que herdou esse comportamento de dividir().

Portanto:

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

agora imprime corretamente "3 | a", em vez de "2 | a".

Melhor pior caso comportamento of hashes
Pequenas mudanças no algoritmo de hashing foram implementadas a fim de melhorar o
distribuição de bits de ordem inferior no valor hash. Espera-se que isso produza melhor
desempenho em teclas que são sequências repetidas.

pacote() formato 'Z' suportado
O novo tipo de formato 'Z' é útil para compactar e desempacotar strings terminadas em nulo. Ver
"pack" em perlfunc.

pacote() formato mudança '!' suportado
O novo modificador de tipo de formato '!' é útil para embalar e desempacotar shorts nativos, ints,
e longs. Veja "pack" em perlfunc.

pacote() e desempacotar () ajuda contados cordas
O caractere do modelo '/' pode ser usado para especificar um tipo de string contado a ser empacotado ou
descompactado. Veja "pack" em perlfunc.

Comentários in pacote() modelos
O caractere '#' em um modelo introduz um comentário até o final da linha. Esse
facilita a documentação de pacote() templates.

Fraco referências
Nas versões anteriores do Perl, você não podia armazenar objetos em cache para permitir que eles fossem excluídos
se a última referência de fora do cache for excluída. A referência no cache seria
mantenha uma contagem de referência no objeto e os objetos nunca serão destruídos.

Outro problema familiar são as referências circulares. Quando um objeto faz referência a si mesmo,
sua contagem de referência nunca cairia a zero, e não seria destruída até que o
o programa está prestes a sair.

Referências fracas resolvem isso permitindo que você "enfraqueça" qualquer referência, ou seja, faça com que ela não
contar para a contagem de referência. Quando a última referência não fraca a um objeto é
excluído, o objeto é destruído e todas as referências fracas ao objeto são
automaticamente undef-ed.

Para usar este recurso, você precisa do pacote Devel :: WeakRef do CPAN, que contém
documentação adicional.

NOTA: este é um recurso experimental. Os detalhes estão sujeitos a alterações.

Binário números suportado
Números binários agora são suportados como literais, nos formatos s? Printf e "oct ()":

$ answer = 0b101010;
printf "A resposta é:% b \ n", oct ("0b101010");

Valor L sub-rotinas
As sub-rotinas agora podem retornar valores modificáveis. Veja "Sub-rotinas Lvalue" em perlsub.

NOTA: este é um recurso experimental. Os detalhes estão sujeitos a alterações.

Alguns setas pode be omitidos in chamadas através de referências
Perl agora permite que a seta seja omitida em muitas construções envolvendo chamadas de sub-rotina
por meio de referências. Por exemplo, "$ foo [10] -> ('foo')" agora pode ser escrito
"$ foo [10] ('foo')". Isso é bastante semelhante a como a flecha pode ser omitida de
"$ foo [10] -> {'foo'}". Observe, entretanto, que a seta ainda é necessária para
"Foo(10) -> ('bar') ".

Booleano atribuição operadores e guarante que os mesmos estão legal lvalores
Construções como "($ a || = 2) + = 1" agora são permitidas.

existe() is suportado on sub-rotina nomes
O existe() builtin agora funciona em nomes de sub-rotina. Uma sub-rotina é considerada existente
se foi declarado (mesmo que implicitamente). Veja "existe" em perlfunc para exemplos.

existe() e deletar () e guarante que os mesmos estão suportado on ordem elementos
O existe() e deletar () builtins agora funcionam em arrays simples também. O comportamento é
semelhante ao dos elementos hash.

existe() pode ser usado para verificar se um elemento da matriz foi inicializado. Isso evita
elementos da matriz autovivificando que não existem. Se a matriz estiver empatada, o EXISTE() método
no pacote vinculado correspondente será chamado.

deletar () pode ser usado para remover um elemento da matriz e retorná-lo. O elemento da matriz
nessa posição retorna ao seu estado não inicializado, de modo que o teste para o mesmo elemento
com existe() retornará falso. Se o elemento for aquele no final, o
o tamanho da matriz também diminui até o elemento mais alto que é verdadeiro para existe(), ou
0 se nada for encontrado. Se a matriz estiver empatada, o EXCLUIR() método no correspondente
pacote vinculado será invocado.

Veja "existe" em perlfunc e "deleta" em perlfunc para exemplos.

Pseudo-hashes trabalho better
Desreferenciar alguns tipos de valores de referência em um pseudo-hash, como "$ ph -> {foo} [1]",
foi desautorizado acidentalmente. Isso foi corrigido.

Quando aplicado a um elemento pseudo-hash, existe() agora relata se o valor especificado
existe, não apenas se a chave for válida.

deletar () agora funciona em pseudo-hashes. Quando recebe um elemento pseudo-hash ou fatia, ele exclui
os valores correspondentes às chaves (mas não às próprias chaves). Consulte "Pseudo-hashes:
Usando uma matriz como um hash "em perlref.

Fatias de pseudo-hash com chaves constantes agora são otimizadas para pesquisas de array em tempo de compilação.

As atribuições de lista para fatias de pseudo-hash agora são suportadas.

O pragma "campos" agora fornece maneiras de criar pseudo-hashes, via campos :: novo () e
campos :: phash (). Veja os campos.

NOTA: O tipo de dados pseudo-hash continua a ser experimental.
Limitar-se aos elementos de interface fornecidos pelo
O pragma de campos fornecerá proteção contra quaisquer alterações futuras.

Automático rubor of saída buffers
garfo(), exec (), sistema(), qx // e tubo abrir()s agora liberam buffers de todos os arquivos abertos para
saída quando a operação foi tentada. Isso elimina principalmente o armazenamento em buffer confuso
percalços sofridos por usuários que não sabem como o Perl lida internamente com I / O.

Isso não é suportado em algumas plataformas como Solaris, onde um correto
a implementação de fflush (NULL) não está disponível.

Melhor diagnósticos on sem sentido identificador de arquivo operações
Construções como "open ( ) "e" fechar ( ) "são erros de tempo de compilação. Tentando
ler a partir de manipuladores de arquivo que foram abertos apenas para gravação agora produzirá avisos (assim como
a gravação em manipuladores de arquivos somente leitura, sim).

Onde possível, tamponado dados, descartado da enganado entrada identificador de arquivo
"open (NEW," <& OLD ")" agora tenta descartar todos os dados que foram lidos anteriormente e
armazenado em "OLD" antes de enganar o identificador. Em plataformas onde isso é permitido, o
a próxima operação de leitura em "NEW" retornará os mesmos dados que a operação correspondente em
"VELHO". Anteriormente, ele teria retornado os dados do início do disco seguinte
bloquear em vez disso.

eof () tem da mesmo velho mágica as <>
"eof ()" retornaria verdadeiro se nenhuma tentativa de leitura de "<>" ainda tivesse sido feita. "eof ()" tem
foi alterado para ter um pouco de magia própria, agora abre os arquivos "<>".

binmode () pode be usava para conjunto : crlf e :cru modos
binmode () agora aceita um segundo argumento que especifica uma disciplina para o identificador em
pergunta. As duas pseudo-disciplinas ": raw" e ": crlf" são atualmente suportadas no DOS-
plataformas derivadas. Veja "binmode" em perlfunc e abra.

"-T" teste de arquivo reconhece UTF-8 codificado arquivos as "texto"
O algoritmo usado para o teste de arquivo "-T" foi aprimorado para identificar corretamente o UTF-8
conteúdo como "texto".

sistema(), crases e tubo aberto agora refletir exec () falha
Em Unix e plataformas semelhantes, sistema(), qx () e aberto (FOO, "cmd |") etc., são implementados
via garfo() e exec (). Quando o subjacente exec () falha, versões anteriores não relataram
o erro corretamente, uma vez que o exec () aconteceu estar em um processo diferente.

O processo filho agora se comunica com o pai sobre o erro ao iniciar o
comando externo, que permite que essas construções retornem com seu valor de erro usual e
definir $ !.

Melhorado diagnósticos
Os números das linhas não são mais suprimidos (sob as circunstâncias mais prováveis) durante o período global
fase de destruição.

Os diagnósticos emitidos a partir do código em execução em threads diferentes da thread principal agora são
acompanhado pelo ID do tópico.

Caracteres nulos incorporados em diagnósticos agora realmente aparecem. Eles costumavam truncar o
mensagem em versões anteriores.

$ foo :: a e $ foo :: b agora estão isentos de avisos de "possível erro de digitação" apenas se ordenar() is
encontrado no pacote "foo".

Escapes alfabéticos não reconhecidos encontrados ao analisar construções de cotação agora geram um
aviso, uma vez que eles podem assumir uma nova semântica em versões posteriores do Perl.

Muitos diagnósticos agora relatam a operação interna em que o aviso foi provocado, como
Sun:

Uso de valor não inicializado na concatenação (.) Na (eval 1) linha 1.
Uso de valor não inicializado na impressão na (avaliação 1) linha 1.

Os diagnósticos que ocorrem dentro da avaliação também podem relatar o arquivo e o número da linha onde o
eval está localizado, além do número de sequência eval e o número da linha dentro do
próprio texto avaliado. Por exemplo:

Argumentos insuficientes para escalar em (eval 4) [newlib / perl5db.pl: 1411] linha 2, em EOF

Diagnóstico seguir STDERR
A saída de diagnóstico agora vai para qualquer arquivo para o qual o identificador "STDERR" esteja apontando, em vez disso
de sempre ir para o "stderr" da biblioteca de tempo de execução C subjacente.

Mais consistente close-on-exec comportamento
Em sistemas que suportam um sinalizador close-on-exec em filehandles, o sinalizador agora está definido para qualquer
alças criadas por tubo(), socketpair (), soquete () e aceitar (), se isso for garantido por
o valor de $ ^ F que pode estar em vigor. Versões anteriores negligenciavam definir o sinalizador para
identificadores criados com esses operadores. Veja "pipe" em perlfunc, "socketpair" em perlfunc,
"socket" em perlfunc, "accept" em perlfunc e "$ ^ F" em perlvar.

syswrite () facilidade de uso
O argumento de comprimento de "syswrite ()" tornou-se opcional.

Melhor sintaxe cheques on entre parênteses unário operadores
Expressões como:

impressão definida (& foo, & bar, & baz);
imprimir uc ("foo", "bar", "baz");
undef ($ foo, & bar);

costumava ser acidentalmente permitido em versões anteriores e produzia um comportamento imprevisível.
Alguns produziram avisos auxiliares quando usados ​​dessa forma; outros silenciosamente fizeram o errado
coisa.

As formas entre parênteses da maioria dos operadores unários que esperam um único argumento agora garantem
que eles não são chamados com mais de um argumento, tornando os casos mostrados acima sintaxe
erros. O comportamento usual de:

imprimir definido & foo, & bar, & baz;
imprimir uc "foo", "bar", "baz";
undef $ foo, & bar;

permanece inalterado. Veja perlop.

Pouco operadores ajuda completa nativo número inteiro largura
Os operadores de bits (& | ^ ~ << >>) agora operam na largura integral nativa completa (o exato
cujo tamanho está disponível em $ Config {ivsize}). Por exemplo, se sua plataforma for
nativamente de 64 bits ou se Perl foi configurado para usar inteiros de 64 bits, essas operações
aplicam-se a 8 bytes (em oposição a 4 bytes em plataformas de 32 bits). Para portabilidade, certifique-se de
mascarar os bits em excesso no resultado de "~" unário, por exemplo, "~ $ x & 0xffffffff".

Melhorado segurança características
Operações mais potencialmente inseguras contaminam seus resultados para maior segurança.

Os campos "passwd" e "shell" retornados pelo getpwent (), getpwnam () e getpwuid () e guarante que os mesmos estão
agora contaminado, porque o usuário pode afetar sua própria senha criptografada e shell de login.

A variável modificada por shmread (), e mensagens retornadas por msgrcv () (e seu objeto-
interface orientada IPC :: SysV :: Msg :: rcv) também são corrompidos, porque outros não confiáveis
os processos podem modificar mensagens e segmentos de memória compartilhada para seus próprios propósitos nefastos.

Mais funcional palavra simples protótipo (*)
Os protótipos de palavras de barra foram racionalizados para permitir que sejam usados ​​para substituir os builtins
que aceitam barewords e os interpretam de uma maneira especial, como "exigir" ou "fazer".

Argumentos prototipados como "*" agora serão visíveis dentro da sub-rotina como um simples
escalar ou como uma referência a um typeglob. Veja "Protótipos" em perlsub.

"requer" e "Faz" pode be sobrescrito
As operações "requer" e "do 'arquivo'" podem ser substituídas localmente pela importação de sub-rotinas de
o mesmo nome no pacote atual (ou globalmente, importando-os para o
CORE :: GLOBAL :: namespace). Substituir "requer" também afetará o "uso", desde que
override é visível em tempo de compilação. Veja "Substituindo Funções Integradas" em perlsub.

$ ^ X variáveis pode agora nomes mais do que um personagem
Anteriormente, $ ^ X era sinônimo de $ {"\ cX"}, mas $ ^ XY era um erro de sintaxe. Agora variável
nomes que começam com um caractere de controle podem ser arbitrariamente longos. No entanto, para
razões de compatibilidade, essas variáveis devo ser escrito com colchetes explícitos, como "$ {^ XY}"
por exemplo. "$ {^ XYZ}" é sinônimo de $ {"\ cXYZ"}. Nomes de variáveis ​​com mais de um
caracteres de controle, como "$ {^ XY ^ Z}", são ilegais.

A sintaxe antiga não mudou. Como antes, `^ X 'pode ser um controle-X literal
caractere ou a sequência de dois caracteres 'circunflexo' mais 'X'. Quando as chaves são omitidas, o
o nome da variável pára após o caractere de controle. Assim, "$ ^ XYZ" continua a ser sinônimo
com "$ ^ X." YZ "" como antes.

Como antes, as variáveis ​​lexicais não podem ter nomes que começam com caracteres de controle. Como
antes, as variáveis ​​cujos nomes começam com um caractere de controle são sempre forçadas a estar em
pacote `main '. Todas essas variáveis ​​são reservadas para extensões futuras, exceto aquelas que
começam com "^ _", que pode ser usado por programas do usuário e não tem garantia de aquisição
significado especial em qualquer versão futura do Perl.

Novo variável $ ^ C reflete "-c" interruptor
$ ^ C tem um valor booleano que reflete se o perl está sendo executado em modo apenas de compilação (ou seja
através do interruptor "-c"). Uma vez que os blocos BEGIN são executados sob tais condições, este
variável permite que o código perl determine se as ações que fazem sentido apenas durante o normal
em execução são garantidos. Veja perlvar.

Novo variável $ ^ V contém Perl versão as a corda
$ ^ V contém o número da versão Perl como uma string composta de caracteres cujos ordinais
coincidir com os números da versão, ou seja, v5.6.0. Isso pode ser usado em comparações de strings.

Consulte "Suporte para strings representadas como um vetor de ordinais" para obter um exemplo.

Opcional Y2K avisos
Se o Perl for construído com a macro cpp "PERL_Y2KWARN" definida, ele emite avisos opcionais
ao concatenar o número 19 com outro número.

Este comportamento deve ser habilitado especificamente ao executar o Configure. Ver INSTALAR e
LEIA-ME.Y2K.

Arrays agora sempre interpolados para dentro aspas duplas cordas
Em strings com aspas duplas, os arrays agora interpolar, não importa o quê. O comportamento no início
versões do perl 5 era que os arrays se interpolariam em strings se o array tivesse sido
mencionado antes de a string ser compilada, caso contrário, o Perl geraria uma compilação fatal
erro de tempo. Nas versões 5.000 a 5.003, o erro era

Literal @example agora requer barra invertida

Nas versões 5.004_01 a 5.6.0, o erro era

Na string, @example agora deve ser escrito como \ @example

A ideia aqui era fazer com que as pessoas tivessem o hábito de escrever "fred \ @ example.com" quando
queria um sinal literal "@", assim como eles sempre escreveram "Devolva meus \ $ 5" quando
eles queriam um sinal literal "$".

Começando com 5.6.1, quando Perl agora vê um sinal "@" em uma string entre aspas duplas, sempre
tenta interpolar uma matriz, independentemente de a matriz ter sido usada ou não ou
já declarou. O erro fatal foi rebaixado para um aviso opcional:

Possível interpolação não intencional de @example na string

Isso avisa que "[email protected]"vai se transformar em" fred.com "se você não
barra invertida o "@". Ver http://perl.plover.com/at-error.html para mais detalhes sobre o
história aqui.

@- e @+ fornecer começando / terminando compensações of regex fósforos
As novas variáveis ​​mágicas @ - e @ + fornecem os deslocamentos inicial e final, respectivamente,
de $ &, $ 1, $ 2, etc. Veja perlvar para detalhes.

Módulos e Pragmático

Módulos
atributos
Embora usado internamente pelo Perl como um pragma, este módulo também fornece uma maneira de buscar
sub-rotina e atributos de variáveis. Veja os atributos.

B O pacote Perl Compiler foi amplamente retrabalhado para esta versão. Mais do
suite de teste Perl padrão passa quando executado no compilador, mas ainda há um
caminho significativo a percorrer para alcançar executáveis ​​compilados de qualidade de produção.

NOTA: O pacote de compiladores permanece altamente experimental. o
o código gerado pode não estar correto, mesmo quando consegue executar
sem erros.

referência
No geral, os resultados do Benchmark exibem erro médio inferior e melhor precisão de tempo.

Agora você pode executar testes para n segundos em vez de adivinhar o número certo de testes para
run: eg, timethese (-5, ...) irá executar cada código por pelo menos 5 segundos de CPU. Zero como
o "número de repetições" significa "por pelo menos 3 segundos de CPU". O formato de saída tem
também mudou. Por exemplo:

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

agora produzirá algo como isto:

Referência: executando a, b, cada um por pelo menos 5 segundos de CPU ...
a: 5 segundos de parede (5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91 / s (n = 1156516)
b: 4 segundos de clock (5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18 / s (n = 800686)

Novos recursos: "cada um por pelo menos N segundos de CPU ...", "segundos do relógio" e o "@
operações / segundo CPU (n = operações) ".

tempo estes () agora retorna uma referência a um hash de objetos Benchmark contendo o teste
resultados, com base nos nomes dos testes.

timethis () agora retorna o campo de iterações no objeto de resultado do Benchmark em vez de
0.

tempo estes (), timethis (), E o novo cmpthese () (veja abaixo) também pode assumir um formato
especificador de 'nenhum' para suprimir a saída.

Uma nova função countit () é como timeit () exceto que leva TIME em vez de
uma CONTAGEM.

Uma nova função cmpthese () imprime um gráfico comparando os resultados de cada teste retornado
a partir de um tempo estes () ligar. Para cada par possível de testes, a velocidade percentual
diferença (iters / seg ou segundos / iter) é mostrada.

Para outros detalhes, consulte Benchmark.

ByteLoaderName
O ByteLoader é uma extensão dedicada para gerar e executar bytecode Perl. Ver
ByteLoader.

constante
As referências agora podem ser usadas.

A nova versão também permite um sublinhado inicial em nomes de constantes, mas não permite um
sublinhado inicial duplo (como em "__LINE__"). Alguns outros nomes não são permitidos ou
advertido contra, incluindo BEGIN, END, etc. Alguns nomes que foram forçados em main ::
costumava falhar silenciosamente em alguns casos; agora eles são fatais (fora do main: :) e um
aviso opcional (dentro de principal: :). A capacidade de detectar se uma constante teve
foi definido com um determinado nome foi adicionado.

Veja constante.

nomes de personagens
Este pragma implementa o escape de seqüência de caracteres "\ N". Veja charnames.

Dados :: Dumper
Uma configuração "Maxdepth" pode ser especificada para evitar se aventurar muito profundamente em dados profundos
estruturas. Consulte Data :: Dumper.

A implementação XSUB de Jogar fora() agora é chamado automaticamente se a configuração "Useqq"
não está em uso.

Despejar objetos "qr //" funciona corretamente.

DB "DB" é um módulo experimental que expõe uma abstração limpa para depuração do Perl
API.

Arquivo_BD
DB_File agora pode ser construído com Berkeley DB versões 1, 2 ou 3. Consulte
"ext / DB_File / Changes".

Develop :: DProf
Develop :: DProf, um criador de perfil de código-fonte Perl foi adicionado. Veja Devel :: DProf e
dprofpp.

Develop :: Peek
O módulo Devel :: Peek fornece acesso à representação interna do Perl
variáveis ​​e dados. É uma ferramenta de depuração de dados para o programador XS.

Valor de despejo
O módulo Dumpvalue fornece dumps de tela de dados Perl.

Dyna Loader
DynaLoader agora suporta um dl_unload_file () funcionar em plataformas que suportam
descarregar objetos compartilhados usando dlclose ().

Perl também pode opcionalmente organizar para descarregar todos os objetos compartilhados de extensão carregados por
Perl. Para habilitar isso, crie Perl com a opção Configurar
"-Accflags = -DDL_UNLOAD_ALL_AT_EXIT". (Isso pode ser útil se você estiver usando o Apache com
mod_perl.)

Inglês
$ PERL_VERSION agora significa $ ^ V (um valor de string) em vez de $] (um valor numérico
valor).

Env Env agora suporta o acesso a variáveis ​​de ambiente como PATH como variáveis ​​de array.

Fcntl
Mais constantes Fcntl adicionadas: F_SETLK64, F_SETLKW64, O_LARGEFILE para arquivo grande (mais
de 4 GB) de acesso (NOTA: o O_LARGEFILE é adicionado automaticamente ao sysopen () sinaliza se
o suporte a arquivos grandes foi configurado, como é o padrão), Free / Net / OpenBSD locking
sinalizadores de comportamento F_FLOCK, F_POSIX, Linux F_SHLCK e O_ACCMODE: a máscara combinada de
O_RDONLY, O_WRONLY e O_RDWR. o procurar()/sysseek () constantes SEEK_SET, SEEK_CUR,
e SEEK_END estão disponíveis por meio da tag ": seek". o chmod ()/stat () S_IF * constantes
e as funções S_IS * estão disponíveis por meio da tag ": mode".

Arquivo :: Comparar
A compare_text () função foi adicionada, o que permite funções de comparação personalizadas.
Consulte Arquivo :: Comparar.

Arquivo :: Encontrar
Arquivo :: Localizar agora funciona corretamente quando o procurado() função é carregada automaticamente ou é um
referência simbólica.

Um bug que fazia com que File :: Find perdesse o controle do diretório de trabalho ao remover o topo
diretórios de nível foram corrigidos.

File :: Find agora também suporta várias outras opções para controlar seu comportamento. Pode
seguir links simbólicos se a opção "seguir" for especificada. Habilitando o "no_chdir"
a opção fará com que Arquivo :: Encontrar pule a mudança do diretório atual ao caminhar
diretórios. O sinalizador "untaint" pode ser útil ao executar as verificações de contaminação ativadas.

Consulte Arquivo :: Encontrar.

Arquivo :: Glob
Esta extensão implementa globbing de arquivo no estilo BSD. Por padrão, ele também será usado
para a implementação interna do glob () operador. Veja Arquivo :: Glob.

Arquivo :: Especificação
Novos métodos foram adicionados ao módulo File :: Spec: devnull () retorna o nome de
o dispositivo nulo (/ dev / null no Unix) e tmpdir () o nome do diretório temporário
(normalmente / Tmp no Unix). Agora também existem métodos para converter entre absoluto e
nomes de arquivos relativos: abs2rel () e rel2abs (). Para compatibilidade com sistemas operacionais
que especificam nomes de volume em caminhos de arquivo, o splitpath (), splitdir () e catdir ()
métodos foram adicionados.

Arquivo :: Especificação :: Funções
Os novos módulos File :: Spec :: Functions fornecem uma interface de função para o File :: Spec
módulo. Permite taquigrafia

$ fullname = catfile ($ dir1, $ dir2, $ file);

em vez de

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

Getopt :: Long
Getopt :: A licença longa foi alterada para permitir a Licença Artística Perl, bem como a
GPL. Costumava ser apenas GPL, o que atrapalhava os aplicativos não GPL que desejavam
para usar Getopt :: Long.

Getopt :: Long encoraja o uso de Pod :: Usage para produzir mensagens de ajuda. Por exemplo:

use Getopt :: Long;
use Pod :: Usage;
meu $ man = 0;
minha $ help = 0;
GetOptions ('help |?' => \ $ Help, man => \ $ man) ou pod2usage(2);
pod2usage(1) se $ help;
pod2usage (-exitstatus => 0, -verbose => 2) se $ man;

__FIM__

= head1 NAME

amostra - Usando Getopt :: Long e Pod :: Usage

= head1 SINOPSE

amostra [opções] [arquivo ...]

opções:
-ajuda breve mensagem de ajuda
documentação completa do homem

= head1 OPÇÕES

= mais de 8

= item B <-ajuda>

Imprime uma breve mensagem de ajuda e sai.

= item B <-man>

Imprime a página do manual e sai.

= voltar

= head1 DESCRIÇÃO

B irá ler o (s) arquivo (s) de entrada fornecido (s) e fazer algo
útil com o seu conteúdo.

= corte

Consulte Pod :: Uso para obter detalhes.

Um bug que evitou que o call-back não opcional <> fosse especificado como o primeiro
argumento foi corrigido.

Para especificar os caracteres <e> como iniciadores de opção, use> <. Observe, no entanto, que
a mudança dos starters de opção está fortemente obsoleta.

IO write () e syswrite () agora aceitará uma forma de argumento único da chamada, para
consistência com o de Perl syswrite ().

Agora você pode criar um IO :: Socket :: INET baseado em TCP sem forçar uma tentativa de conexão.
Isso permite que você configure suas opções (como torná-lo não bloqueador) e, em seguida, chame
conectar() manualmente.

Um bug que impedia o IO :: Socket :: protocol () acessor de nunca devolver o
o valor correto foi corrigido.

IO :: Socket :: connect agora usa IO sem bloqueio em vez de alarme() para fazer conectar
tempos limite.

IO :: Socket :: aceitar agora usa select () em vez de alarme() para fazer timeouts.

IO :: Socket :: INET-> new agora define $! corretamente em caso de falha. $ @ ainda está definido para trás
compatibilidade.

JPL Java Perl Lingo agora é distribuído com Perl. Veja jpl / README para mais informações.

lib "use lib" agora elimina quaisquer entradas duplicadas remanescentes. "no lib" remove todos os nomes
entradas.

Math :: BigInt
As operações bit a bit "<<", ">>", "&", "|" e "~" agora são suportadas em bigints.

Matemática :: Complexo
Os métodos de acesso Re, Im, arg, abs, rho e theta agora também podem atuar como mutadores
(acessador $ z->Ré(), mutador $ z->Re(3)).

O método de classe "display_format" e o método de objeto correspondente
"display_format", além de aceitar apenas um argumento, agora também pode aceitar um
hash de parâmetro. As chaves reconhecidas de um hash de parâmetro são "estilo", que corresponde a
o antigo caso de parâmetro e dois novos parâmetros: "formato", que é um
printf ()string de formato de estilo (o padrão geralmente é "% .15g", você pode reverter para o
padrão, definindo a string de formato para "undef") usado para ambas as partes de um complexo
número e "polar_pretty_print" (o padrão é verdadeiro), que controla se uma tentativa
é feito para tentar reconhecer pequenos múltiplos e racionais de pi (2pi, pi / 2) no
argumento (ângulo) de um número complexo polar.

A mudança potencialmente perturbadora é que, no contexto da lista, ambos os métodos agora retorno da
parâmetro hash, em vez de apenas o valor do parâmetro "estilo".

Matemática :: Trig
Um pouco de trigonometria radial (cilíndrica e esférica), coordenada radial
conversões, e a grande distância do círculo foram adicionadas.

Pod :: Parser, Pod :: InputObjects
Pod :: Parser é uma classe base para analisar e selecionar seções da documentação do pod
de um fluxo de entrada. Este módulo se encarrega de identificar os parágrafos do pod e
comandos na entrada e entrega os parágrafos analisados ​​e comandos definidos pelo usuário
métodos que são livres para interpretá-los ou traduzi-los como bem entenderem.

Pod :: InputObjects define alguns objetos de entrada necessários para Pod :: Parser e para
usuários de Pod :: Parser que precisam mais sobre um comando além de seu nome e texto.

A partir da versão 5.6.0 do Perl, Pod :: Parser é agora o "analisador de base oficialmente aprovado
code "recomendado para uso por todos os tradutores pod2xxx. Pod :: Text (pod2text) e
Pod :: Man (pod2man) já foi convertido para usar Pod :: Parser e os esforços para
convert Pod :: HTML (pod2html) já estão em andamento. Para quaisquer perguntas ou comentários
sobre os problemas de análise e tradução de pods e utilitários, use o
[email protected] lista de discussão.

Para obter mais informações, consulte Pod :: Parser e Pod :: InputObjects.

Pod :: Checker, podchecker
Este utilitário verifica os arquivos de pod quanto à sintaxe correta, de acordo com o perlpod. Óbvio
erros são sinalizados como tal, enquanto avisos são impressos para erros que podem ser
manuseado graciosamente. A lista de verificação ainda não está completa. Consulte Pod :: Checker.

Pod :: ParseUtils, Pod :: Find
Esses módulos fornecem um conjunto de dispositivos que são úteis principalmente para tradutores de pod.
Pod :: Find atravessa estruturas de diretório e retorna arquivos de pod encontrados, junto com seus
nomes canônicos (como "File :: Spec :: Unix"). Pod :: ParseUtils contém Pod :: List (útil
para armazenar informações da lista de pod), Pod :: Hyperlink (para analisar o conteúdo de "L <>"
sequências) e Pod :: Cache (para armazenar informações sobre arquivos de pod, por exemplo, nós de link).

Pod :: Select, podselect
Pod :: Select é uma subclasse de Pod :: Parser que fornece uma função chamada "podselect ()"
para filtrar seções especificadas pelo usuário da documentação bruta do pod de um fluxo de entrada.
podselect é um script que fornece acesso a Pod :: Select de outros scripts para ser
usado como um filtro. Consulte Pod :: Select.

Pod :: Usage, pod2usage
Pod :: Usage fornece a função "pod2usage ()"para imprimir mensagens de uso para um Perl
script baseado em sua documentação de pod embutida. o pod2usage () função é geralmente
útil para todos os autores de script, pois permite que escrevam e mantenham uma única fonte
(os pods) para documentação, eliminando assim a necessidade de criar e manter
texto da mensagem de uso que consiste em informações já nos pods.

Há também um script pod2usage que pode ser usado a partir de outros tipos de scripts para
imprimir mensagens de uso de pods (mesmo para scripts não Perl com pods incorporados em
comentários).

Para obter detalhes e exemplos, consulte Pod :: Usage.

Pod :: Texto e Pod :: Homem
Pod :: Text foi reescrito para usar Pod :: Parser. Enquanto pod2text () Ainda está disponível
para compatibilidade com versões anteriores, o módulo agora tem uma nova interface preferencial. Ver
Pod :: Texto para detalhes. O novo módulo Pod :: Text é facilmente subclassificado para ajustes
para a saída, e duas dessas subclasses (Pod :: Text :: Termcap para o estilo de página de manual negrito e
sublinhado usando informações de termcap e Pod :: Text :: Color para marcação com cor ANSI
sequências) agora são padrão.

pod2man foi transformado em um módulo, Pod :: Man, que também usa Pod :: Parser. No
processo, vários bugs pendentes relacionados a citações nos cabeçalhos das seções, citando
escapes de código e listas aninhadas foram corrigidas. pod2man agora é um script de wrapper
em torno deste módulo.

SDBM_Arquivo
Um método EXISTS foi adicionado a este módulo (e sdbm_exists () foi adicionado a
a biblioteca sdbm subjacente), então agora é possível chamar o existe em um hash vinculado SDBM_File e
obter o resultado correto, em vez de um erro de tempo de execução.

Um bug que pode ter causado perda de dados quando mais de um bloco de disco é lido
do banco de dados em um único BUSCAR() foi corrigido.

Sys :: Syslog
Sys :: Syslog agora usa XSUBs para acessar recursos de syslog.h, portanto, não requer mais
syslog.ph existe.

Sys :: Hostname
Sys :: Hostname agora usa XSUBs para chamar a biblioteca C gethostname () or uname () se eles
existir.

Termo :: ANSIColor
Term :: ANSIColor é um módulo muito simples para fornecer acesso fácil e legível ao
Cor ANSI e sequências de escape de destaque, suportadas pela maioria dos terminais ANSI
emuladores. Agora está incluído como padrão.

Horário :: Local
O timelocal () e timegm () funções usadas para retornar silenciosamente resultados falsos quando o
data caiu fora do intervalo inteiro da máquina. Eles agora consistentemente coaxar () se o
data cai em um intervalo não suportado.

Win32
O valor de retorno do erro no contexto da lista foi alterado para todas as funções que retornam
uma lista de valores. Anteriormente, essas funções retornavam uma lista com um único elemento
"undef" se ocorreu um erro. Agora, essas funções retornam a lista vazia nestes
situações. Isso se aplica às seguintes funções:

Win32 :: FsType
Win32 :: GetOSVersion

As funções restantes permanecem inalteradas e continuam a retornar "undef" em caso de erro, mesmo em
contexto da lista.

A função Win32 :: SetLastError (ERROR) foi adicionada como um complemento ao
Win32 :: GetLastError () função.

O novo Win32 :: GetFullPathName (FILENAME) retorna o caminho absoluto completo para
FILENAME em contexto escalar. No contexto da lista, ele retorna uma lista de dois elementos contendo
o nome completo do diretório e o nome do arquivo. Veja Win32.

XSLoaderGenericName
A extensão XSLoader é uma alternativa mais simples ao DynaLoader. Veja XSLoader.

Filtros DBM
Um novo recurso chamado "Filtros DBM" foi adicionado a todos os módulos DBM - DB_File,
GDBM_File, NDBM_File, ODBM_File e SDBM_File. Filtros DBM adicionam quatro novos métodos para
cada módulo DBM:

filter_store_key
filtro_store_value
filter_fetch_key
filter_fetch_value

Eles podem ser usados ​​para filtrar pares de valor-chave antes que os pares sejam gravados no
banco de dados ou logo após serem lidos do banco de dados. Veja perldbmfilter para mais
informações.

Pragmático
"use attrs" agora é obsoleto e é fornecido apenas para compatibilidade com versões anteriores. Tem sido
substituído pela sintaxe "sub: atributos". Veja "Atributos de subrotina" em perlsub e
atributos.

Pragma de avisos lexicais, "use avisos;", para controlar avisos opcionais. Veja perllexwarn.

"use filetest" para controlar o comportamento dos filetests ("-r" "-w" ...). Atualmente apenas um
subpragma implementado, "use filetest 'access';", que usa Acesso(2) ou equivalente a
verifique as permissões em vez de usar estado(2) como de costume. Isso é importante em sistemas de arquivos onde
existem ACLs (listas de controle de acesso): o estado(2) pode mentir, mas Acesso(2) sabe melhor.

O pragma "aberto" pode ser usado para especificar disciplinas padrão para construtores de alças (por exemplo
abrir()) e para qx //. As duas pseudo-disciplinas ": raw" e ": crlf" estão atualmente
suportado em plataformas derivadas do DOS (isto é, onde binmode não é autônomo). Veja também
"binmode () pode ser usado para definir os modos: crlf e: raw ".

Utilidade Alterações

dprofpp
"dprofpp" é usado para exibir dados de perfil gerados usando "Devel :: DProf". Veja dprofpp.

encontrar2perl
O utilitário "find2perl" agora usa os recursos aprimorados do módulo Arquivo :: Localizar. o
As opções -depth e -follow são suportadas. A documentação do pod também está incluída no
script.

H2xs
A ferramenta "h2xs" agora pode funcionar em conjunto com "C :: Scan" (disponível no CPAN) para
analisa automaticamente os arquivos de cabeçalho da vida real. As opções "-M", "-a", "-k" e "-o" são
nova.

perlcc
"perlcc" agora suporta backends C e Bytecode. Por padrão, ele gera saída de
o back-end C simples em vez do back-end C otimizado.

O suporte para plataformas não-Unix foi melhorado.

perldoc
"perldoc" foi retrabalhado para evitar possíveis falhas de segurança. Não vai, por padrão, deixar
em si ser executado como o superusuário, mas você ainda pode usar o -U mude para tentar fazer cair
privilégios primeiro.

O Perl Debugger
Muitas correções de bugs e melhorias foram adicionadas ao perl5db.pl, o depurador Perl. A ajuda
a documentação foi reorganizada. Novos comandos incluem "<?", ">?" E "{?" listar
ações atuais, "cara docpage " para executar seu visualizador de documentos em algum docset perl e suporte para
opções citadas. As informações de ajuda foram reorganizadas e devem ser visualizadas novamente se
você está usando menos como seu pager. Uma falha grave de segurança foi conectada - você deve
remover imediatamente todas as versões anteriores do depurador Perl como instaladas na versão anterior
lançamentos, de volta ao perl3, de seu sistema para evitar ser mordido por eles.

Melhorado Documentação

Muitos dos arquivos README específicos da plataforma agora fazem parte da instalação do perl. Ver
perl para a lista completa.

perlapi.pod
A lista oficial de funções públicas da API Perl.

perlboot.pod
Um tutorial para iniciantes em Perl orientado a objetos.

perlcompile.pod
Uma introdução ao uso do pacote Perl Compiler.

perldbmfilter.pod
Um documento de instruções sobre como usar o recurso de filtro DBM.

perldebug.pod
Todo o material não relacionado à execução do depurador Perl, além de todos os tipos de guts de baixo nível
detalhes que corriam o risco de esmagar o usuário casual do depurador, foram realocados de
a página de manual antiga para a próxima entrada abaixo.

perldebguts.pod
Esta nova página de manual contém material de nível excessivamente baixo não relacionado ao Perl
depurador, mas ligeiramente relacionado à depuração do próprio Perl. Ele também contém algum arcano
detalhes internos de como funciona o processo de depuração que podem ser do interesse apenas para
desenvolvedores de depuradores Perl.

perlfork.pod
Notas sobre o garfo() emulação atualmente disponível para a plataforma Windows.

perlfilter.pod
Uma introdução à escrita de filtros fonte Perl.

perlhack.pod
Algumas diretrizes para hackear o código-fonte do Perl.

perlintern.pod
Uma lista de funções internas no código-fonte do Perl. (A lista está vazia no momento.)

perllexwarn.pod
Introdução e informações de referência sobre categorias de aviso com escopo léxico.

perlnumber.pod
Informações detalhadas sobre os números conforme são representados em Perl.

perlopentut.pod
Um tutorial sobre como usar abrir() eficazmente.

perlreftut.pod
Um tutorial que apresenta os fundamentos das referências.

perltootc.pod
Um tutorial sobre como gerenciar dados de classe para módulos de objeto.

perltodo.pod
Discussão dos recursos mais procurados que podem algum dia ter suporte no Perl.

perlunicocode.pod
Uma introdução aos recursos de suporte Unicode em Perl.

Desempenho Melhorias

simples ordenar() utilização { $a <=> $b } e da como e guarante que os mesmos estão otimizado
Muitos comuns ordenar() operações que usam um bloco embutido simples agora são otimizadas para agilizar
desempenho.

Otimizado atribuições para lexical variáveis
Certas operações no RHS de instruções de atribuição foram otimizadas para definir diretamente
a variável lexical no LHS, eliminando sobrecargas de cópia redundantes.

Mais rápido sub-rotina chamadas
Pequenas mudanças em como as chamadas de sub-rotina são tratadas internamente fornecem melhorias marginais
no desempenho.

deletar (), cada(), valores () e hash iteração e guarante que os mesmos estão mais rápido
Os valores de hash retornados por deletar (), cada(), valores () e hashes em um contexto de lista são
os valores reais no hash, em vez de cópias. Isso resulta em significativamente melhor
desempenho, porque elimina a cópia desnecessária na maioria das situações.

Instalação e Configuração Melhorias

-Dusethreads significa alguma coisa diferente
O sinalizador -Dusethreads agora ativa o suporte experimental de thread baseado em interpretador por
predefinição. Para obter o sabor dos tópicos experimentais que estavam em 5.005, você precisa
execute Configure com "-Dusethreads -Duse5005threads".

Desde a v5.6.0, o suporte a encadeamentos do interpretador ainda não tem uma maneira de criar novos encadeamentos
do Perl (ou seja, "use Thread;" não funcionará com threads de intérprete). "use Thread;"
continua disponível quando você especifica a opção -Duse5005threads para Configurar, bugs
e tudo.

NOTA: o suporte para threads continua sendo um recurso experimental.
As interfaces e a implementação estão sujeitas a mudanças repentinas e drásticas.

Novo configurar bandeiras
Os novos sinalizadores a seguir podem ser habilitados na linha de comando do Configure executando Configure
com "-Dflag".

usar multiplicidade
usethreads useithreads (novos threads de intérprete: nenhuma API Perl ainda)
usethreads use5005threads (threads como eram em 5.005)

use64bitint (igual a agora obsoleto 'use64bits')
use64bitall

uselongdoble
use mais bits
use arquivos grandes
useocks (apenas SOCKS v5 suportado)

Rosqueamento e 64 bits agora mais ousado
As opções de configuração que permitem o uso de threads e o uso de 64 bits agora são mais
ousadia no sentido de que eles não têm mais uma lista explícita de sistemas operacionais de conhecidos
threads / recursos de 64 bits. Em outras palavras: se o seu sistema operacional tem o necessário
APIs e tipos de dados, você deve ser capaz de ir em frente e usá-los, para threads por
Configure -Dusethreads, e para 64 bits explicitamente por Configure -Duse64bitint ou
implicitamente se o seu sistema tiver tipos de dados de 64 bits. Consulte também "suporte a 64 bits".

longo Dupla
Algumas plataformas têm "duplos longos", números de ponto flutuante de alcance ainda maior do que
"duplos" comuns. Para habilitar o uso de duplas longas para escalares de Perl, use -Duselongdouble.

-Dusemorebits
Você pode habilitar -Duse64bitint e -Duselongdouble com -Dusemorebits. Veja também
"Suporte a 64 bits".

-Dusearquivosgrandes
Algumas plataformas suportam APIs de sistema que são capazes de lidar com arquivos grandes (normalmente,
arquivos maiores que dois gigabytes). Perl tentará usar essas APIs se você solicitar
-Duse arquivos grandes.

Consulte "Suporte a arquivos grandes" para obter mais informações.

instalarusrbinperl
Você pode usar "Configure -Uinstallusrbinperl" que faz com que o installperl ignore a instalação
perl também como / usr / bin / perl. Isso é útil se você preferir não modificar / usr / bin para alguns
razão ou outra, mas prejudicial porque muitos scripts presumem encontrar Perl em / usr / bin / perl.

MEIAS ajuda
Você pode usar "Configure -Dusesocks" que faz com que o Perl investigue o protocolo de proxy SOCKS
biblioteca (v5, não v4). Para obter mais informações sobre SOCKS, consulte:

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

"-UMA" bandeira
Você pode "pós-editar" as variáveis ​​de configuração usando a opção Configurar "-A". A edição
acontece imediatamente após os arquivos de dicas específicos da plataforma serem processados, mas antes
o processo de configuração real é iniciado. Execute "Configure -h" para descobrir o "-A" completo
sintaxe.

Eficiência Instalação diretórios
A estrutura de instalação foi enriquecida para melhorar o suporte para manutenção
várias versões de perl, para fornecer locais para módulos fornecidos por fornecedores, scripts e
manpages e para facilitar a manutenção de módulos, scripts e manpages adicionados localmente. Ver
a seção sobre diretórios de instalação no arquivo INSTALL para detalhes completos. Para
a maioria dos usuários construindo e instalando a partir do código-fonte, os padrões devem ser adequados.

Se você já usou "Configure -Dsitelib" ou "-Dsitearch" para definir valores especiais para
diretórios de biblioteca, você pode querer considerar o uso da nova configuração "-Dsiteprefix"
em vez de. Além disso, se você deseja reutilizar um arquivo config.sh de uma versão anterior do perl,
você deve verificar se o Configure faz escolhas sensatas para os novos diretórios.
Veja INSTALAR para detalhes completos.

Plataforma aplicação alterar

Suportado plataformas
· Os Mach CThreads (NEXTSTEP, OPENSTEP) agora são suportados pela extensão Thread.

· GNU / Hurd agora é suportado.

· Rapsódia / Darwin agora é compatível.

· EPOC agora é compatível (no Psion 5).

· A porta cygwin (anteriormente cygwin32) foi muito melhorada.

DOS
· Perl agora funciona com djgpp 2.02 (e 2.03 alpha).

· Nomes de variáveis ​​de ambiente não são mais convertidos em maiúsculas.

· Códigos de saída incorretos de crases foram corrigidos.

· Esta porta continua a usar seu próprio globbing embutido (não File :: Glob).

OS390 (Edição Aberta MVS)
O suporte para esta plataforma EBCDIC não foi renovado nesta versão. Existem
dificuldades em reconciliar a padronização de Perl em UTF-8 como sua representação interna
para caracteres com o conjunto de caracteres EBCDIC, porque os dois são incompatíveis.

Não está claro se as versões futuras renovarão o suporte para esta plataforma, mas o
possibilidade existe.

VMS
Numerosas revisões e extensões para configuração, construção, teste e instalação
processo para acomodar mudanças essenciais e opções específicas de VMS.

Expanda o código de manipulação de% ENV para permitir o mapeamento em tempo de execução para nomes lógicos, símbolos CLI e CRTL
gama de amb.

Extensão do código de chamada de subprocesso para aceitar as especificações de arquivo como "verbos" de comando.

Adicione ao processamento de linha de comando Perl a capacidade de usar tipos de arquivo padrão e reconhecer
Estilo Unix "2> & 1".

Expansão das rotinas File :: Spec :: VMS e integração em ExtUtils :: MM_VMS.

Extensão de ExtUtils :: MM_VMS para lidar com extensões complexas de forma mais flexível.

Barewords no início de caminhos de sintaxe Unix podem ser tratados como texto em vez de apenas como lógico
nomes.

Tradução segura opcional de vários nomes lógicos usados ​​internamente pelo Perl.

Correção de bugs diversos e portação de novo código principal para VMS.

Agradecemos de bom grado às muitas pessoas que contribuíram com patches VMS, testes,
e ideias.

Win32
Perl agora pode emular garfo() internamente, usando vários intérpretes em execução em diferentes
threads simultâneos. Este suporte deve ser habilitado no momento da construção. Veja perlfork para
informação detalhada.

Quando fornecido um nome de caminho que consiste apenas em um nome de driver, como "A:", opendir () e
stat () agora use o diretório de trabalho atual para a unidade em vez da raiz da unidade.

As funções XSUB embutidas no namespace Win32 :: são documentadas. Veja Win32.

$ ^ X agora contém o nome do caminho completo do executável em execução.

A Win32 :: GetLongPathName () função é fornecida para complementar Win32 :: GetFullPathName () e
Win32 :: GetShortPathName (). Veja Win32.

POSIX :: uname () é suportado.

system (1, ...) agora retorna IDs de processo verdadeiros em vez de identificadores de processo. matar() aceita
qualquer id de processo real, em vez de valores retornados estritamente do sistema (1, ...).

Para melhor compatibilidade com Unix, "kill (0, $ pid)" agora pode ser usado para testar se um
o processo existe.

O módulo "Shell" é compatível.

Melhor suporte para a construção de Perl em command.com no Windows 95 foi adicionado.

Os scripts são lidos em modo binário por padrão para permitir ByteLoader (e o mecanismo de filtro
em geral) para funcionar corretamente. Para compatibilidade, o identificador de arquivo DATA será definido como texto
modo se um retorno de carro for detectado no final da linha que contém o __END__ ou
Token __DATA__; caso contrário, o identificador de arquivo DATA será deixado aberto no modo binário. Mais cedo
as versões sempre abrem o arquivo DATA no modo texto.

O glob () operador é implementado por meio da extensão "File :: Glob", que suporta glob
sintaxe do C shell. Isso aumenta a flexibilidade do glob () operadora, mas lá
podem ser problemas de compatibilidade para programas que dependiam da sintaxe globbing mais antiga. Se você
deseja preservar a compatibilidade com a sintaxe mais antiga, você pode querer executar perl com
"-MFile :: DosGlob". Para obter detalhes e informações de compatibilidade, consulte Arquivo :: Glob.

Significativo erro fixo

on vazio arquivos
Com $ / definido como "undef", "slurping" um arquivo vazio retorna uma string de comprimento zero (ao invés
de "undef", como costumava acontecer) na primeira vez que o HANDLE é lido após $ / ser definido como "undef".
Outras leituras produzem "undef".

Isso significa que o seguinte anexará "foo" a um arquivo vazio (ele não fazia nada):

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

O comportamento de:

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

permanece inalterado (continua a deixar o arquivo vazio).

"eval '...' " melhorias
Números de linha (conforme refletido por chamador () e a maioria dos diagnósticos) em "eval '...'" foram
frequentemente incorreto onde os documentos estavam envolvidos. Isso foi corrigido.

Pesquisas lexicais para variáveis ​​que aparecem em "eval '...'" dentro de funções que foram
eles próprios chamados dentro de um "eval '...'" estavam procurando léxicos no lugar errado. O
a pesquisa lexical agora termina corretamente no limite do bloco da sub-rotina.

O uso de "return" dentro de "eval {...}" fazia com que $ @ não fosse redefinido corretamente quando não
exceção ocorreu dentro do eval. Isso foi corrigido.

A análise destes documentos costumava ser falha quando eles apareciam como substitutos
expressão em "eval 's /.../.../ e'". Isso foi corrigido.

Todas as compilação erros e guarante que os mesmos estão verdadeiro erros
Alguns "erros" encontrados em tempo de compilação foram gerados por necessidade conforme avisos seguidos
por eventual rescisão do programa. Isso permitiu que mais desses erros fossem relatados em um
única execução, em vez de causar uma parada brusca no primeiro erro encontrado.

O mecanismo para relatar tais erros foi reimplementado para enfileirar o tempo de compilação
erros e relatá-los no final da compilação como erros verdadeiros, em vez de
avisos. Isso corrige casos em que mensagens de erro vazavam na forma de avisos
quando o código foi compilado em tempo de execução usando "eval STRING", e também permite que tais erros sejam
confiavelmente preso usando "eval" ... "".

Implicitamente fechado manipuladores de arquivo e guarante que os mesmos estão mais segura
Às vezes, manipuladores de arquivos implicitamente fechados (como quando eles são localizados, e Perl
fecha-os automaticamente ao sair do escopo) poderia inadvertidamente definir $? ou $ !. Isto
foi corrigido.

Comportamento of Lista fatias is mais consistente
Ao obter uma fatia de uma lista literal (em oposição a uma fatia de uma matriz ou hash), Perl
usado para retornar uma lista vazia se o resultado for composto de todos os valores undef.

O novo comportamento é produzir uma lista vazia se (e somente se) a lista original estiver vazia.
Considere o seguinte exemplo:

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

O comportamento antigo teria resultado em @a sem elementos. O novo comportamento garante
tem três elementos indefinidos.

Observe em particular que o comportamento das fatias dos seguintes casos permanece o mesmo:

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

Veja perldata.

"(\ $)" protótipo e $ foo {a}
Um protótipo de referência escalar agora permite corretamente um hash ou elemento de matriz nesse slot.

"vamos para &sub" e CARREGAMENTO AUTOMÁTICO
A construção "goto & sub" funciona corretamente quando & sub é carregado automaticamente.

"-bareword" permitidas para "usar inteiro "
A citação automática de barewords precedidos por "-" não funcionava nas versões anteriores, quando o
O pragma "inteiro" foi ativado. Isso foi corrigido.

Falhas in DESTRUIR()
Quando o código em um destruidor lançava uma exceção, isso passava despercebido nas versões anteriores do
Perl, a menos que alguém esteja olhando $ @ logo após o ponto do destruidor
aconteceu de correr. Essas falhas agora são visíveis como avisos quando os avisos são ativados.

Localidade erros fixado
printf () e sprintf () anteriormente redefinir a localidade numérica de volta para a localidade "C" padrão.
Isso foi corrigido.

Números formatados de acordo com a localidade numérica local (como usando uma vírgula decimal
em vez de um ponto decimal) causou avisos "não é numérico", mesmo enquanto as operações
acessar esses números produziu resultados corretos. Esses avisos foram interrompidos.

Memória vazamentos
A construção "eval 'return sub {...}'" às vezes pode vazar memória. Isso foi corrigido.

Operações que não são construtores de manipulador de arquivos usados ​​para vazar memória quando usados ​​em
filehandles. Isso foi corrigido.

Construções que modificaram @_ podem falhar ao desalocar valores em @_ e, assim, vazar memória.
Isso foi corrigido.

espúrio sub-rotina tocos depois de fracassado sub-rotina chamadas
Perl às vezes pode criar stubs de sub-rotina vazios quando uma sub-rotina não foi encontrada no
pacote. Esses casos impediram que pesquisas de método posteriores progredissem para os pacotes básicos.
Isso foi corrigido.

Taint falhas para "-VOCÊ"
Ao executar no modo inseguro, as violações de contaminação às vezes podem causar falhas silenciosas. Isto
foi corrigido.

END blocos e da "-c" interruptor
Versões anteriores usadas para executar BEGIN e END bloqueia quando Perl foi executado no modo somente de compilação.
Uma vez que este não é o comportamento esperado, os blocos END não são mais executados
quando a opção "-c" é usada ou se a compilação falhar.

Consulte "Suporte para blocos CHECK" para saber como executar as coisas quando a fase de compilação terminar.

Potencial para vazar DADOS manipuladores de arquivo
Usar o token "__DATA__" cria um manipulador de arquivos implícito para o arquivo que contém o
símbolo. É responsabilidade do programa fechá-lo quando terminar de ler.

Esta advertência agora é melhor explicada na documentação. Veja perldata.

Novo or Alterado Diagnóstico

A variável "% s"% s mascara a declaração anterior no mesmo% s
(W misc) Uma variável "meu" ou "nosso" foi redeclarada no escopo atual ou
declaração, efetivamente eliminando todo o acesso à instância anterior. Isto é
quase sempre um erro tipográfico. Observe que a variável anterior ainda existirá
até o final do escopo ou até que todos os referentes de fechamento a ele sejam destruídos.

"meu sub" ainda não implementado
(F) As sub-rotinas com escopo léxico ainda não foram implementadas. Não tente isso ainda.

"nossa" variável% s redeclarada
(W misc) Você parece já ter declarado o mesmo global uma vez antes no atual
escopo léxico.

'!' permitido apenas após os tipos% s
(F) O '!' é permitido em pacote() e desempacotar () somente após certos tipos. Veja "pack" em
perlfunc.

Não consigo fazer uma contagem
(F) Você tinha um modelo de descompactação indicando uma string de comprimento contado, mas também
especificou um tamanho explícito para a string. Veja "pack" em perlfunc.

/ deve ser seguido por a, A ou Z
(F) Você tinha um modelo de descompactação indicando uma string de comprimento contado, que deve ser
seguido por uma das letras a, A ou Z para indicar que tipo de string deve ser
descompactado. Veja "pack" em perlfunc.

/ deve ser seguido por *, A * ou Z *
(F) Você tinha um modelo de pacote indicando uma sequência de comprimento contado, atualmente o único
coisas que podem ter seu comprimento contado são a *, A * ou Z *. Veja "pack" em perlfunc.

/ deve seguir um tipo numérico
(F) Você tinha um modelo de descompactação que continha um '#', mas isso não seguia alguns
especificação numérica de descompactação. Veja "pack" em perlfunc.

/% s /: escape não reconhecido \\% c passado
(W regexp) Você usou uma combinação de barra invertida que não é reconhecida pelo Perl.
Esta combinação aparece em uma variável interpolada ou um regular "'" -delimitado
expressão. O personagem foi entendido literalmente.

/% s /: escape não reconhecido \\% c na classe de caractere passada
(W regexp) Você usou uma combinação de barra invertida que não é reconhecida pelo Perl
dentro das classes de personagens. O personagem foi entendido literalmente.

/% s / provavelmente deve ser escrito como "% s"
(Sintaxe W) Você usou um padrão onde Perl esperava encontrar uma string, como no
primeiro argumento para "juntar". Perl tratará o resultado verdadeiro ou falso de combinar o
padrão contra $ _ como string, o que provavelmente não é o que você tinha em mente.

% s () chamou muito cedo para verificar o protótipo
(Protótipo W) Você chamou uma função que tem um protótipo antes de o analisador ver um
definição ou declaração para ele, e Perl não poderia verificar se a chamada está em conformidade com
o protótipo. Você precisa adicionar uma declaração de protótipo inicial para o
sub-rotina em questão, ou mova a definição da sub-rotina antes da chamada para obter
verificação adequada do protótipo. Alternativamente, se você tiver certeza de que está ligando para o
funcionar corretamente, você pode colocar um "e" comercial antes do nome para evitar o aviso.
Veja perlsub.

O argumento% s não é um elemento HASH ou ARRAY
(F) O argumento para existe() deve ser um hash ou elemento de matriz, como:

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

O argumento% s não é um elemento HASH ou ARRAY ou fatia
(F) O argumento para deletar () deve ser um elemento hash ou array, como:

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

ou um hash ou fatia de array, como:

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

O argumento% s não é um nome de sub-rotina
(F) O argumento para existe() para "existe & sub" deve ser um nome de sub-rotina, e não um
chamada de subrotina. "existe & sub ()" gerará este erro.

O atributo do pacote% s pode entrar em conflito com a palavra futura reservada:% s
(W reservado) Foi usado um nome de atributo em minúsculas que tinha um manipulador específico do pacote.
Esse nome pode ter um significado para o próprio Perl algum dia, embora ainda não tenha.
Talvez você deva usar um nome de atributo de maiúsculas e minúsculas, em vez disso. Veja os atributos.

(em limpeza)% s
(W misc) Este prefixo geralmente indica que um DESTRUIR() método levantou o indicado
exceção. Uma vez que os destruidores são geralmente chamados pelo sistema em pontos arbitrários
durante a execução, e muitas vezes um grande número de vezes, o aviso é emitido apenas uma vez
para qualquer número de falhas que, de outra forma, resultariam na mesma mensagem sendo
repetido.

A falha dos retornos de chamada do usuário despachados usando o sinalizador "G_KEEPERR" também pode resultar em
este aviso. Veja "G_KEEPERR" em perlcall.

<> devem ser citações
(F) Você escreveu "requerer "quando você deveria ter escrito" require 'file' ".

Tentar unir-se a si mesmo
(F) Você tentou juntar um fio de dentro dele mesmo, o que é uma tarefa impossível. Você
pode estar entrando no tópico errado, ou você pode precisar mover o Junte-se() para algum outro
fio.

Padrão de substituição mal avaliado
(F) Você usou a opção / e para avaliar a substituição por uma substituição, mas perl
encontrou um erro de sintaxe no código para avaliar, provavelmente uma chave direita inesperada
'}'.

Piscina realloc () ignoradas
(S) Uma rotina interna chamada realloc () em algo que nunca foi malloc ()ed
em primeiro lugar. Obrigatório, mas pode ser desativado definindo a variável de ambiente
"PERL_BADFREE" a 1.

Bareword encontrada em condicional
(W bareword) O compilador encontrou uma bareword onde esperava uma condicional, que
frequentemente indica que um || ou && foi analisado como parte do último argumento do
construção anterior, por exemplo:

abrir FOO || morrer;

Também pode indicar uma constante com erro ortográfico que foi interpretada como uma palavra de barra:

use TYPO constante => 1;
if (TYOP) {imprimir "foo"}

O pragma "estrito" é útil para evitar esses erros.

Número binário> 0b11111111111111111111111111111111 não portátil
(W portátil) O número binário especificado é maior que 2 ** 32-1 (4294967295) e
portanto, não portátil entre sistemas. Veja perlport para mais informações sobre portabilidade
preocupações.

Tamanho do vetor de bits> 32 não portátil
(W portátil) O uso de tamanhos de vetor de bits maiores que 32 não é portátil.

Estouro de buffer em prime_env_iter:% s
(W interno) Um aviso peculiar ao VMS. Enquanto o Perl se preparava para iterar
% ENV, encontrou um nome lógico ou definição de símbolo que era muito longo, por isso foi
truncado para a string mostrada.

Não é possível verificar o sistema de arquivos do script "% s"
(P) Por algum motivo, você não pode verificar o sistema de arquivos do script para nosuid.

Não é possível declarar a classe para% s não escalar em "% s"
(S) Atualmente, apenas variáveis ​​escalares podem ser declaradas com um qualificador de classe específico em um
declaração "minha" ou "nossa". A semântica pode ser estendida para outros tipos de variáveis
no futuro.

Não é possível declarar% s em "% s"
(F) Apenas variáveis ​​escalares, array e hash podem ser declaradas como variáveis ​​"my" ou "our".
Eles devem ter identificadores comuns como nomes.

Não é possível ignorar o sinal CHLD, forçando para o padrão
(Sinal W) Perl detectou que está sendo executado com o sinal SIGCHLD (às vezes
conhecido como SIGCLD) desativado. Uma vez que desabilitar este sinal irá interferir com
determinação do status de saída de processos filho, Perl redefiniu o sinal para seu
valor padrão. Esta situação normalmente indica que o programa pai sob o qual
Perl pode estar rodando (por exemplo, cron) está sendo muito descuidado.

Não é possível modificar chamada de sub-rotina não-lvalue
(F) As sub-rotinas destinadas a serem usadas no contexto de lvalue devem ser declaradas como tal, consulte
"Sub-rotinas Lvalue" em perlsub.

Não é possível ler ambiente CRTL
(S) Um aviso peculiar ao VMS. Perl tentou ler um elemento de% ENV dos CRTLs
matriz de ambiente interno e descobriu que a matriz estava faltando. Você precisa descobrir
onde seu CRTL perdeu seu ambiente ou definir PERL_ENV_TABLES (veja perlvms) então
esse ambiente não é pesquisado.

Não é possível remover% s:% s, pulando arquivo
(S) Você solicitou uma edição local sem criar um arquivo de backup. Perl foi incapaz de
remova o arquivo original para substituí-lo pelo arquivo modificado. O arquivo foi deixado
não modificado.

Não é possível retornar% s da sub-rotina lvalue
(F) Perl detectou uma tentativa de retornar valores ilegais (como temporário ou somente leitura
valores) de uma sub-rotina usada como um lvalue. Isso não é permitido.

Não pode enfraquecer uma não referência
(F) Você tentou enfraquecer algo que não era uma referência. Apenas referências podem
ser enfraquecido.

Classe de personagem [:% s:] desconhecida
(F) A classe na sintaxe da classe de caracteres [::] é desconhecida. Veja perlre.

A sintaxe da classe de caracteres [% s] pertence às classes de caracteres
(W inseguro) As construções da classe de caracteres [::], [= =] e [. .] vai dentro personagem
classes, os [] são parte da construção, por exemplo: / [012 [: alpha:] 345]/. Observação
que [= =] e [. .] não estão implementados atualmente; eles são simplesmente marcadores de posição para
extensões futuras.

Constante não é referência% s
(F) Um valor constante (talvez declarado usando o pragma "usar constante") está sendo
não referenciado, mas equivale ao tipo errado de referência. A mensagem indica
o tipo de referência que era esperado. Isso geralmente indica um erro de sintaxe em
desreferenciando o valor constante. Consulte "Funções constantes" em perlsub e constante.

constante (% s):% s
(F) O analisador encontrou inconsistências ao tentar definir um
constante, ou ao tentar encontrar o nome do caractere especificado no escape "\ N {...}".
Talvez você tenha esquecido de carregar o pragma "sobrecarga" ou "charnames" correspondente? Ver
charnames e sobrecarga.

CORE ::% s não é uma palavra-chave
(F) O namespace CORE :: é reservado para palavras-chave Perl.

definido (@array) está obsoleto
(D) definiram() geralmente não é útil em matrizes porque verifica se há um
escalar valor. Se você quiser ver se o array está vazio, use "if (@array) {# not
vazio} "por exemplo.

definido (% hash) está obsoleto
(D) definiram() geralmente não é útil em hashes porque verifica se há um
escalar valor. Se você quiser ver se o hash está vazio, use "if (% hash) {# not
vazio} "por exemplo.

Não produziu um cabeçalho válido
Consulte o erro do servidor.

(Você quis dizer "local" em vez de "nosso"?)
(W misc) Lembre-se de que "nosso" não localiza a variável global declarada. Você tem
declarou-o novamente no mesmo âmbito lexical, o que parece supérfluo.

O documento não contém dados
Consulte o erro do servidor.

entrada efetiva% s falhou
(F) Enquanto sob o pragma "use filetest", trocar os uids reais e efetivos ou
gids falhou.

false [] intervalo "% s" em regexp
(W regexp) Um intervalo de classe de caractere deve começar e terminar em um caractere literal, não
outra classe de caractere como "\ d" ou "[: alpha:]". O "-" no seu intervalo falso é
interpretado como um literal "-". Considere citar "-", "\ -". Veja perlre.

Filehandle% s aberto apenas para saída
(W io) Você tentou ler de um filehandle aberto apenas para gravação. Se você pretendia
para ser um manipulador de arquivos de leitura / gravação, você precisava abri-lo com "+ <" ou "+>" ou "+ >>"
em vez de com "<" ou nada. Se você pretendia apenas ler o arquivo, use "<".
Veja "abrir" em perlfunc.

rebanho() no manipulador de arquivos fechado% s
(W fechado) O identificador de arquivo que você está tentando rebanho() fechou-se algum tempo
até agora. Verifique seu fluxo lógico. rebanho() opera em filehandles. Você está
tentando ligar rebanho() em um dirhandle com o mesmo nome?

O símbolo global "% s" requer um nome de pacote explícito
(F) Você disse "use strict vars", o que indica que todas as variáveis ​​devem ser
com escopo léxico (usando "meu"), declarado de antemão usando "nosso", ou explicitamente
qualificado para dizer em qual pacote a variável global está (usando "::").

Número hexadecimal> 0xffffffff não portátil
(W portátil) O número hexadecimal que você especificou é maior que 2 ** 32-1 (4294967295)
e, portanto, não portátil entre sistemas. Veja perlport para mais informações sobre portabilidade
preocupações.

Valor de ambiente CRTL mal formado "% s"
(W interno) Um aviso peculiar ao VMS. Perl tentou ler o CRTL interno
array de environment e encontrou um elemento sem o delimitador "=" usado para separar
chaves de valores. O elemento é ignorado.

Mensagem mal formada em prime_env_iter: |% s |
(W interno) Um aviso peculiar ao VMS. Perl tentou ler um nome lógico ou CLI
definição de símbolo ao se preparar para iterar sobre% ENV, e não vi o esperado
delimitador entre chave e valor, então a linha foi ignorada.

Dígito binário ilegal% s
(F) Você usou um dígito diferente de 0 ou 1 em um número binário.

Dígito binário ilegal% s ignorado
(Dígito W) Você pode ter tentado usar um dígito diferente de 0 ou 1 em um número binário.
A interpretação do número binário parou antes do dígito incorreto.

Número ilegal de bits em vec
(F) O número de bits em vec () (o terceiro argumento) deve ser uma potência de dois de 1 a
32 (ou 64, se sua plataforma suportar).

Estouro de número inteiro no número% s
(Estouro de W) O número hexadecimal, octal ou binário que você especificou como um
literal ou como um argumento para hex () or out () é muito grande para sua arquitetura e tem
foi convertido em um número de ponto flutuante. Em uma arquitetura de 32 bits, o maior
o número hexadecimal, octal ou binário representável sem estouro é 0xFFFFFFFF,
037777777777 ou 0b11111111111111111111111111111111 respectivamente. Observe que Perl
promove de forma transparente todos os números a uma representação de ponto flutuante
internamente - sujeito a erros de perda de precisão nas operações subsequentes.

Atributo% s inválido:% s
O atributo indicado para uma sub-rotina ou variável não foi reconhecido por Perl ou por
um manipulador fornecido pelo usuário. Veja os atributos.

Atributos de% s inválidos:% s
Os atributos indicados para uma sub-rotina ou variável não foram reconhecidos pelo Perl ou
por um manipulador fornecido pelo usuário. Veja os atributos.

inválido [] intervalo "% s" em regexp
A faixa ofensiva agora é exibida explicitamente.

Caractere separador inválido% s na lista de atributos
(F) Algo diferente de dois pontos ou espaço em branco foi visto entre os elementos de um
lista de atributos. Se o atributo anterior tivesse uma lista de parâmetros entre parênteses, talvez
essa lista foi encerrada muito cedo. Veja os atributos.

Caractere separador inválido% s na lista de atributos de sub-rotina
(F) Algo diferente de dois pontos ou espaço em branco foi visto entre os elementos de um
lista de atributos de sub-rotina. Se o atributo anterior tinha um parâmetro entre parênteses
lista, talvez essa lista tenha sido encerrada muito cedo.

deixando% s efetivo falhou
(F) Enquanto sob o pragma "use filetest", trocar os uids reais e efetivos ou
gids falhou.

Lvalue subs retornando% s ainda não implementado
(F) Devido às limitações na implementação atual, os valores de array e hash não podem ser
retornado em sub-rotinas usadas no contexto lvalue. Veja "Sub-rotinas Lvalue" em perlsub.

Método% s não permitido
Consulte o erro do servidor.

Faltando% sbrace% s em \ N {}
(F) Sintaxe errada do nome do caractere literal "\ N {charname}" entre aspas duplas
contexto.

Comando em falta em piped open
(Tubo W) Você usou a construção "abrir (FH," | comando ")" ou "abrir (FH," comando | ")",
mas o comando estava faltando ou em branco.

Falta o nome em "meu sub"
(F) A sintaxe reservada para sub-rotinas com escopo léxico requer que eles tenham um
nome com o qual eles podem ser encontrados.

Nenhum% s especificado para -% c
(F) A opção de linha de comando indicada precisa de um argumento obrigatório, mas você não
especificado um.

Nenhum nome de pacote permitido para a variável% s em "nosso"
(F) Nomes de variáveis ​​totalmente qualificados não são permitidos em "nossas" declarações, porque
não faz muito sentido sob a semântica existente. Essa sintaxe é reservada para o futuro
extensões.

Nenhum espaço permitido após -% c
(F) O argumento para a opção de linha de comando indicada deve seguir imediatamente após
o switch, sem espaços intermediários.

nenhuma informação de deslocamento UTC; assumindo que a hora local é UTC
(S) Um aviso peculiar ao VMS. Perl não conseguiu encontrar a diferença de fuso horário local, então
está assumindo que a hora do sistema local é equivalente ao UTC. Se não for, defina o
nome lógico SYS $ TIMEZONE_DIFFERENTIAL para traduzir para o número de segundos que
precisa ser adicionado ao UTC para obter a hora local.

Número octal> 037777777777 não portátil
(W portátil) O número octal que você especificou é maior que 2 ** 32-1 (4294967295) e
portanto, não portátil entre sistemas. Veja perlport para mais informações sobre portabilidade
preocupações.

Veja também perlport para escrever código portátil.

pânico: del_backref
(P) Falha em uma verificação de consistência interna ao tentar redefinir uma referência fraca.

pânico: kid popen errno read
(F) criança bifurcada retornou uma mensagem incompreensível sobre seu erro.

pânico: magic_killbackrefs
(P) Falha em uma verificação de consistência interna ao tentar redefinir todas as referências fracas para
um objeto.

Faltam parênteses na lista "% s"
(W parênteses) Você disse algo como

meu $ foo, $ bar = @_;

quando você quis dizer

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

Lembre-se de que "meu", "nosso" e "local" são mais vinculados do que a vírgula.

Possível interpolação não intencional de% s na string
(W ambíguo) Costumava ser que o Perl tentava adivinhar se você queria um array
interpolado ou um literal @. Não faz mais isso; arrays são agora sempre
interpolado em strings. Isso significa que se você tentar algo como:

imprimir "[email protected]";

e o array @example não existe, Perl irá imprimir "fred.com", que é
provavelmente não é o que você queria. Para obter um sinal "@" literal em uma string, coloque uma barra invertida
antes dele, da mesma forma que você faria para obter um sinal literal de "$".

Possível bug do ano 2:% s
(W y2k) Você está concatenando o número 19 com outro número, que pode ser um
problema potencial do ano 2000.

pragma "attrs" está obsoleto, use "sub NAME: ATTRS" em seu lugar
(W obsoleto) Você escreveu algo assim:

sub-doit
{
usar attrs qw (bloqueado);
}

Você deve usar a nova sintaxe de declaração.

sub doit: bloqueado
{
...

O pragma "use attrs" agora é obsoleto e só é fornecido para versões anteriores
compatibilidade. Veja "Atributos de subrotina" em perlsub.

Inicio prematuro dos cabeçalhos de script
Consulte o erro do servidor.

Repita a contagem em estouros de pacotes
(F) Você não pode especificar uma contagem de repetição tão grande que ultrapasse seus inteiros assinados.
Veja "pack" em perlfunc.

Repita a contagem em estouros de descompactação
(F) Você não pode especificar uma contagem de repetição tão grande que ultrapasse seus inteiros assinados.
Veja "desempacotar" em perlfunc.

realloc () de memória liberada ignorada
(S) Uma rotina interna chamada realloc () em algo que já havia sido libertado.

Referência já é fraca
(W misc) Você tentou enfraquecer uma referência que já era fraca. Fazer isso tem
nenhum efeito.

setpgrp não aceita argumentos
(F) Seu sistema tem o setpgrp () do BSD 4.2, que não aceita argumentos, ao contrário do POSIX
setpgid (), que leva um ID de processo e um ID de grupo de processo.

Estranho * +? {} Na expressão de comprimento zero
(W regexp) Você aplicou um quantificador de expressão regular em um lugar onde não há
sentido, como em uma afirmação de largura zero. Tente colocar o quantificador dentro do
afirmação em vez disso. Por exemplo, a forma de corresponder "abc" desde que seja seguido
por três repetições de "xyz" é "/ abc (? = (?: xyz) {3}) /", não "/ abc (? = xyz) {3} /".

a mudança efetiva% s não foi implementada
(F) Enquanto sob o pragma "use filetest", não podemos mudar o real e o eficaz
uids ou gids.

Este Perl não pode redefinir os elementos de ambiente CRTL (% s)
Este Perl não pode definir elementos de ambiente CRTL (% s =% s)
(W interno) Avisos peculiares ao VMS. Você tentou alterar ou excluir um elemento de
a matriz de ambiente interno do CRTL, mas sua cópia do Perl não foi construída com um CRTL que
continha o setenv () função. Você precisará reconstruir o Perl com um CRTL que faça,
ou redefinir PERL_ENV_TABLES (ver perlvms) para que a matriz de ambiente não seja o alvo
da mudança para% ENV que produziu o aviso.

Tarde demais para executar o bloco% s
(W void) Um bloco CHECK ou INIT está sendo definido durante o tempo de execução adequado, quando o
oportunidade de executá-los já passou. Talvez você esteja carregando um arquivo com
"require" ou "do" quando você deveria usar "use". Ou talvez você deva colocar
o "requer" ou "do" dentro de um bloco BEGIN.

Desconhecido abrir() modo '% s'
(F) O segundo argumento de 3 argumentos abrir() não está entre a lista de modos válidos:
"<", ">", ">>", "+ <", "+>", "+ >>", "- |", "| -".

Processo desconhecido% x enviou mensagem para prime_env_iter:% s
(P) Um erro peculiar ao VMS. Perl estava lendo valores para% ENV antes de iterar
e outra pessoa colou uma mensagem no fluxo de dados que Perl esperava. De alguém
muito confuso, ou talvez tentando subverter a população de Perl de% ENV por nefasto
finalidades.

Escape não reconhecido \\% c passado
(W misc) Você usou uma combinação de barra invertida que não é reconhecida pelo Perl.
O personagem foi entendido literalmente.

Parâmetro de atributo não terminado na lista de atributos
(F) O lexer viu um caractere de parêntese de abertura (à esquerda) ao analisar um atributo
lista, mas o caractere de parêntese de fechamento (direito) correspondente não foi encontrado. Você pode
precisa adicionar (ou remover) um caractere de barra invertida para equilibrar os parênteses. Ver
atributos.

Lista de atributos não terminada
(F) O lexer encontrou algo diferente de um identificador simples no início de um
atributo, e não era um ponto e vírgula ou o início de um bloco. Talvez você tenha terminado
a lista de parâmetros do atributo anterior muito cedo. Veja os atributos.

Parâmetro de atributo não terminado na lista de atributos de sub-rotina
(F) O lexer viu um caractere de parêntese de abertura (à esquerda) ao analisar uma sub-rotina
lista de atributos, mas o caractere de parêntese de fechamento (direito) correspondente não foi encontrado.
Você pode precisar adicionar (ou remover) um caractere de barra invertida para colocar seus parênteses
equilibrar.

Lista de atributos de sub-rotina não terminada
(F) O lexer encontrou algo diferente de um identificador simples no início de um
atributo de sub-rotina, e não era um ponto-e-vírgula ou o início de um bloco. Talvez você
encerrou a lista de parâmetros do atributo anterior muito cedo.

Valor do símbolo CLI "% s" muito longo
(W misc) Um aviso peculiar ao VMS. Perl tentou ler o valor de um elemento% ENV
de uma tabela de símbolos CLI e encontrou uma sequência resultante com mais de 1024 caracteres.
O valor de retorno foi truncado para 1024 caracteres.

O número da versão deve ser um número constante
(P) A tentativa de traduzir uma instrução "use Module nn LIST" em seu equivalente
O bloco "BEGIN" encontrou uma inconsistência interna com o número da versão.

Novo testes

lib / attrs
Testes de compatibilidade para "sub: attrs" versus o antigo "use attrs".

lib / env
Testa a capacidade escalar do novo ambiente (por exemplo, "use Env qw ($ BAR);").

lib / env-array
Testa a capacidade da nova matriz de ambiente (por exemplo, "use Env qw (@PATH);").

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

lib / io_dir
Métodos de E / S relacionados ao diretório (novo, ler, fechar, retroceder, excluir vinculado).

lib / io_multihomed
Soquetes INET com hosts multihomed.

lib / io_poll
IO votação().

lib / io_unix
Soquetes UNIX.

op / attrs
Testes de regressão para "my ($ x, @ y,% z): attrs" e .

op / filetest
Operadores de teste de arquivo.

op / lex_assign
Verifique as operações que acessam os objetos do teclado (lexicais e temporários).

op / existe_sub
Verifique as operações "existe e sub".

Incompatível Alterações

Perl fonte Incompatibilidades
Esteja ciente de que quaisquer novos avisos que foram adicionados ou antigos que foram aprimorados são
não consideradas alterações incompatíveis.

Uma vez que todos os novos avisos devem ser solicitados explicitamente por meio da opção "-w" ou dos "avisos"
pragma, em última análise, é responsabilidade do programador garantir que os avisos sejam
habilitado judiciosamente.

CHECK é uma nova palavra-chave
Todas as definições de sub-rotina denominadas CHECK agora são especiais. Ver "/" Suporte para CHECK
bloqueia "" para obter mais informações.

O tratamento das fatias da lista de undef foi alterado
Existe uma incompatibilidade potencial no comportamento das fatias da lista que são compreendidas
inteiramente de valores indefinidos. Consulte "O comportamento das fatias da lista é mais consistente".

O formato de $ English :: PERL_VERSION é diferente
O módulo em inglês agora define $ PERL_VERSION para $ ^ V (um valor de string) em vez de $] (um
valor numérico). Esta é uma incompatibilidade potencial. Envie-nos um relatório via perlbug se
você é afetado por isso.

Veja "Sistema de numeração de versão Perl aprimorado" para as razões desta mudança.

Literais da forma 1.2.3 analisam de forma diferente
Anteriormente, literais numéricos com mais de um ponto eram interpretados como um
número de ponto flutuante concatenado com um ou mais números. Esses "números" são agora
analisados ​​como strings compostas dos ordinais especificados.

Por exemplo, "print 97.98.99" costumava produzir 97.9899 em versões anteriores, mas agora
imprime "abc".

Consulte "Suporte para strings representadas como um vetor de ordinais".

Gerador de números pseudo-aleatórios possivelmente alterado
Programas Perl que dependem da reprodução de um conjunto específico de números pseudo-aleatórios podem
agora produzem resultados diferentes devido às melhorias feitas no rand () construídas em. Você pode
use "sh Configure -Drandfunc = rand" para obter o comportamento antigo.

Consulte "Melhor gerador de números pseudo-aleatórios".

A função de hash para chaves hash mudou
Mesmo que os hashes Perl não preservem a ordem, a ordem aparentemente aleatória
encontrados ao iterar no conteúdo de um hash é, na verdade, determinado pelo
algoritmo de hash usado. Melhorias no algoritmo podem produzir uma ordem aleatória que
is diferente das versões anteriores, especialmente ao iterar em hashes.

Consulte "Melhor comportamento de pior caso de hashes" para obter informações adicionais.

"undef" falha em valores somente leitura
Usar o operador "undef" em um valor somente leitura (como $ 1) tem o mesmo efeito que
atribuir "undef" ao valor somente leitura - lança uma exceção.

O bit close-on-exec pode ser definido nas alças de tubo e soquete
Pipe e alças de soquete agora também estão sujeitos ao comportamento de close-on-exec determinado
pela variável especial $ ^ F.

Consulte "Comportamento de close-on-exec mais consistente".

Escrever "$$ 1" para significar "$ {$} 1" não é compatível
Perl 5.004 descontinuou a interpretação de $$ 1 e similar em interpolado
strings para significar "$$." 1 "", mas ainda assim é permitido.

No Perl 5.6.0 e posterior, "$$ 1" sempre significa "$ {$ 1}".

deletar (), cada(), valores () e "\ (% h)"
operar em aliases para valores, não em cópias

deletar (), cada(), valores () e hashes (por exemplo, "\ (% h)") em um contexto de lista retornam o
valores reais no hash, em vez de cópias (como costumavam acontecer nas versões anteriores).
Expressões idiomáticas típicas para usar essas construções copiam os valores retornados, mas isso pode tornar
uma diferença significativa ao criar referências aos valores retornados. Chaves no
hash ainda são retornados como cópias ao iterar em um hash.

Veja também "deletar (), cada(), valores () e a iteração hash é mais rápida ".

vec (EXPR, OFFSET, BITS) impõe poderes de dois BITS
vec () gera um erro em tempo de execução se o argumento BITS não for uma potência de dois válida
inteiro.

O texto de alguma saída de diagnóstico foi alterado
A maioria das referências a operações Perl internas em diagnósticos foram alteradas para serem
mais descritivo. Isso pode ser um problema para programas que podem depender incorretamente do
texto exato de diagnóstico para o funcionamento adequado.

"%@" foi removido
A variável especial não documentada "% @" que costumava acumular erros de "segundo plano"
(como aqueles que acontecem em DESTRUIR()) foi removido, porque poderia
potencialmente resultar em vazamentos de memória.

Entre parênteses não() se comporta como um operador de lista
O operador "não" agora se enquadra na categoria "se parece uma função, ele se comporta como um
função "regra.

Como resultado, a forma entre parênteses pode ser usada com "grep" e "map". A seguir
construção costumava ser um erro de sintaxe antes, mas agora funciona como esperado:

grep not ($ _), @things;

Por outro lado, usar "não" com uma fatia de lista literal pode não funcionar. A seguir
construção permitida anteriormente:

imprimir não (1,2,3) [0];

precisa ser escrito com parênteses adicionais agora:

imprimir não ((1,2,3) [0]);

O comportamento permanece inalterado quando "not" não é seguido por parênteses.

A semântica do protótipo de bareword "(*)" mudou
A semântica do protótipo de bareword "*" mudou. Perl 5.005 sempre forçado
argumentos escalares simples para um typeglob, que não era útil em situações onde o
a sub-rotina deve distinguir entre um escalar simples e um typeglob. O novo comportamento
é não coagir argumentos de palavras de barra a um tipo de vinho. O valor estará sempre visível
como um escalar simples ou como uma referência a um typeglob.

Consulte "Protótipo de palavras de barra mais funcional (*)".

A semântica dos operadores de bits pode ter mudado nas plataformas de 64 bits
Se a sua plataforma for nativamente de 64 bits ou se o Perl tiver sido configurado para ser usado
Inteiros de 64 bits, ou seja, $ Config {ivsize} é 8, pode haver uma incompatibilidade potencial
no comportamento de operadores numéricos bit a bit (& | ^ ~ << >>). Esses operadores costumavam
operar estritamente nos 32 bits inferiores de inteiros nas versões anteriores, mas agora
operar em toda a largura integral nativa. Em particular, observe que "~" unário
produzirá resultados diferentes em plataformas com $ Config {ivsize} diferente. Por
portabilidade, certifique-se de mascarar os bits em excesso no resultado de "~" unário, por exemplo,
"~ $ x & 0xffffffff".

Consulte "Operadores de bit suportam largura inteira nativa inteira".

Mais builtins contaminam seus resultados
Conforme descrito em "Recursos de segurança aprimorados", pode haver mais fontes de contaminação em um
Programa Perl.

Para evitar esses novos comportamentos de contaminação, você pode construir Perl com a opção Configurar
"-Accflags = -DINCOMPLETE_TAINTS". Esteja ciente de que o binário perl resultante pode ser inseguro.

C fonte Incompatibilidades
"PERL_POLLUTE"
A versão 5.005 adquiriu nomes de símbolos globais antigos, fornecendo macros de pré-processador
para compatibilidade de fonte de extensão. A partir da versão 5.6.0, esses pré-processadores
as definições não estão disponíveis por padrão. Você precisa compilar explicitamente o perl com
"-DPERL_POLLUTE" para obter essas definições. Para extensões que ainda usam o antigo
símbolos, esta opção pode ser especificada através do MakeMaker:

perl Makefile.PL POLLUTE = 1

"PERL_IMPLICIT_CONTEXT"
Esta nova opção de construção fornece um conjunto de macros para todas as funções da API, de forma que um
O argumento implícito do interpretador / contexto do thread é passado para todas as funções da API. Como um
resultado disso, algo como "sv_setsv (foo, bar)" equivale a uma invocação de macro que
na verdade se traduz em algo como "Perl_sv_setsv (my_perl, foo, bar)". Enquanto isso é
geralmente esperado que não tenha nenhum problema significativo de compatibilidade de fonte, o
diferença entre uma macro e uma chamada de função real precisará ser considerada.

Isso significa que há is um problema de compatibilidade de origem como resultado disso, se o seu
extensões tentam usar ponteiros para qualquer uma das funções da API Perl.

Observe que o problema acima não é relevante para a compilação padrão do Perl, cujo
interfaces continuam a corresponder às das versões anteriores (mas sujeito a outras opções
descrito aqui).

Veja "Histórico e PERL_IMPLICIT_CONTEXT" em perlguts para informações detalhadas sobre o
ramificações de construir Perl com esta opção.

NOTA: PERL_IMPLICIT_CONTEXT é habilitado automaticamente sempre que Perl é construído
com um de -Dusethreads, -Dusemultiplicity ou ambos. Não é
pretende ser habilitado pelos usuários neste momento.

"PERL_POLLUTE_MALLOC"
Habilitar o malloc do Perl na versão 5.005 e anteriores causou o namespace do
família malloc de funções do sistema a ser usurpada pelas versões Perl, uma vez que por
padrão eles usaram os mesmos nomes. Além de causar problemas em plataformas que não
permitir que essas funções sejam substituídas de forma limpa, isso também significa que as versões do sistema
não podia ser chamado em programas que usavam o malloc do Perl. Versões anteriores de Perl
permitiram que este comportamento fosse suprimido com HIDEMYMALLOC e EMBEDMYMALLOC
definições de pré-processador.

A partir da versão 5.6.0, a família de funções malloc do Perl tem nomes padrão distintos
das versões do sistema. Você precisa compilar explicitamente o perl com
"-DPERL_POLLUTE_MALLOC" para obter o comportamento mais antigo. HIDEMYMALLOC e EMBEDMYMALLOC
não têm efeito, pois o comportamento que eles habilitaram agora é o padrão.

Observe que essas funções não constituem a API de alocação de memória do Perl. Veja "Memória
Allocation "em perlguts para mais informações sobre isso.

Compatível C fonte API Alterações
"PATCHLEVEL" agora é "PERL_VERSION"
As macros cpp "PERL_REVISION", "PERL_VERSION" e "PERL_SUBVERSION" agora são
disponível por padrão em perl.h, e reflete a revisão base, patchlevel e
subversão respectivamente. "PERL_REVISION" não tinha equivalente anterior, enquanto
"PERL_VERSION" e "PERL_SUBVERSION" estavam disponíveis anteriormente como "PATCHLEVEL" e
"SUBVERSÃO".

Os novos nomes causam menos poluição do cpp namespace e refletem quais são os números
passaram a representar na prática comum. Para compatibilidade, os nomes antigos ainda são
apoiado quando patchlevel.h está explicitamente incluído (como exigido antes), então há
nenhuma incompatibilidade de fonte da mudança.

Binário Incompatibilidades
Em geral, espera-se que a compilação padrão desta versão seja compatível com o binário para
extensões construídas com a versão 5.005 ou suas versões de manutenção. No entanto, específico
plataformas podem ter quebrado compatibilidade binária devido a mudanças nos padrões usados ​​em
arquivos de dicas. Portanto, certifique-se de sempre verificar os arquivos README específicos da plataforma
para quaisquer notas em contrário.

Os usethreads ou usemultiplicity builds são não binário compatível com o correspondente
constrói em 5.005.

Em plataformas que requerem uma lista explícita de exportações (AIX, OS / 2 e Windows, entre
outros), símbolos puramente internos, como funções de analisador e os opcodes de tempo de execução não são
exportado por padrão. Perl 5.005 usado para exportar todas as funções, independentemente de elas
foram considerados parte da API pública ou não.

Para obter a lista completa de funções de API públicas, consulte perlapi.

Conhecido Problemas

Fio teste falhas
Os subtestes 19 e 20 do teste lib / thr5005.t são conhecidos por falharem devido a problemas fundamentais
na implementação de encadeamento 5.005. Estas não são falhas novas - Perl 5.005_0x tem o
mesmos bugs, mas não tinha esses testes.

EBCDIC plataformas não suportado
Em versões anteriores do Perl, ambientes EBCDIC como OS390 (também conhecido como Open Edition
MVS) e VM-ESA foram suportados. Devido às mudanças exigidas pelo suporte UTF-8 (Unicode),
as plataformas EBCDIC não são suportadas no Perl 5.6.0.

In 64-bit HP-UX da lib / io_multihomed teste pode pendurar
O teste lib / io_multihomed pode travar no HP-UX se Perl tiver sido configurado para ser de 64 bits.
Como outras plataformas de 64 bits não param neste teste, o HP-UX é suspeito. Todos os outros
os testes passam em HP-UX de 64 bits. O teste tenta criar e se conectar a "multihomed"
sockets (sockets que têm vários endereços IP).

PRÓXIMA ETAPA 3.3 POSIX teste falha
No NEXTSTEP 3.3p2, a implementação do horário de trabalho(3) nas bibliotecas do sistema operacional
é buggy: o formato% j numera os dias de um mês a partir de zero, que, embora sendo
lógico para os programadores, fará com que os subtestes 19 a 27 do teste lib / posix possam falhar.

Tru64 (Aka Digital Unix, aka Dezembro OSF / 1) lib / sdbm teste falha com gcc
Se compilado com gcc 2.95, o teste lib / sdbm irá falhar (dump core). A cura é usar o
fornecedor cc, ele vem com o sistema operacional e produz um bom código.

UNICOS / mk CC falhas durante configurar corrida
No UNICOS / mk, os seguintes erros podem aparecer durante a execução da Configuração:

Adivinhando quais símbolos seu compilador C e pré-processador definem ...
CC-20 cc: Arquivo ERROR = try.c, Line = 3
...
interruptor ruim yylook 79 interruptor ruim yylook 79 interruptor ruim yylook 79 interruptor ruim yylook 79 # ifdef A29K
...
4 erros detectados na compilação de "try.c".

O culpado é o awk quebrado do UNICOS / mk. Felizmente, o efeito é bastante moderado: Perl
em si não é adversamente afetado pelo erro, apenas o utilitário h2ph que vem com Perl, e
isso raramente é necessário hoje em dia.

seta operador e matrizes
Quando o argumento da esquerda para o operador de seta "->" é uma matriz, ou o operador "escalar"
operando em uma matriz, o resultado da operação deve ser considerado incorreto. Por
exemplo:

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

Essas expressões obterão erros de tempo de execução em alguma versão futura do Perl.

experimental características
Conforme discutido acima, muitos recursos ainda são experimentais. Interfaces e implementação
desses recursos estão sujeitos a alterações e, em casos extremos, até mesmo à remoção em
alguma versão futura do Perl. Esses recursos incluem o seguinte:

Tópicos
Unicode
Suporte de bits 64
Sub-rotinas Lvalue
Referências fracas
O tipo de dados pseudo-hash
O pacote de compiladores
Implementação interna de globbing de arquivo
O módulo DB
O código da expressão regular constrói:
"(? {código})" e "(?? {código})"

Obsoleto Diagnóstico

A sintaxe da classe de caracteres [::] é reservada para futuras extensões
(W) Dentro das classes de caracteres de expressão regular ([]), a sintaxe que começa com "[:"
e terminando com ":]" está reservado para futuras extensões. Se você precisa representar
essas sequências de caracteres dentro de uma classe de caracteres de expressão regular, basta citar o
colchetes com a barra invertida: "\ [:" e ": \]".

Nome lógico mal formado |% s | em prime_env_iter
(W) Um aviso peculiar ao VMS. Um nome lógico foi encontrado durante a preparação para
iterar sobre% ENV que viola as regras sintáticas que regem os nomes lógicos. Porque
não pode ser traduzido normalmente, é ignorado e não aparecerá em% ENV. Isto
pode ser uma ocorrência benigna, pois alguns pacotes de software podem modificar diretamente
tabelas de nomes e introduzir nomes não padronizados, ou pode indicar que um nome lógico
tabela foi corrompida.

Na string, @% s agora deve ser escrito como \ @% s
A descrição desse erro costumava dizer:

(Algum dia ele simplesmente assumirá que um @ sem barra invertida
interpola uma matriz.)

Esse dia chegou e esse erro fatal foi removido. Foi substituído por um
aviso não fatal em vez disso. Consulte "Matrizes agora sempre interpolar em aspas duplas
strings "para obter detalhes.

Provável problema de precedência em% s
(W) O compilador encontrou uma palavra de barra onde esperava uma condicional, que muitas vezes
indica que um || ou && foi analisado como parte do último argumento do anterior
construir, por exemplo:

abrir FOO || morrer;

regexp muito grande
(F) A implementação atual de expressões regulares usa shorts como deslocamentos de endereço
dentro de uma string. Infelizmente, isso significa que se a expressão regular compilar para
mais do que 32767, ele vai explodir. Normalmente, quando você quer uma expressão regular, isso
grande, há uma maneira melhor de fazer isso com várias instruções. Veja perlre.

Uso de "$$ "significa" $ {$} "está obsoleto
(D) Versões Perl anteriores a 5.004 interpretaram mal qualquer marcador de tipo seguido por "$" e um
dígito. Por exemplo, "$$ 0" foi interpretado incorretamente como "$ {$} 0" em vez de "$ {$ 0}".
Este bug é (principalmente) corrigido no Perl 5.004.

No entanto, os desenvolvedores do Perl 5.004 não conseguiram corrigir esse bug completamente, porque em
pelo menos dois módulos amplamente usados ​​dependem do antigo significado de "$$ 0" em uma string. Então Perl
5.004 ainda interpreta "$$ "da maneira antiga (quebrada) dentro das cordas; mas
gera esta mensagem como um aviso. E no Perl 5.005, este tratamento especial irá
cessar.

Relatórios Erros

Se você encontrar o que acha que é um bug, pode verificar os artigos recentemente postados no
grupo de notícias comp.lang.perl.misc. Também pode haver informações em http://www.perl.com/perl/
, a página inicial do Perl.

Se você acredita que tem um bug não relatado, execute o perlbug programa incluído com
sua liberação. Certifique-se de reduzir seu bug para um caso de teste minúsculo, mas suficiente. Seu bug
relatório, junto com a saída de "perl -V", será enviado para [email protected] ser
analisado pela equipe de portabilidade Perl.

Use perl56delta online usando serviços onworks.net