perlport - Online na Nuvem

PROGRAMA:

NOME

perlport - Escrevendo Perl portátil

DESCRIÇÃO

Perl é executado em vários sistemas operacionais. Embora a maioria deles tenha muito em comum, eles
também têm suas próprias características únicas.

Este documento destina-se a ajudá-lo a descobrir o que constitui um código Perl portátil. que
uma vez que você toma a decisão de escrever de forma portátil, você sabe onde as linhas são desenhadas e
você pode ficar dentro deles.

Há uma troca entre tirar o máximo proveito de um tipo específico de computador e
aproveitando-se de uma gama completa deles. Naturalmente, à medida que você amplia seu alcance e se torna
mais diversos, os fatores comuns caem e você fica com uma área cada vez menor
de terreno comum no qual você pode operar para realizar uma tarefa específica. Assim, quando você
começar a atacar um problema, é importante considerar em qual parte do tradeoff
curva que deseja operar. Especificamente, você deve decidir se é importante que o
tarefa que você está codificando tem toda a generalidade de ser portátil, ou apenas obter
o trabalho feito agora. Essa é a escolha mais difícil de ser feita. O resto é fácil, porque
Perl oferece muitas opções, de qualquer maneira que você queira abordar seu problema.

Olhando de outra maneira, escrever código portátil geralmente é limitar intencionalmente sua
escolhas disponíveis. Naturalmente, é preciso disciplina e sacrifício para fazer isso. O produto
de portabilidade e conveniência pode ser uma constante. Você foi avisado.

Fique atento a dois pontos importantes:

Nem todos os programas Perl precisam ser portáteis
Não há razão para você não usar Perl como uma linguagem para colar ferramentas Unix,
ou para prototipar um aplicativo Macintosh, ou para gerenciar o registro do Windows. Se isso
não faz sentido almejar a portabilidade por um motivo ou outro em um determinado programa,
então não se incomode.

Quase todo o Perl já is portátil
Não se iluda pensando que é difícil criar código Perl portátil. Não é.
Perl tenta seu melhor nível para preencher as lacunas entre o que está disponível em diferentes
plataformas, e todos os meios disponíveis para usar esses recursos. Assim, quase todo Perl
código é executado em qualquer máquina sem modificação. Mas há alguns problemas importantes
ao escrever código portátil, e este documento é inteiramente sobre essas questões.

Aqui está a regra geral: Quando você aborda uma tarefa comumente feita usando uma ampla gama de
plataformas, pense em escrever código portátil. Dessa forma, você não sacrifica muito pelo caminho
das opções de implementação das quais você pode se beneficiar e, ao mesmo tempo, pode dar
seus usuários muitas opções de plataforma. Por outro lado, quando você tem que aproveitar
de algum recurso exclusivo de uma plataforma em particular, como é frequentemente o caso de sistemas
programação (seja para Unix, Windows, VMS, etc.), considere escrever
código.

Quando o código for executado em apenas dois ou três sistemas operacionais, talvez seja necessário considerar
apenas as diferenças desses sistemas particulares. O importante é decidir onde
o código será executado e será deliberado em sua decisão.

O material abaixo está dividido em três seções principais: principais questões de portabilidade
("ISSUES"), problemas específicos da plataforma ("PLATFORMS") e funções Perl integradas que
comportam-se de forma diferente em várias portas ("IMPLEMENTAÇÕES DE FUNÇÕES").

Esta informação não deve ser considerada completa; inclui possivelmente transitório
informações sobre idiossincrasias de alguns dos portos, quase todos em estado
de evolução constante. Assim, este material deve ser considerado um trabalho perpétuo em
progresso (" ").

QUESTÕES

Novas linhas
Na maioria dos sistemas operacionais, as linhas dos arquivos são terminadas por novas linhas. Apenas o que é usado
como uma nova linha pode variar de sistema operacional para sistema operacional. O Unix tradicionalmente usa "\012", um tipo de DOSish
E/S usa "\015\012", Mac OS usa "\015" e z/OS usa "\025".

Perl usa "\n" para representar a nova linha "lógica", onde o que é lógico pode depender do
plataforma em uso. Em MacPerl, "\n" sempre significa "\015". Em plataformas EBCDIC, "\n" pode
ser "\025" ou "\045". Em perls DOSish, "\n" geralmente significa "\012", mas ao acessar um
arquivo no modo "texto", o perl usa a camada ":crlf" que o traduz para (ou de)
"\015\012", dependendo se você está lendo ou escrevendo. Unix faz a mesma coisa em
ttys no modo canônico. "\015\012" é comumente referido como CRLF.

Para cortar as novas linhas à direita das linhas de texto, use "chomp()". Com configurações padrão que
A função procura um caractere "\n" à direita e, portanto, apara de maneira portátil.

Ao lidar com arquivos binários (ou arquivos de texto no modo binário), certifique-se de definir explicitamente $/
para o valor apropriado para seu formato de arquivo antes de usar "chomp()".

Por causa da tradução do modo "texto", os perls DOSish têm limitações no uso de "seek" e
"tell" em um arquivo acessado no modo "texto". Atenha-se a "procurar" os locais de onde você tirou
"tell" (e nenhum outro), e você geralmente é livre para usar "seek" e "tell" mesmo em "texto"
modo. Usar "seek" ou "tell" ou outras operações de arquivo pode não ser portátil. Se você usar
"binmode" em um arquivo, no entanto, você geralmente pode "seek" e "tell" com valores arbitrários
com segurança.

Um equívoco comum na programação de soquete é que "\n eq \012" em todos os lugares. Ao usar
protocolos como protocolos comuns da Internet, "\012" e "\015" são chamados para
especificamente, e os valores da lógica "\n" e "\r" (retorno de carro) não são
fiável.

print SOCKET "Olá, cliente!\r\n"; # ERRADO
print SOCKET "Olá, cliente!\015\012"; # DIREITO

No entanto, usar "\015\012" (ou "\cM\cJ", ou "\x0D\x0A") pode ser tedioso e desagradável, pois
bem como confuso para aqueles que mantêm o código. Assim, o módulo "Socket" fornece
a Coisa Certa para quem a quer.

use Soquete qw(:DEFAULT :crlf);
print SOCKET "Olá, cliente!$CRLF" # DIREITA

Ao ler de um soquete, lembre-se de que o separador de registro de entrada padrão $/ é "\n",
mas o código de soquete robusto reconhecerá como "\012" ou "\015\012" como final de linha:

enquanto ( ) { # NÃO ACONSELHÁVEL!
# ...
}

Como CRLF e LF terminam em LF, o separador de registro de entrada pode ser definido como LF e qualquer CR
despojado depois. Melhor escrever:

use Soquete qw(:DEFAULT :crlf);
local($/) = LF; # não é necessário se $/ já for \012

enquanto ( ) {
s/$CR?$LF/\n/; # não tenho certeza se o soquete usa LF ou CRLF, OK
# s/\015?\012/\n/; # mesma coisa
}

Este exemplo é preferível ao anterior - mesmo para plataformas Unix - porque agora qualquer
"\015"'s ("\cM"'s) são retirados (e houve muita alegria).

Da mesma forma, funções que retornam dados de texto, como uma função que busca um arquivo web
página -- às vezes deve traduzir novas linhas antes de retornar os dados, se ainda não
foi traduzido para a representação de nova linha local. Uma única linha de código geralmente
satisfazer:

$dados =~ s/\015?\012/\n/g;
return $ data;

Alguns destes podem ser confusos. Aqui está uma referência útil para o ASCII CR e LF
personagens. Você pode imprimi-lo e colocá-lo em sua carteira.

LF eq \012 eq \x0A eq \cJ eq chr(10) eq. ASCII 10
CR eq \015 eq \x0D eq \cM eq chr(13) eq. ASCII 13

| Unix | DOS | Mac |
---------------------------
\n | BF | BF | CR |
\r | CR | CR | BF |
\n* | BF | CRLF | CR |
\r* | CR | CR | LF |
---------------------------
* modo texto STDIO

A coluna Unix assume que você não está acessando uma linha serial (como um tty) em canonical
modo. Se estiver, então CR na entrada se torna "\n" e "\n" na saída se torna CRLF.

Estas são apenas as definições mais comuns de "\n" e "\r" em Perl. Pode bem haver
outras. Por exemplo, em uma implementação EBCDIC como z/OS (OS/390) ou OS/400 (usando
o ILE, o PASE é baseado em ASCII) o material acima é semelhante ao "Unix", mas o código
os números mudam:

LF eq \025 eq \x15 eq \cU eq chr(21) eq. CP-1047 21
LF eq \045 eq \x25 eq chr(37) eq. CP-0037 37
CR eq \015 eq \x0D eq \cM eq chr(13) eq. CP-1047 13
CR eq \015 eq \x0D eq \cM eq chr(13) eq. CP-0037 13

| z/OS | OS/400 |
----------------------
\n | BF | BF |
\r | CR | CR |
\n* | BF | BF |
\r* | CR | CR |
----------------------
* modo texto STDIO

Números endianidade e Largura
Diferentes CPUs armazenam números inteiros e de ponto flutuante em ordens diferentes (chamadas
endianidade) e larguras (32 bits e 64 bits sendo os mais comuns hoje). Isso afeta sua
programas quando tentam transferir números em formato binário de uma arquitetura de CPU
para outro, geralmente "ao vivo" via conexão de rede ou armazenando os números para
armazenamento secundário, como um arquivo em disco ou fita.

Pedidos de armazenamento conflitantes fazem uma bagunça total com os números. Se um anfitrião little-endian
(Intel, VAX) armazena 0x12345678 (305419896 em decimal), um host big-endian (Motorola, Sparc,
PA) lê como 0x78563412 (2018915346 em decimal). Alfa e MIPS podem ser:
Digital/Compaq usou/usa-os no modo little-endian; SGI/Cray os usa em big-endian
modo. Para evitar este problema em conexões de rede (socket) use o "pack" e "unpack"
formatos "n" e "N", as ordens de "rede". Estes são garantidos para serem portáteis.

A partir do Perl 5.10.0, você também pode usar os modificadores ">" e "<" para forçar grandes ou pequenos
ordem de bytes endian. Isso é útil se você deseja armazenar inteiros assinados ou 64 bits
inteiros, por exemplo.

Você pode explorar o endianness de sua plataforma descompactando uma estrutura de dados compactada em
formato nativo, como:

print unpack("h*", pack("s2", 1, 2)), "\n";
# '10002000' em, por exemplo, Intel x86 ou Alpha 21064 no modo little-endian
# '00100020' em, por exemplo, Motorola 68040

Se você precisar distinguir entre arquiteturas endian, poderá usar qualquer um dos
variáveis ​​definidas assim:

$is_big_endian = unpack("h*", pack("s", 1)) =~ /01/;
$is_little_endian = unpack("h*", pack("s", 1)) =~ /^1/;

Larguras diferentes podem causar truncamento mesmo entre plataformas de igual endianness. O
plataforma de menor largura perde as partes superiores do número. Não há boa solução
para este problema, exceto para evitar transferir ou armazenar números binários brutos.

Pode-se contornar esses dois problemas de duas maneiras. Transfira e armazene números
sempre em formato de texto, em vez de binário bruto, ou então considere usar módulos como
"Data::Dumper" e "Storable" (incluídos a partir do Perl 5.8). Mantendo todos os dados como texto
simplifica significativamente as coisas.

As v-strings são portáteis apenas até v2147483647 (0x7FFF_FFFF), é até onde EBCDIC, ou
mais precisamente UTF-EBCDIC irá.

Arquivos e Sistemas de arquivos
Atualmente, a maioria das plataformas estrutura os arquivos de maneira hierárquica. Então, é razoavelmente
seguro assumir que todas as plataformas suportam a noção de um "caminho" para identificar exclusivamente um
arquivo no sistema. Como esse caminho é realmente escrito, porém, difere consideravelmente.

Embora semelhantes, as especificações de caminho de arquivo diferem entre Unix, Windows, Mac OS, OS/2,
VMS, VOS, RISC OS e provavelmente outros. O Unix, por exemplo, é um dos poucos SOs que
tem a ideia elegante de um único diretório raiz.

DOS, OS/2, VMS, VOS e Windows podem funcionar de forma semelhante ao Unix com "/" como separador de caminho ou
em suas próprias maneiras idiossincráticas (como ter vários diretórios raiz e vários
arquivos de dispositivo "unrooted" como NIL: e LPT:).

O Mac OS 9 e versões anteriores usavam ":" como separador de caminho em vez de "/".

O sistema de arquivos não pode suportar nem hard links ("link") nem links simbólicos ("symlink",
"readlink", "lstat").

O sistema de arquivos não pode suportar nem o timestamp de acesso nem o timestamp de alteração (o que significa que
sobre o único timestamp portátil é o timestamp de modificação), ou um segundo
granularidade de quaisquer marcas de tempo (por exemplo, o sistema de arquivos FAT limita a granularidade de tempo a dois
segundos).

O "timestamp de alteração do inode" (o teste de arquivo "-C") pode realmente ser o "timestamp de criação"
(que não está no Unix).

VOS perl pode emular nomes de arquivos Unix com "/" como separador de caminho. O nome do caminho nativo
caracteres maior que, menor que, sinal de número e sinal de porcentagem são sempre aceitos.

O RISC OS perl pode emular nomes de arquivos Unix com "/" como separador de caminho, ou tornar-se nativo e usar
"." para separador de caminho e ":" para sinalizar sistemas de arquivos e nomes de disco.

Não assuma a semântica de acesso ao sistema de arquivos Unix: que ler, escrever e executar são todos os
permissões existem, e mesmo que existam, que sua semântica (por exemplo, o que
"r", "w" e "x" significam em um diretório) são os Unix. Os vários Unix/POSIX
camadas de compatibilidade geralmente tentam fazer interfaces como "chmod()" funcionarem, mas às vezes
simplesmente não existe um bom mapeamento.

Se tudo isso for intimidante, não tenha (bem, talvez apenas um pouco) medo. Existem módulos
isso pode ajudar. Os módulos "File::Spec" fornecem métodos para fazer a coisa certa em qualquer
plataforma está executando o programa.

use File::Spec::Funções;
chdir(updir()); # sobe um diretório
meu $arquivo = catfile(curdir(), 'temp', 'arquivo.txt');
# em Unix e Win32, './temp/file.txt'
# no Mac OS Classic, ':temp:file.txt'
# no VMS, '[.temp]file.txt'

"File::Spec" está disponível na distribuição padrão a partir da versão 5.004_05.
"File::Spec::Functions" está apenas em "File::Spec" 0.7 e posterior, e algumas versões do Perl
vem com a versão 0.6. Se "File::Spec" não for atualizado para 0.7 ou posterior, você deve usar o
interface orientada a objetos de "File::Spec" (ou atualize "File::Spec").

Em geral, o código de produção não deve ter caminhos de arquivo codificados. Tornando-os usuários-
fornecido ou lido de um arquivo de configuração é melhor, tendo em mente que o caminho do arquivo
sintaxe varia em máquinas diferentes.

Isso é especialmente perceptível em scripts como Makefiles e suítes de teste, que geralmente
assuma "/" como separador de caminho para subdiretórios.

Também é útil "File::Basename" da distribuição padrão, que divide um nome de caminho
em pedaços (nome do arquivo base, caminho completo para o diretório e sufixo do arquivo).

Mesmo quando em uma única plataforma (se você pode chamar o Unix de uma única plataforma), lembre-se de não
contar com a existência ou o conteúdo de arquivos ou diretórios específicos do sistema,
como / Etc / passwd, /etc/sendmail.conf, / Etc / resolv.conf, ou mesmo / tmp /. Por exemplo, a
/ Etc / passwd pode existir, mas não conter as senhas criptografadas, porque o sistema está usando
alguma forma de segurança reforçada. Ou pode não conter todas as contas, porque o
sistema está usando NIS. Se o código precisar depender de tal arquivo, inclua uma descrição de
o arquivo e seu formato na documentação do código, então facilite para o usuário
substituir o local padrão do arquivo.

Não assuma que um arquivo de texto terminará com uma nova linha. Deveriam, mas as pessoas esquecem.

Não tenha dois arquivos ou diretórios de mesmo nome com maiúsculas e minúsculas, como teste.pl
e Teste.pl, já que muitas plataformas não diferenciam maiúsculas de minúsculas (ou pelo menos toleram maiúsculas)
nomes de arquivos. Além disso, tente não ter caracteres que não sejam palavras (exceto ".") nos nomes e
mantê-los na convenção 8.3, para máxima portabilidade, oneroso, embora isso possa
aparecer.

Da mesma forma, ao usar o módulo "AutoSplit", tente manter suas funções com a nomenclatura 8.3 e
convenções que não diferenciam maiúsculas de minúsculas; ou, pelo menos, fazer com que os arquivos resultantes tenham um
únicos (não diferencia maiúsculas de minúsculas) primeiros 8 caracteres.

Espaços em branco em nomes de arquivos são tolerados na maioria dos sistemas, mas não em todos, e até mesmo em sistemas
onde pode ser tolerado, alguns utilitários podem ficar confusos com esse espaço em branco.

Muitos sistemas (DOS, VMS ODS-2) não podem ter mais de um "." em seus nomes de arquivo.

Não assuma que ">" não será o primeiro caractere de um nome de arquivo. Sempre use "<" explicitamente para
abra um arquivo para leitura, ou melhor ainda, use a versão de três argumentos de "abrir", a menos que você
deseja que o usuário seja capaz de especificar um pipe aberto.

abra meu $fh, '<', $existing_file) ou morra $!;

Se os nomes dos arquivos usarem caracteres estranhos, é mais seguro abri-los com "sysopen"
de "aberto". "open" é mágico e pode traduzir caracteres como ">", "<" e "|", que podem
ser a coisa errada a fazer. (Às vezes, porém, é a coisa certa.) Três-arg aberto pode
também ajudam a proteger contra essa tradução nos casos em que ela é indesejável.

Não use ":" como parte de um nome de arquivo, pois muitos sistemas usam isso para sua própria semântica
(Mac OS Classic para separar componentes de nome de caminho, muitos esquemas de rede e utilitários
para separar o nome do nó e o nome do caminho e assim por diante). Pelas mesmas razões, evite
"@", ";" e "|".

Não assuma que em nomes de caminho você pode recolher duas barras iniciais "//" em uma: algumas
sistemas de arquivos de rede e clustering têm uma semântica especial para isso. Deixe o funcionamento
sistema resolva isso.

O portátil nome do arquivo caracteres conforme definido pelo ANSI C são

abcdefghijklmnopqrtuv wxyz
ABCDEFGHIJKLMNOPQRTUV WXYZ
0 1 2 3 4 5 6 7 8 9
. _ -

e o "-" não deve ser o primeiro caractere. Se você quer ser hipercorreto, fique caso-
insensível e dentro da convenção de nomenclatura 8.3 (todos os arquivos e diretórios devem ser
único dentro de um diretório se seus nomes estiverem em minúsculas e truncados para oito
caracteres antes do ".", se houver, e três caracteres após o ".", se houver). (E
não use "."s em nomes de diretórios.)

System Interação
Nem todas as plataformas fornecem uma linha de comando. Geralmente são plataformas que dependem principalmente
em uma interface gráfica do usuário (GUI) para interação do usuário. Um programa que requer um comando
interface de linha pode não funcionar em todos os lugares. Isto é provavelmente para o usuário do programa
lidar com isso, então não fique acordado até tarde se preocupando com isso.

Algumas plataformas não podem excluir ou renomear arquivos mantidos abertos pelo sistema, esta limitação pode
também se aplicam à alteração de metainformações do sistema de arquivos, como permissões ou proprietários de arquivos.
Lembre-se de "fechar" os arquivos quando terminar com eles. Não "desvincule" ou "renomeie" um arquivo aberto
Arquivo. Não "amarre" ou "abra" um arquivo já amarrado ou aberto; "desatar" ou "fechar" primeiro.

Não abra o mesmo arquivo mais de uma vez para escrever, pois alguns sistemas operacionais
colocar bloqueios obrigatórios em tais arquivos.

Não assuma que a permissão de gravação/modificação em um diretório dá o direito de adicionar ou excluir
arquivos/diretórios nesse diretório. Isso é específico do sistema de arquivos: em alguns sistemas de arquivos você
precisa de permissão de gravação/modificação também (ou mesmo apenas) no próprio arquivo/diretório. Em alguns
sistemas de arquivos (AFS, DFS) a permissão para adicionar/excluir entradas de diretório é completamente
permissão separada.

Não assuma que um único "desvincular" elimina completamente o arquivo: alguns sistemas de arquivos
(principalmente os do VMS) têm sistemas de arquivos versionados, e "unlink()" remove apenas o
mais recente (não remove todas as versões porque por padrão as ferramentas nativas do
essas plataformas também removem apenas a versão mais recente). O idioma portátil para remover
todas as versões de um arquivo são

1 enquanto desvincula "arquivo";

Isso terminará se o arquivo não puder ser excluído por algum motivo (protegido, ausente e
em breve).

Não conte com uma variável de ambiente específica existente em %ENV. Não conte com %ENV
entradas diferenciando maiúsculas de minúsculas ou até mesmo preservando maiúsculas e minúsculas. Não tente limpar %ENV dizendo
"%ENV = ();", ou, se for realmente necessário, condicione-o a "$^O ne 'VMS'" já que em
VMS a tabela %ENV é muito mais do que uma tabela de string de valor-chave por processo.

No VMS, algumas entradas no hash %ENV são criadas dinamicamente quando sua chave é usada em um
ler se eles não existiam anteriormente. Os valores para $ENV{HOME}, $ENV{TERM}, $ENV{PATH},
e $ENV{USER}, são conhecidos por serem gerados dinamicamente. Os nomes específicos que
gerado dinamicamente pode variar com a versão da biblioteca C no VMS, e mais
existem do que estão documentados.

No VMS, por padrão, as alterações no hash %ENV persistem após a saída do perl. Subseqüente
invocações de perl no mesmo processo podem inadvertidamente herdar configurações de ambiente
que deveriam ser temporários.

Não conte com sinais ou %SIG para nada.

Não conte com globbing de nome de arquivo. Use "opendir", "readdir" e "closedir" em vez disso.

Não conte com variáveis ​​de ambiente por programa ou diretórios atuais por programa.

Não conte com valores específicos de $!, nem numéricos nem principalmente os valores de string.
Os usuários podem mudar suas localidades fazendo com que as mensagens de erro sejam traduzidas para seus
línguas. Se você pode confiar em um ambiente POSIXish, você pode usar os símbolos de forma portátil
definido pelo módulo "Errno", como "ENOENT". E não confie nos valores de $! em absoluto
exceto imediatamente após uma chamada de sistema com falha.

Command nomes contra lima nomes de caminho
Não assuma que o nome usado para invocar um comando ou programa com "system" ou "exec" pode
também ser usado para testar a existência do arquivo que contém o código executável para aquele
comando ou programa. Primeiro, muitos sistemas têm comandos "internos" que são embutidos no
shell ou OS e, embora esses comandos possam ser invocados, não há arquivo correspondente.
Em segundo lugar, alguns sistemas operacionais (por exemplo, Cygwin, DJGPP, OS/2 e VOS) exigem sufixos
para arquivos executáveis; esses sufixos geralmente são permitidos no nome do comando, mas são
não requerido. Assim, um comando como "perl" pode existir em um arquivo chamado "perl", "perl.exe",
or "perl.pm", dependendo do sistema operacional. A variável "_exe" no "Config"
módulo contém o sufixo executável, se houver. Terceiro, a porta VMS configura cuidadosamente $^X e
$Config{perlpath} para que nenhum processamento adicional seja necessário. Isso é tão bom,
porque a expressão regular correspondente usada abaixo teria que lidar com uma possível
número da versão à direita no nome do arquivo VMS.

Para converter $^X em um nome de caminho de arquivo, levando em consideração os requisitos dos vários
possibilidades do sistema operacional, digamos:

usar configuração;
meu $thisperl = $^X;
if ($^O ne 'VMS')
{$thisperl .= $Config{_exe} a menos que $thisperl =~ m/$Config{_exe}$/i;}

Para converter $Config{perlpath} em um nome de caminho de arquivo, diga:

usar configuração;
meu $thisperl = $Config{perlpath};
if ($^O ne 'VMS')
{$thisperl .= $Config{_exe} a menos que $thisperl =~ m/$Config{_exe}$/i;}

Networking
Não assuma que você pode acessar a Internet pública.

Não presuma que há apenas uma maneira de passar por firewalls para a Internet pública.

Não assuma que você pode alcançar o mundo exterior através de qualquer outra porta que não seja 80, ou algum
procurador. ftp é bloqueado por muitos firewalls.

Não presuma que você pode enviar e-mail conectando-se à porta SMTP local.

Não assuma que você pode acessar a si mesmo ou a qualquer nó pelo nome 'localhost'. O mesmo
vai para '127.0.0.1'. Você terá que experimentar os dois.

Não assuma que o host tenha apenas uma placa de rede ou que não possa se conectar a muitas
endereços IP virtuais.

Não assuma um nome de dispositivo de rede específico.

Não assuma que um conjunto específico de "ioctl()"s funcionará.

Não assuma que você pode fazer ping nos hosts e obter respostas.

Não assuma que qualquer porta (serviço) em particular responderá.

Não presuma que "Sys::Hostname" (ou qualquer outra API ou comando) retorne um
hostname qualificado ou um hostname não qualificado: tudo depende de como o sistema foi
configurado. Lembre-se também que para coisas como DHCP e NAT, o nome do host que você recebe de volta
pode não ser muito útil.

Todos os "não":s acima podem parecer assustadores, e são, mas a chave é degradar
graciosamente se não for possível alcançar o serviço de rede específico que se deseja. Coaxar ou
pendurado não parece muito profissional.

Interprocesso Comunicação (CPI)
Em geral, não acesse diretamente o sistema em código destinado a ser portátil. Isso significa, não
"system", "exec", "fork", "pipe", "``", "qx//", "open" com um "|", nem qualquer um dos outros
coisas que fazem valer a pena ser um hacker Perl.

Comandos que iniciam processos externos geralmente são suportados na maioria das plataformas (embora
muitos deles não suportam nenhum tipo de bifurcação). O problema de usá-los vem de
sobre o que você os invoca. Ferramentas externas são frequentemente nomeadas de forma diferente em diferentes
plataformas, podem não estar disponíveis no mesmo local, podem aceitar argumentos diferentes,
podem se comportar de maneira diferente e geralmente apresentam seus resultados de maneira dependente da plataforma.
Assim, você raramente deve depender deles para produzir resultados consistentes. (Então, novamente, se
você está ligando netstat -a, você provavelmente não espera que ele seja executado em Unix e CP/M.)

Um bit especialmente comum do código Perl é abrir um pipe para enviar correio:

open(MAIL, '|/ usr / lib / sendmail -t')
ou morrer "não é possível bifurcar o sendmail: $!";

Isso é bom para programação de sistemas quando se sabe que o sendmail está disponível. Mas isso é
não é bom para muitos sistemas não-Unix, e até mesmo alguns sistemas Unix que podem não ter sendmail
instalado. Se for necessária uma solução portátil, veja as várias distribuições no CPAN que
lide com isso. "Mail::Mailer" e "Mail::Send" na distribuição "MailTools" são
comumente usados ​​e fornecem vários métodos de correspondência, incluindo "mail", "sendmail" e
SMTP direto (via "Net::SMTP") se um agente de transferência de correio não estiver disponível. "E-mail::Enviar e-mail"
é um módulo autônomo que fornece correspondência simples e independente de plataforma.

O Unix System V IPC ("msg*(), sem*(), shm*()") não está disponível mesmo em todos os Unix
.

Não use o resultado simples de "pack("N", 10, 20, 30, 40)" ou v-strings simples (como
como "v10.20.30.40") para representar endereços IPv4: ambas as formas apenas compactam os quatro bytes em
ordem de rede. Que isso seria igual à estrutura "in_addr" da linguagem C (que é o que
o código de soquete usa internamente) não é garantido. Para ser portátil use as rotinas de
a extensão "Socket", como "inet_aton()", "inet_ntoa()" e "sockaddr_in()".

A regra geral para código portátil é: Faça tudo em Perl portátil, ou use um módulo (que
pode implementá-lo internamente com código específico da plataforma, mas expõe uma interface comum).

Externo Sub-rotinas (XS)
O código XS geralmente pode ser feito para funcionar com qualquer plataforma, mas bibliotecas dependentes,
arquivos, etc., podem não estar prontamente disponíveis ou portáteis, ou o próprio código XS pode ser
específico da plataforma, assim como o código Perl pode ser. Se as bibliotecas e os cabeçalhos forem portáteis,
então normalmente é razoável certificar-se de que o código XS também seja portátil.

Um tipo diferente de problema de portabilidade surge ao escrever código XS: disponibilidade de um C
compilador no sistema do usuário final. C traz consigo seus próprios problemas de portabilidade, e
escrever código XS irá expô-lo a alguns deles. Escrever puramente em Perl é uma maneira mais fácil
para alcançar a portabilidade.

Padrão Módulos
Em geral, os módulos padrão funcionam entre plataformas. Exceções notáveis ​​são o "CPAN"
módulo (que atualmente faz conexões com programas externos que podem não estar disponíveis),
módulos específicos da plataforma (como "ExtUtils::MM_VMS") e módulos DBM.

Não há um módulo DBM disponível em todas as plataformas. "SDBM_File" e os outros são
geralmente disponível em todas as portas Unix e DOSish, mas não em MacPerl, onde apenas
"NDBM_File" e "DB_File" estão disponíveis.

A boa notícia é que pelo menos algum módulo DBM deve estar disponível, e "AnyDBM_File"
use qualquer módulo que encontrar. Claro, então o código precisa ser bastante rigoroso,
caindo para o máximo divisor comum (por exemplo, não excedendo 1K para cada registro), de modo que
ele funcionará com qualquer módulo DBM. Consulte AnyDBM_File para obter mais detalhes.

Tempo e Data
A noção do sistema de hora do dia e data do calendário é controlada em
caminhos. Não assuma que o fuso horário está armazenado em $ENV{TZ} e, mesmo que esteja, não assuma
que você pode controlar o fuso horário por meio dessa variável. Não suponha nada sobre o
abreviaturas de fuso horário de três letras (por exemplo, que MST seria o Mountain Standard
Tempo, é conhecido por significar o Horário Padrão de Moscou). Se você precisar usar fusos horários,
expressá-los em algum formato inequívoco, como o número exato de minutos de deslocamento do UTC,
ou o formato de fuso horário POSIX.

Não assuma que a época começa às 00:00:00, 1º de janeiro de 1970, porque isso é OS- e
específicos de implementação. É melhor armazenar uma data em uma representação inequívoca.
O padrão ISO 8601 define YYYY-MM-DD como o formato de data, ou YYYY-MM-DDTHH:MM:SS
(que é um "T" literal separando a data da hora). Por favor, use a ISO 8601
em vez de nos fazer adivinhar qual seria a data 02/03/04. A ISO 8601 até classifica bem como está.
Uma representação de texto (como "1987-12-18") pode ser facilmente convertida em um arquivo específico do sistema operacional
valor usando um módulo como "Date::Parse". Uma matriz de valores, como os retornados por
"localtime", pode ser convertido em uma representação específica do sistema operacional usando "Time::Local".

Ao calcular tempos específicos, como para testes em módulos de hora ou data, pode ser
apropriado para calcular um deslocamento para a época.

requer Tempo::Local;
meu $offset = Hora::Local::timegm(0, 0, 0, 1, 0, 70);

O valor para $offset no Unix será 0, mas no Mac OS Classic será um número grande.
$offset pode então ser adicionado a um valor de tempo Unix para obter o que deve ser o valor adequado
qualquer sistema.

Personagem conjuntos e personagem codificação
Assuma muito pouco sobre conjuntos de caracteres.

Não assuma nada sobre valores numéricos ("ord", "chr") de caracteres. Não use explícito
intervalos de pontos de código (como "\xHH-\xHH)". No entanto, a partir do Perl v5.22, a expressão regular
intervalos de classe de caracteres entre colchetes padrão especificados como "qr/[\N{U+HH}-\N{U+HH}]/" são
portátil. Você pode usar de forma portátil classes de caracteres simbólicos como "[:print:]".

Não assuma que os caracteres alfabéticos são codificados de forma contígua (no
senso). Pode haver lacunas. A codificação especial em Perl, no entanto, garante que todos os subconjuntos
de "qr/[AZ]/", "qr/[az]/" e "qr/[0-9]/" se comportam conforme o esperado. "tr///" se comporta da mesma forma
para esses intervalos. Nos padrões, qualquer intervalo especificado com pontos finais usando o "\N{...}"
notations garante a portabilidade do conjunto de caracteres, mas é um bug no Perl v5.22, que isso
não é verdade para "tr///".

Não suponha nada sobre a ordenação dos personagens. As letras minúsculas podem
vir antes ou depois das letras maiúsculas; as letras minúsculas e maiúsculas podem ser entrelaçadas
de modo que tanto "a" quanto "A" venham antes de "b"; os acentuados e outros caracteres internacionais
pode ser entrelaçado para que ae venha antes de "b". Unicode::Collate pode ser usado para classificar isso
tudo para fora.

Internacionalização
Se você pode assumir POSIX (uma suposição bastante grande), você pode ler mais sobre o POSIX
sistema locale de perllocale. O sistema de localidade pelo menos tenta tornar as coisas um
um pouco mais portátil, ou pelo menos mais conveniente e amigável para não-ingleses
Comercial. O sistema afeta conjuntos de caracteres e codificação, e data e hora
formatação - entre outras coisas.

Se você realmente quer ser internacional, considere o Unicode. Veja perluniintro e
perlunico para obter mais informações.

Se você quiser usar bytes não ASCII (fora dos bytes 0x00..0x7f) no "código-fonte" do
seu código, para ser portátil, você precisa ser explícito sobre quais bytes são. Alguém
pode, por exemplo, estar usando seu código em uma localidade UTF-8, nesse caso nativo aleatório
bytes podem ser ilegais ("UTF-8 malformado ...") Isso significa que, por exemplo, incorporar ISO
8859-1 bytes além de 0x7f em suas strings podem causar problemas mais tarde. Se os bytes são
bytes nativos de 8 bits, você pode usar o pragma "bytes". Se os bytes estiverem em uma string (regular
expressões sendo strings curiosas), muitas vezes você também pode usar o "\xHH" ou mais portátil,
as notações "\N{U+HH}" em vez de incorporar os bytes como estão. Se você quiser escrever seu
código em UTF-8, você pode usar utf8.

System Notícias
Se o seu código for destinado a sistemas com restrições virtuais severas (ou ausentes!)
sistemas de memória, então você quer ser especialmente consciente de evitar construções desnecessárias como
como:

minhas @linhas = <$very_large_file>; # ruim

while (<$fh>) {$file .= $_} # às vezes ruim
meu $arquivo = join('', <$fh>); # Melhor

As duas últimas construções podem parecer pouco intuitivas para a maioria das pessoas. O primeiro cresce repetidamente
uma string, enquanto a segunda aloca um grande pedaço de memória de uma só vez. Em alguns
sistemas, o segundo é mais eficiente que o primeiro.

Segurança
A maioria das plataformas multiusuário fornece níveis básicos de segurança, geralmente implementados no
nível do sistema de arquivos. Alguns, porém, infelizmente não. Assim, a noção de ID do usuário, ou
diretório "home", ou mesmo o estado de estar logado, pode ser irreconhecível em muitos
plataformas. Se você escreve programas preocupados com a segurança, geralmente é melhor saber
em que tipo de sistema você estará executando para que você possa escrever código explicitamente para
essa plataforma (ou classe de plataformas).

Não assuma a semântica de acesso ao sistema de arquivos Unix: o sistema operacional ou o sistema de arquivos
pode estar usando alguns sistemas ACL, que são linguagens mais ricas do que o "rwx" usual. Mesmo se
o "rwx" existe, sua semântica pode ser diferente.

(Do ponto de vista da segurança, testar as permissões antes de tentar fazer algo é
bobo de qualquer maneira: se alguém tentar isso, há potencial para condições de corrida. Alguém ou
algo pode alterar as permissões entre a verificação de permissões e o real
Operação. Apenas tente a operação.)

Não assuma a semântica de usuário e grupo do Unix: especialmente, não espere $< e $> (ou $(
e $)) para trabalhar na troca de identidades (ou associações).

Não assuma a semântica set-uid e set-gid. (E mesmo se você fizer isso, pense duas vezes: set-uid e
set-gid são uma lata conhecida de worms de segurança.)

Sessão de Fotos
Para aqueles momentos em que é necessário ter código específico da plataforma, considere manter o
código específico da plataforma em um só lugar, facilitando a portabilidade para outras plataformas. Use o
módulo "Config" e a variável especial $^O para diferenciar plataformas, conforme descrito em
"PLATAFORMAS".

Tenha cuidado nos testes que você fornece com seu módulo ou programas. O código do módulo pode ser totalmente
portátil, mas seus testes podem não ser. Isso geralmente acontece quando os testes geram outros
processos ou chamar programas externos para auxiliar no teste, ou quando (como observado acima) o
testes assumem certas coisas sobre o sistema de arquivos e caminhos. Cuidado para não depender de um
estilo de saída específico para erros, como ao verificar $! após uma chamada de sistema com falha.
Usando $! para qualquer outra coisa além de exibi-lo como saída é duvidoso (embora veja o
Módulo "Errno" para testar o valor do erro de forma razoavelmente portátil). Algumas plataformas esperam um
determinado formato de saída, e o Perl nessas plataformas pode ter sido ajustado de acordo.
Mais especificamente, não ancore um regex ao testar um valor de erro.

CPAN Testadores

Os módulos carregados no CPAN são testados por uma variedade de voluntários em diferentes plataformas.
Esses testadores CPAN são notificados por correio de cada novo upload e respondem à lista com
PASS, FAIL, NA (não aplicável a esta plataforma) ou UNKNOWN (desconhecido), juntamente com qualquer
notações relevantes.

O objetivo do teste é duplo: um, para ajudar os desenvolvedores a corrigir quaisquer problemas em seus
código que surge por falta de testes em outras plataformas; dois, para fornecer aos usuários
com informações sobre se um determinado módulo funciona em uma determinada plataforma.

Veja também:

· Lista de correspondência: [email protected]

· Resultados dos testes:http://www.cpantesters.org/>

PLATAFORMAS

Perl é construído com uma variável $^O que indica o sistema operacional em que foi construído.
Isso foi implementado para ajudar a acelerar o código que, de outra forma, teria que "usar Config" e
use o valor de $Config{osname}. Naturalmente, para obter informações mais detalhadas sobre o
sistema, olhar para %Config é certamente recomendado.

No entanto, o %Config nem sempre é confiável, pois foi criado em tempo de compilação. Se perl
foi construído em um lugar e depois transferido para outro, alguns valores podem estar errados. Os valores
pode até ter sido editado após o fato.

Unix
Perl funciona em uma desconcertante variedade de plataformas Unix e Unix-like (veja, por exemplo, a maioria dos
arquivos no dicas / diretório no kit de código-fonte). Na maioria desses sistemas, o
valor de $^O (daí $Config{'osname'}, também) é determinado por letras minúsculas e
retirando a pontuação do primeiro campo da string retornada digitando "uname -a" (ou
um comando semelhante) no prompt do shell ou testando o sistema de arquivos quanto à presença de
arquivos com nomes exclusivos, como kernel ou arquivo de cabeçalho. Aqui, por exemplo, estão alguns dos
sabores Unix mais populares:

uname $^O $Config{'archname'}
--------------------------------------------
aix aix aix
BSD/OS bsdos i386-bsdos
darwin darwin darwin
DYNIX/ptx dynixptx i386-dynixptx
FreeBSD freebsd freebsd-i386
Haiku haicai BePC-haiku
Linux linux arm-linux
Linux linux armv5tel-linux
Linux linux i386-linux
Linux linux i586-linux
Linux linux ppc-linux
HP-UX HPUX PA-RISC1.1
irix irix irix
Mac OS X Darwin Darwin
NeXT 3 próxima próxima gordura
NeXT 4 próximo OPENSTEP-Mach
openbsd openbsd i386-openbsd
OSF1 dec_osf alfa-dec_osf
reliantunix-n svr4 RM400-svr4
SCO_SV sco_sv i386-sco_sv
SINIX-N svr4 RM400-svr4
sn4609 únicos CRAY_C90-únicos
sn6521 unicosmk t3e-unicosmk
sn9617 únicos CRAY_J90-únicos
SunOS solaris sun4-solaris
SunOS solaris i86pc-solaris
SunOS4 sunos sun4-sunos

Como o valor de $Config{archname} pode depender da arquitetura de hardware, ele pode
variam mais do que o valor de $^O.

DOS e Derivativos
O Perl foi portado há muito tempo para microcomputadores no estilo Intel rodando em sistemas como PC-DOS,
MS-DOS, OS/2 e a maioria das plataformas Windows que você pode mencionar (exceto
Windows CE, se você contar isso). Usuários familiarizados com COMMAND.COM or CMD.EXE conchas de estilo
deve estar ciente de que cada uma dessas especificações de arquivo pode ter diferenças sutis:

meu $filespec0 = "c:/foo/bar/arquivo.txt";
meu $filespec1 = "c:\\foo\\bar\\arquivo.txt";
meu $filespec2 = 'c:\foo\bar\arquivo.txt';
meu $filespec3 = 'c:\\foo\\bar\\arquivo.txt';

As chamadas do sistema aceitam "/" ou "\" como separador de caminho. No entanto, muitas linhas de comando
utilitários do DOS vintage tratam "/" como o prefixo da opção, portanto, podem ficar confusos com os nomes dos arquivos
contendo "/". Além de chamar qualquer programa externo, "/" funcionará bem e
provavelmente melhor, pois é mais consistente com o uso popular e evita o problema de
lembrando o que fazer backwhack e o que não fazer.

O sistema de arquivos DOS FAT pode acomodar apenas nomes de arquivos de estilo "8.3". Sob o "caso-
sistemas de arquivos HPFS (OS/2) e NTFS (NT) insensíveis, mas que preservam maiúsculas e minúsculas, você pode ter que
cuidado com o caso retornado com funções como "readdir" ou usado com funções como
"abrir" ou "abrir".

O DOS também trata vários nomes de arquivos como especiais, como AUX, PRN, NUL, CON, COM1, LPT1,
LPT2, etc. Infelizmente, às vezes, esses nomes de arquivo nem funcionarão se você incluir um
prefixo de diretório explícito. É melhor evitar esses nomes de arquivo, se você quiser que seu código
ser portátil para DOS e seus derivados. É difícil saber o que tudo isso é,
infelizmente.

Os usuários desses sistemas operacionais também podem querer usar scripts como pl2bat.bat
or pl2cmd para colocar wrappers em torno de seus scripts.

A nova linha ("\n") é traduzida como "\015\012" pelo STDIO ao ler e gravar em arquivos
(veja "Novas linhas"). "binmode(FILEHANDLE)" manterá "\n" traduzido como "\012" para isso
identificador de arquivo. Uma vez que é um no-op em outros sistemas, "binmode" deve ser usado para cross-
código de plataforma que lida com dados binários. Isso supondo que você perceba antecipadamente que
seus dados estão em binário. Programas de propósito geral geralmente não devem presumir nada sobre seus
dados.

A variável $^O e os valores $Config{archname} para vários perls DOSish são os seguintes:

Versão do ID do SO $^O $Config{archname}
-------------------------------------------------- ------
MS-DOS dos?
PC DOS?
OS/2 os2?
Windows 3.1? ? 0 3 01
Windows 95 MSWin32 MSWin32-x86 1 4 00
Windows 98 MSWin32 MSWin32-x86 1 4 10
Windows ME MSWin32 MSWin32-x86 1?
Windows NT MSWin32 MSWin32-x86 2 4 xx
Windows NT MSWin32 MSWin32-ALPHA 2 4 xx
Windows NT MSWin32 MSWin32-ppc 2 4 xx
Windows 2000 MSWin32 MSWin32-x86 2 5 00
Windows XP MSWin32 MSWin32-x86 2 5 01
Windows 2003 MSWin32 MSWin32-x86 2 5 02
Windows Vista MSWin32 MSWin32-x86 2 6 00
Windows 7 MSWin32 MSWin32-x86 2 6 01
Windows 7 MSWin32 MSWin32-x64 2 6 01
Windows 2008 MSWin32 MSWin32-x86 2 6 01
Windows 2008 MSWin32 MSWin32-x64 2 6 01
Windows CE MSWin32? 3
Cygwin Cygwin Cygwin

Os vários MSWin32 Perl podem distinguir o sistema operacional em que estão sendo executados através do valor do
quinto elemento da lista retornado de "Win32::GetOSVersion()". Por exemplo:

if ($^O eq 'MSWin32') {
meu @os_version_info = Win32::GetOSVersion();
print +('3.1','95','NT')[$os_version_info[4]],"\n";
}

Há também "Win32::IsWinNT()" e "Win32::IsWin95()"; tente "perldoc Win32", e a partir de
libwin32 0.19 (não faz parte da distribuição principal do Perl) "Win32::GetOSName()". O muito
portátil "POSIX::uname()" também funcionará:

c:\> perl -MPOSIX -we "print join '|', uname"
Windows NT|moonru|5.0|Build 2195 (Service Pack 2)|x86

Veja também:

· O ambiente djgpp para DOS,http://www.delorie.com/djgpp/> e perldos.

· O ambiente EMX para DOS, OS/2, etc. [email protected],
<ftp://hobbes.nmsu.edu/pub/os2/dev/emx/> Também perlos2.

· Construir instruções para Win32 em perlwin32, ou sob o ambiente Cygnus em
perlcygwin.

· Os módulos "Win32::*" no Win32.

· As Páginas ActiveState,http://www.activestate.com/>

· O ambiente Cygwin para Win32; README.cygwin (instalado como perlcygwin),
<http://www.cygwin.com/>

· O ambiente U/WIN para Win32,http://www.research.att.com/sw/tools/uwin/>

· Instruções de construção para OS/2, perlos2

VMS
Perl em VMS é discutido em perlvms na distribuição Perl.

O nome oficial do VMS no momento da redação deste artigo é OpenVMS.

Interagir com Perl a partir do shell DCL (Digital Command Language) geralmente requer um
conjunto diferente de aspas do que os shells Unix fazem. Por exemplo:

$ perl -e "print ""Olá, mundo.\n"""
Olá mundo.

Existem várias maneiras de envolver seus scripts Perl em DCL . COM arquivos, se você é assim
inclinado. Por exemplo:

$ write sys$output "Olá da DCL!"
$ se p1 .eqs. ""
$ então perl -x 'f$environment("PROCEDIMENTO")
$ else perl -x - 'p1 'p2 'p3 'p4 'p5 'p6 'p7 'p8
$ baralho/dólares="__END__"
#!/ usr / bin / perl

print "Olá do Perl!\n";

__FIM__
$endif

Tome cuidado com "$ ASSIGN/nolog/user SYS$COMMAND: SYS$INPUT" se o seu script Perl-in-DCL
espera fazer coisas como "$read = ;".

O sistema operacional VMS possui dois sistemas de arquivos, designados por sua estrutura em disco (ODS)
nível: ODS-2 e seu sucessor ODS-5. A porta inicial de Perl para VMS é anterior ao ODS-5,
mas todos os testes e desenvolvimentos atuais assumem o ODS-5 e seus recursos, incluindo case
preservação, caracteres estendidos em especificações de arquivos e nomes de até 8192 bytes.

Perl no VMS pode aceitar especificações de arquivo no estilo VMS ou Unix como em qualquer um dos
A seguir:

$ perl -ne "imprimir se /perl_setup/i" SYS$LOGIN:LOGIN.COM
$ perl -ne "imprimir se /perl_setup/i" / sys$login/login.com

mas não uma mistura de ambos como em:

$ perl -ne "imprimir se /perl_setup/i" sys$login:/login.com
Não é possível abrir sys$login:/login.com: erro de sintaxe de especificação de arquivo

Em geral, o caminho mais fácil para a portabilidade é sempre especificar nomes de arquivos no formato Unix
a menos que eles precisem ser processados ​​por comandos ou utilitários nativos. Devido a esta
última consideração, o módulo File::Spec por padrão retorna o formato nativo
especificações independentemente do formato de entrada. Este padrão pode ser revertido para que os nomes dos arquivos
são sempre relatados no formato Unix especificando o recurso "DECC$FILENAME_UNIX_REPORT"
lógico no ambiente.

O tipo de arquivo, ou extensão, está sempre presente em uma especificação de arquivo no formato VMS, mesmo se
é de comprimento zero. Isso significa que, por padrão, "readdir" retornará um ponto final em um
arquivo sem extensão, então onde você veria "a" no Unix você verá "a". em VMS.
No entanto, o ponto final pode ser suprimido ativando o "DECC$READDIR_DROPDOTNOTYPE"
recurso no ambiente (consulte a documentação CRTL sobre nomes lógicos de recursos).

O que "\n" representa depende do tipo de arquivo aberto. Geralmente representa "\012", mas
também pode ser "\015", "\012", "\015\012", "\000", "\040" ou nada dependendo do
organização de arquivos e formato de registro. O módulo "VMS::Stdio" fornece acesso ao
requisitos especiais "fopen()" de arquivos com atributos incomuns no VMS.

O valor de $^O no OpenVMS é "VMS". Para determinar a arquitetura que você está executando
em consulte $Config{'archname'}.

No VMS, o perl determina o deslocamento UTC do nome lógico "SYS$TIMEZONE_DIFFERENTIAL".
Embora a época do VMS tenha começado em 17-NOV-1858 00:00:00.00, as chamadas para "localtime" são ajustadas
para contar deslocamentos de 01-JAN-1970 00:00:00.00, assim como o Unix.

Veja também:

· README.vms (instalado como README_vms), perlvms

· lista vmsperl, [email protected]

· vmsperl na web,http://www.sidhe.org/vmsperl/index.html>

· Site da VMS Software Inc.,http://www.vmssoftware.com>

SEU
Perl em VOS (também conhecido como OpenVOS) é discutido em README.vos na distribuição Perl
(instalado como perlvos). Perl no VOS pode aceitar arquivos no estilo VOS ou Unix
especificações como em qualquer um dos seguintes:

$ perl -ne "imprimir if /perl_setup/i" >sistema > avisos
$ perl -ne "imprimir se /perl_setup/i" /system/notices

ou mesmo uma mistura de ambos como em:

$ perl -ne "print if /perl_setup/i" >system/notices

Embora o VOS permita que o caractere de barra apareça em nomes de objetos, porque a porta VOS
de Perl o interpreta como um caractere delimitador de nome de caminho, arquivos VOS, diretórios ou links
cujos nomes contêm um caractere de barra não podem ser processados. Esses arquivos devem ser renomeados
antes que eles possam ser processados ​​por Perl.

Versões mais antigas do VOS (antes do OpenVOS Release 17.0) limitam os nomes dos arquivos a 32 ou menos
caracteres, proibir nomes de arquivo de começar com um caractere "-" e proibir arquivo
nomes de conter qualquer caractere correspondente a "tr/ !#%&'()*;<=>?//".

Versões mais recentes do VOS (OpenVOS Versão 17.0 ou posterior) suportam um recurso conhecido como estendido
nomes. Nessas versões, os nomes dos arquivos podem conter até 255 caracteres, são proibidos
de começar com um caractere "-", e o conjunto de caracteres proibidos é reduzido a qualquer
caractere correspondente a "tr/#%*<>?//". Existem restrições envolvendo espaços e
apóstrofos: esses caracteres não devem começar ou terminar um nome, nem podem imediatamente
precedem ou seguem um período. Além disso, um espaço não deve preceder imediatamente outro
espaço ou hífen. Especificamente, as seguintes combinações de caracteres são proibidas:
espaço-espaço, espaço-hífen, período-espaço, espaço-período, período-apóstrofo, apóstrofo-
período, espaço inicial ou final e apóstrofo inicial ou final. Embora um
nome de arquivo estendido está limitado a 255 caracteres, um nome de caminho ainda está limitado a 256
caracteres.

O valor de $^O em VOS é "vos". Para determinar a arquitetura na qual você está executando
sem recorrer a carregar todo %Config você pode examinar o conteúdo do array @INC
igual a:

if ($^O =~ /vos/) {
print "Estou em uma caixa Stratus!\n";
Else {}
print "Não estou em uma caixa Stratus!\n";
morrer;
}

Veja também:

· README.vos (instalado como perlvos)

· A lista de discussão VOS.

Não há lista de discussão específica para Perl no VOS. Você pode entrar em contato com o Stratus
Technologies Customer Assistance Center (CAC) para sua região, ou você pode usar o
informações de contato localizadas nos arquivos de distribuição no FTP do Stratus Anonymous
site.

· Stratus Technologies na web emhttp://www.stratus.com>

· Software de código aberto VOS na web emhttp://ftp.stratus.com/pub/vos/vos.html>

EBCDIC Desafios
v5.22 core Perl é executado em z/OS (anteriormente OS/390). Teoricamente, poderia ser executado no
sucessores do OS/400 em minicomputadores AS/400, bem como VM/ESA, e BS2000 para S/390
Mainframes. Esses computadores usam conjuntos de caracteres EBCDIC internamente (geralmente Código de Caracteres
Defina o ID 0037 para OS/400 e 1047 ou POSIX-BC para sistemas S/390).

O restante desta seção pode precisar de atualização, mas não sabemos o que deve dizer. Por favor
comentários por e-mail para [email protected] <mailto:[email protected]>.

No mainframe, o Perl atualmente funciona sob os "Serviços do sistema Unix para OS/390"
(anteriormente conhecido como OpenEdition), VM/ESA OpenEdition ou o sistema BS200 POSIX-BC (BS2000
é suportado em Perl 5.6 e superior). Veja perlos390 para detalhes. Observe que para OS/400
há também uma porta de Perl 5.8.1/5.10.0 ou posterior para o PASE que é baseado em ASCII (como
ao contrário do ILE que é baseado em EBCDIC), veja perlos400.

A partir do R2.5 do USS para OS/390 e da Versão 2.3 do VM/ESA, esses subsistemas Unix não
apoiar o "#!" Shebang truque para invocação de script. Portanto, no OS/390 e VM/ESA Perl
scripts podem ser executados com um cabeçalho semelhante ao seguinte script simples:

: # usa perl
eval 'exec / usr / local / bin / perl -S $ 0 $ {1 + "$ @"}'
se 0;
#!/usr/local/bin/perl # apenas um comentário realmente

print "Olá do perl!\n";

OS/390 suportará o "#!" truque shebang na versão 2.8 e além. Chamadas para "sistema"
e backticks podem usar a sintaxe de shell POSIX em todos os sistemas S/390.

No AS/400, se PERL5 estiver em sua lista de bibliotecas, talvez seja necessário agrupar seus scripts Perl em
um procedimento CL para invocá-los assim:

INÍCIO
CALL PGM(PERL5/PERL) PARM('/QOpenSys/hello.pl')
ENDPGM

Isto irá invocar o script Perl ola.pl na raiz do sistema de ficheiros QOpenSys. No
As chamadas do AS/400 para "sistema" ou backticks devem usar a sintaxe CL.

Nessas plataformas, lembre-se de que o conjunto de caracteres EBCDIC pode afetar o que
acontece com algumas funções Perl (como "chr", "pack", "print", "printf", "ord", "sort",
"sprintf", "unpack"), bem como mexer nos bits com constantes ASCII usando operadores como
"^", "&" e "|", sem mencionar lidar com interfaces de soquete para computadores ASCII (consulte
"Novas linhas").

Felizmente, a maioria dos servidores web para o mainframe traduzirá corretamente o "\n" no
seguinte declaração para seu equivalente ASCII ("\r" é o mesmo em Unix e z/OS):

print "Tipo de conteúdo: texto/html\r\n\r\n";

Os valores de $^O em algumas dessas plataformas incluem:

uname $^O $Config{'archname'}
--------------------------------------------
OS/390 os390 os390
OS400 OS400 OS400
POSIX-BC posix-bc BS2000-posix-bc

Alguns truques simples para determinar se você está executando em uma plataforma EBCDIC podem incluir
qualquer um dos seguintes (talvez todos):

if ("\t" eq "\005") { print "EBCDIC pode ser falado aqui!\n"; }

if (ord('A') == 193) { print "EBCDIC pode ser falado aqui!\n"; }

if (chr(169) eq 'z') { print "EBCDIC pode ser falado aqui!\n"; }

Uma coisa na qual você pode não querer confiar é a codificação EBCDIC de caracteres de pontuação
uma vez que eles podem diferir de página de código para página de código (e uma vez que seu módulo ou script é
rumores de que funciona com EBCDIC, as pessoas vão querer que funcione com todos os conjuntos de caracteres EBCDIC).

Veja também:

· perlos390, perlos400, perlbs2000, perlebcdic.

· O [email protected] lista é para discussão de questões de portabilidade, bem como questões gerais
problemas de uso para todos os Perls EBCDIC. Envie um corpo de mensagem de "subscribe perl-mvs" para
[email protected].

· Informações AS/400 Perl emhttp://as400.rochester.ibm.com/> bem como no CPAN no
portas/ diretório.

Bolota RISC OS
Como o Acorns usa ASCII com novas linhas ("\n") em arquivos de texto como "\012" como Unix, e
como a emulação de nome de arquivo Unix está ativada por padrão, a maioria dos scripts simples provavelmente
trabalhar "fora da caixa". O sistema de arquivos nativo é modular e os sistemas de arquivos individuais são
livres para diferenciar maiúsculas de minúsculas ou não, e geralmente preservam maiúsculas e minúsculas. Alguns nativos
os sistemas de arquivos têm limites de comprimento de nome, cujos nomes de arquivo e diretório são truncados silenciosamente
caber. Os scripts devem estar cientes de que o sistema de arquivos padrão atualmente possui um comprimento de nome
limite de 10 caracteres, com até 77 itens em um diretório, mas outros sistemas de arquivos podem não
impor tais limitações.

Os nomes de arquivos nativos são da forma

Sistema de arquivos#Special_Field::DiskName.$.Directory.Directory.File

onde

Special_Field geralmente não está presente, mas pode conter . e $.
Sistema de arquivos =~ m|[A-Za-z0-9_]|
DsicNome =~ m|[A-Za-z0-9_/]|
$ representa o diretório raiz
. é o separador de caminho
@ é o diretório atual (por sistema de arquivos, mas global da máquina)
^ é o diretório pai
Diretório e Arquivo =~ m|[^\0- "\.\$\%\&:\@\\^\|\177]+|

A tradução de nome de arquivo padrão é aproximadamente "tr|/.|./|;"

Observe que ""ADFS::HardDisk.$.File" ne 'ADFS::HardDisk.$.File'" e que o segundo estágio
de interpolação "$" em expressões regulares irá falhar com o $. se os scripts não forem
Cuidado.

Os caminhos lógicos especificados por variáveis ​​do sistema contendo listas de pesquisa separadas por vírgulas são
também permitido; portanto, "System:Modules" é um nome de arquivo válido e o sistema de arquivos será prefixado
"Módulos" com cada seção de "System$Path" até que um nome seja criado que aponte para um objeto
em disco. A gravação em um novo arquivo "System:Modules" seria permitida somente se "System$Path"
contém uma única lista de itens. O sistema de arquivos também expandirá as variáveis ​​do sistema em
nomes de arquivos se entre colchetes angulares, então " .Modules" procuraria o arquivo
"$ENV{'System$Dir'} . 'Módulos'". A implicação óbvia disso é que totalmente qualificado
nomes de arquivos pode começo com "<>" e deve ser protegido quando "aberto" for usado para entrada.

Porque "." estava em uso como um separador de diretório e os nomes dos arquivos não podiam ser considerados
único após 10 caracteres, a Acorn implementou o compilador C para remover o ".c" final
".h" ".s" e ".o" sufixo de nomes de arquivos especificados no código-fonte e armazenar os respectivos
arquivos em subdiretórios nomeados após o sufixo. Portanto, os arquivos são traduzidos:

foo.h h.foo
C:foo.h C:h.foo (variável de caminho lógico)
sys/os.h sys.h.os (compilador C groks Unix-speak)
10charname.c c.10charname
10charname.o o.10charname
11charname_.c c.11charname (assumindo que o sistema de arquivos trunca em 10)

A tradução de nomes de arquivos da biblioteca de emulação Unix para nativo assume que esse tipo de
tradução é necessária e permite uma lista definida pelo usuário de sufixos conhecidos que serão
transpor desta forma. Isso pode parecer transparente, mas considere que com essas regras
foo/bar/baz.h e foo/bar/h/baz ambos mapeiam para foo.bar.h.baz, e que "readdir" e "glob"
não pode e não tenta emular o mapeamento reverso. Outros "." em nomes de arquivos são
traduzido para "/".

Como implícito acima, o ambiente acessado através de %ENV é global, e a convenção é
que as variáveis ​​de ambiente específicas do programa estejam no formato "Program$Name". Cada
sistema de arquivos mantém um diretório atual e o diretório atual do sistema de arquivos atual
é o global diretório atual. Consequentemente, os programas sociáveis ​​não mudam a atual
diretório, mas dependem de nomes de caminho completos, e programas (e Makefiles) não podem assumir que eles
pode gerar um processo filho que pode alterar o diretório atual sem afetar seu
pai (e todos os outros para esse assunto).

Como os identificadores de arquivos do sistema operacional nativo são globais e estão atualmente alocados
de 255, com 0 sendo um valor reservado, a biblioteca de emulação Unix emula Unix
alças de arquivo. Conseqüentemente, você não pode confiar em passar "STDIN", "STDOUT" ou "STDERR" para
seus filhos.

O desejo dos usuários de expressar nomes de arquivos no formato " .Bar" na linha de comando
unquoted causa problemas também: a captura de saída do comando "``" tem que executar um jogo de adivinhação.
Ele assume que uma string "<[^<>]+\$[^<>]>" é uma referência a uma variável de ambiente,
enquanto qualquer outra coisa envolvendo "<" ou ">" é redirecionamento e geralmente consegue ser 99%
direito. Claro, o problema permanece que os scripts não podem depender de nenhuma ferramenta Unix sendo
disponíveis, ou que quaisquer ferramentas encontradas tenham argumentos de linha de comando do tipo Unix.

Extensões e XS são, em teoria, construíveis por qualquer pessoa usando ferramentas gratuitas. Na prática, muitos
não, pois os usuários da plataforma Acorn estão acostumados a distribuições binárias. MakeMaker faz
run, mas nenhum make disponível atualmente lida com os makefiles do MakeMaker; mesmo se e quando
isso deve ser corrigido, a falta de um shell do tipo Unix causará problemas com o makefile
regras, especialmente linhas do formulário "cd sdbm && make all", e qualquer coisa usando aspas.

"RISC OS" é o nome apropriado para o sistema operacional, mas o valor em $^O é "riscos"
(porque não gostamos de gritar).

Outros pérolas
Perl foi portado para muitas plataformas que não se encaixam em nenhuma das categorias listadas
acima. Alguns, como AmigaOS, QNX, Plan 9 e VOS, foram bem integrados ao
kit de código-fonte Perl padrão. Você pode precisar ver o portas/ diretório no CPAN para
informações e possivelmente binários, como: aos, Atari ST, lynxos, riscos,
Novell Netware, Guardião Tandem, etc. (Sim, sabemos que alguns desses sistemas operacionais podem cair
na categoria Unix, mas não somos um órgão de padrões.)

Alguns nomes de sistemas operacionais aproximados e seus valores $^O na categoria "OTHER"
incluem:

SO $^O $Config{'archname'}
------------------------------------------
Amiga DOS amigos m68k-amigos

Veja também:

· Amiga, README.amiga (instalado como perlamiga).

· Um PERL.NLM gratuito baseado em perl5 para Novell Netware está disponível em binário pré-compilado e
formulário de código-fonte dehttp://www.novell.com/> bem como do CPAN.

· Plano 9, LEIA-ME.plan9

FUNÇÃO IMPLEMENTAÇÕES

Abaixo estão listadas funções que não foram implementadas completamente ou que foram
implementado de forma diferente em várias plataformas. Após cada descrição será, em
parênteses, uma lista de plataformas às quais a descrição se aplica.

A lista pode estar incompleta ou até errada em alguns lugares. Na dúvida, consulte o
arquivos README específicos da plataforma na distribuição fonte Perl e qualquer outro
recursos de documentação que acompanham uma determinada porta.

Esteja ciente, além disso, que mesmo entre os sistemas Unix existem variações.

Para muitas funções, você também pode consultar %Config, exportado por padrão do "Config"
módulo. Por exemplo, para verificar se a plataforma possui a chamada "lstat", verifique
$Config{d_lstat}. Consulte Config para obter uma descrição completa das variáveis ​​disponíveis.

alfabética listagem of Perl Funções
-X "-w" apenas inspeciona o atributo de arquivo somente leitura (FILE_ATTRIBUTE_READONLY), que
determina se o diretório pode ser excluído, não se pode ser gravado.
Os diretórios sempre têm acesso de leitura e gravação, a menos que seja negado por
listas de controle de acesso (DACLs). (Win32)

"-r", "-w", "-x" e "-o" informam se o arquivo está acessível, o que pode não
refletem as proteções de arquivo baseadas em UIC. (VMS)

"-s" por nome em um arquivo aberto retornará o espaço reservado no disco, em vez de
a extensão atual. "-s" em um identificador de arquivo aberto retorna o tamanho atual.
(RISCO OS)

"-R", "-W", "-X", "-O" são indistinguíveis de "-r", "-w", "-x", "-o". (Win32,
VMS, SO RISC)

"-g", "-k", "-l", "-u", "-A" não são particularmente significativos. (Win32, VMS,
SO RISC)

"-p" não é particularmente significativo. (VMS, RISC OS)

"-d" é verdadeiro se passar uma especificação de dispositivo sem um diretório explícito. (VMS)

"-x" (ou "-X") determina se um arquivo termina em um dos sufixos executáveis. "-S"
é sem sentido. (Win32)

"-x" (ou "-X") determina se um arquivo tem um tipo de arquivo executável. (RISCO OS)

alarm Emulado usando temporizadores que devem ser explicitamente pesquisados ​​sempre que Perl quiser
despachar "sinais seguros" e, portanto, não pode interromper o bloqueio de chamadas de sistema.
(Win32)

atan2 Devido a problemas com várias CPUs, bibliotecas matemáticas, compiladores e padrões, os resultados
para "atan2()" pode variar dependendo de qualquer combinação dos itens acima. Perl tentativas
para estar em conformidade com os padrões Open Group/IEEE para os resultados retornados
"atan2()", mas não pode forçar o problema se o sistema Perl é executado não permitir
isto. (Tru64, HP-UX 10.20)

A versão atual dos padrões para "atan2()" está disponível em
<http://www.opengroup.org/onlinepubs/009695399/functions/atan2.html>.

binmode Sem sentido. (RISCO OS)

Reabre o arquivo e restaura o ponteiro; se a função falhar, o filehandle subjacente pode ser
fechado, ou o ponteiro pode estar em uma posição diferente. (VMS)

O valor retornado por "tell" pode ser afetado após a chamada, e o filehandle
pode ser lavado. (Win32)

chmod Apenas bom para alterar o acesso de leitura e gravação do "proprietário", "grupo" e "outros" bits são
sem significado. (Win32)

Só é bom para alterar o acesso de leitura e gravação de "proprietário" e "outro". (RISCO OS)

As permissões de acesso são mapeadas nas alterações da lista de controle de acesso do VOS. (VOS)

As permissões reais definidas dependem do valor do "CYGWIN" no SYSTEM
configurações do ambiente. (Cygwin)

Definir o bit exec em alguns locais (geralmente / cartão SD) retornará true, mas
não realmente definir o bit. (Android)

chown Não implementado. (Win32, Plano 9, RISC OS)

Não faz nada, mas não falha. (Win32)

Um pouco estranho, porque a noção de propriedade da VOS é um pouco estranha (VOS).

chroot Não implementado. (Win32, VMS, Plano 9, RISC OS, VOS)

crypt Pode não estar disponível se a biblioteca ou fonte não foi fornecida ao construir o perl.
(Win32)

Não implementado. (Android)

dbmclose
Não implementado. (VMS, Plano 9, VOS)

dbmopen Não implementado. (VMS, Plano 9, VOS)

despejar Não é útil. (RISCO OS)

Não suportado. (Cygwin, Win32)

Invoca o depurador VMS. (VMS)

exec "exec LIST" sem o uso de sintaxe de objeto indireto ("exec PROGRAM LIST") pode
volte a tentar o shell se o primeiro "spawn()" falhar. (Win32)

Não libera automaticamente os identificadores de saída em algumas plataformas. (SunOS, Solaris,
HP-UX)

Não suportado. (SO Symbian)

exit Emula Unix "exit()" (que considera "exit 1" para indicar um erro) mapeando
o 1 para "SS$_ABORT" (44). Este comportamento pode ser substituído pelo pragma "use
vmsish 'exit'". Assim como a função "exit()" do CRTL, "exit 0" também é mapeado para
um status de saída de "SS$_NORMAL" (1); este mapeamento não pode ser substituído. Qualquer outro
argumento para "exit()" é usado diretamente como o status de saída do Perl. No VMS, a menos que o
o modo POSIX_EXIT futuro está habilitado, o código de saída deve ser sempre uma saída VMS válida
código e não um número genérico. Quando o modo POSIX_EXIT está habilitado, um genérico
número será codificado em um método compatível com a macro _POSIX_EXIT da biblioteca C
para que possa ser decodificado por outros programas, particularmente aqueles escritos em C, como
o pacote GNV. (VMS)

"exit()" redefine ponteiros de arquivo, o que é um problema quando chamado de um processo filho
(criado por "fork()") em "BEGIN". Uma solução alternativa é usar "POSIX::_exit".
(Solaris)

sair a menos que $Config{archname} =~ /\bsolaris\b/;
requerem POSIX e POSIX::_saída(0);

fcntl Não implementado. (Win32)

Algumas funções disponíveis com base na versão do VMS. (VMS)

bando Não implementado (VMS, RISC OS, VOS).

fork Não implementado. (AmigaOS, RISC OS, VMS)

Emulado usando vários intérpretes. Veja perlfork. (Win32)

Não libera automaticamente os identificadores de saída em algumas plataformas. (SunOS, Solaris,
HP-UX)

obter login
Não implementado. (RISCO OS)

getpgrp Não implementado. (Win32, VMS, RISC OS)

getppid Não implementado. (Win32, RISC OS)

obter prioridade
Não implementado. (Win32, VMS, RISC OS, VOS)

getpwnam
Não implementado. (Win32)

Nao é útil. (RISCO OS)

getgranm
Não implementado. (Win32, VMS, RISC OS)

getnetbynome
Não implementado. (Android, Win32, Plano 9)

getpwuid
Não implementado. (Win32)

Nao é útil. (RISCO OS)

começar
Não implementado. (Win32, VMS, RISC OS)

getnetbyaddr
Não implementado. (Android, Win32, Plano 9)

obterprotopornúmero
Não implementado. (Android)

getservbyport
começar
Não implementado. (Android, Win32)

ficar feliz
Não implementado. (Android, Win32, VMS)

gethostbyname
"gethostbyname('localhost')" não funciona em todos os lugares: você pode ter que usar
"gethostbyname('127.0.0.1')". (Irix 5)

gethostent
Não implementado. (Win32)

getnetente
Não implementado. (Android, Win32, Plano 9)

obter protocolo
Não implementado. (Android, Win32, Plano 9)

getervent
Não implementado. (Win32, Plano 9)

seekdir Não implementado. (Android)

sethostente
Não implementado. (Android, Win32, Plano 9, RISC OS)

setnetente
Não implementado. (Win32, Plano 9, RISC OS)

definir protocolo
Não implementado. (Android, Win32, Plano 9, RISC OS)

servente
Não implementado. (Plano 9, Win32, RISC OS)

fim
Não implementado. (Win32)

Ou não implementado ou não operacional. (Android)

final
Não implementado. (Android, RISC OS, VMS, Win32)

endhostent
Não implementado. (Android, Win32)

endnetente
Não implementado. (Android, Win32, Plano 9)

protocolo final
Não implementado. (Android, Win32, Plano 9)

Endervent
Não implementado. (Plano 9, Win32)

getockopt SOCKET,LEVEL,OPTNAME
Não implementado. (Plano 9)

glob Este operador é implementado através da extensão "File::Glob" na maioria das plataformas.
Consulte File::Glob para obter informações de portabilidade.

gmtime Em teoria, "gmtime()" é confiável de -2**63 a 2**63-1. No entanto, porque o trabalho
voltas na implementação usam números de ponto flutuante, ele se tornará
impreciso à medida que o tempo aumenta. Este é um bug e será corrigido no
futuro.

No VOS, os valores de tempo são quantidades de 32 bits.

ioctl FILEHANDLE, FUNÇÃO, ESCALAR
Não implementado. (VMS)

Disponível apenas para alças de soquete, e faz o que o "ioctlsocket()" chama em
a API Winsock faz. (Win32)

Disponível apenas para alças de soquete. (RISCO OS)

kill Não implementado, portanto, não é útil para verificação de contaminação. (RISCO OS)

"kill()" não tem a semântica de "raise()", ou seja, não envia um sinal para
o processo identificado como nas plataformas Unix. Em vez disso, "kill($sig, $pid)"
termina o processo identificado por $pid e o faz sair imediatamente com exit
estado $ sig. Como no Unix, se $sig for 0 e o processo especificado existir, ele
retorna true sem realmente encerrá-lo. (Win32)

"kill(-9, $pid)" encerrará o processo especificado por $pid e recursivamente todos
processos filhos de sua propriedade. Isso é diferente da semântica do Unix, onde o
sinal será entregue a todos os processos no mesmo grupo de processos que o processo
especificado por $pid. (Win32)

Não há suporte para número de identificação de processo de 0 ou números negativos. (VMS)

link Não implementado. (RISC OS, VOS)

A contagem de links não foi atualizada porque os links físicos não são tão difíceis (Eles são classificados
de meio caminho entre os links físicos e flexíveis). (Amiga OS)

Os links físicos são implementados no Win32 apenas em NTFS. Eles são suportados nativamente
no Windows 2000 e posterior. No Windows NT eles são implementados usando o Windows
O suporte ao subsistema POSIX e o processo Perl precisarão de Administrador ou Backup
Privilégios de operador para criar links físicos.

Disponível no OpenVMS 64 de 8.2 bits e posterior. (VMS)

horário local
horário local() tem o mesmo intervalo que "gmtime", mas como as regras de fuso horário alteram sua
precisão para tempos históricos e futuros pode diminuir, mas geralmente não mais do que
uma hora.

lstat Não implementado. (RISCO OS)

Os valores de retorno (especialmente para dispositivo e inode) podem ser falsos. (Win32)

msgctl
mensagem
mensagem
msgrcv Não implementado. (Android, Win32, VMS, Plano 9, RISC OS, VOS)

abra aberto para "|-" e "-|" não são suportados. (Win32, RISC OS)

A abertura de um processo não libera automaticamente os identificadores de saída em algumas plataformas.
(SunOS, Solaris, HP-UX)

link de leitura
Não implementado. (Win32, VMS, RISC OS)

renomear Não é possível mover diretórios entre diretórios em diferentes volumes lógicos. (Win32)

retroceder
Não fará com que "readdir()" leia novamente o fluxo de diretório. As entradas já
lido antes da chamada "rewinddir()" será retornado novamente de um cache
amortecedor. (Win32)

selecione Implementado apenas em soquetes. (Win32, VMS)

Apenas confiável em soquetes. (RISCO OS)

Observe que o formulário "selecionar FILEHANDLE" geralmente é portátil.

semctl
semget
semop Não implementado. (Android, Win32, VMS, RISC OS)

Setgrent
Não implementado. (Android, VMS, Win32, RISC OS)

setpgrp Não implementado. (Win32, VMS, RISC OS, VOS)

prioridade
Não implementado. (Win32, VMS, RISC OS, VOS)

setpwent
Não implementado. (Android, Win32, RISC OS)

setockopt
Não implementado. (Plano 9)

shmctl
merda
shmread
escrever
Não implementado. (Android, Win32, VMS, RISC OS)

sleep Emulado usando funções de sincronização de modo que possa ser interrompido por
"alarm()" e limitado a um máximo de 4294967 segundos, aproximadamente 49 dias.
(Win32)

marca de meia
Uma adição relativamente recente às funções de soquete, pode não ser implementada mesmo em
Plataformas Unix.

par de tomadas
Não implementado. (RISCO OS)

Disponível no OpenVMS 64 de 8.2 bits e posterior. (VMS)

stat Plataformas que não possuem rdev, blksize ou blocks irão retornar como '', então
comparação numérica ou manipulação desses campos pode causar 'não numérico'
avisos.

ctime não suportado em UFS (Mac OS X).

ctime é o tempo de criação em vez do tempo de alteração do inode (Win32).

dispositivo e inode não são significativos. (Win32)

device e inode não são necessariamente confiáveis. (VMS)

mtime, atime e ctime retornam a hora da última modificação. Dispositivo e inode
não são necessariamente confiáveis. (RISCO OS)

dev, rdev, blksize e blocks não estão disponíveis. inode não é significativo e
será diferente entre as chamadas de estatísticas no mesmo arquivo. (os2)

algumas versões do cygwin ao fazer um "stat("foo")" e se não encontrá-lo pode então
tente "stat("foo.exe")" (Cygwin)

No Win32 "stat()" precisa abrir o arquivo para determinar a contagem de links e atualizar
atributos que podem ter sido alterados por meio de links físicos. Contexto
"${^WIN32_SLOPPY_STAT}" para um valor verdadeiro acelera "stat()" por não realizar isso
Operação. (Win32)

link simbólico Não implementado. (Win32, RISC OS)

Implementado em VMS 64 de 8.3 bits. O VMS requer que o link simbólico esteja no Unix
sintaxe se pretende resolver para um caminho válido.

syscall Não implementado. (Win32, VMS, RISC OS, VOS)

sysopen Os modos tradicionais "0", "1" e "2" são implementados com diferentes
valores em alguns sistemas. Os sinalizadores exportados por "Fcntl" (O_RDONLY, O_WRONLY,
O_RDWR) deve funcionar em todos os lugares. (Mac OS, OS/390)

system Como uma otimização, não pode chamar o shell de comando especificado em $ENV{PERL5SHELL}.
"system(1, @args)" gera um processo externo e retorna imediatamente seu processo
designador, sem esperar que termine. O valor de retorno pode ser usado
posteriormente em "wait" ou "waitpid". A falha em "spawn()" um subprocesso é
indicado pela configuração $? para "255 << 8". $? está definido de forma compatível com Unix
(ou seja, o status de saída do subprocesso é obtido por ""$? " 8">>, conforme descrito em
a documentação). (Win32)

Não há shell para processar metacaracteres, e o padrão nativo é passar um
linha de comando terminada por "\n" "\r" ou "\0" para o programa gerado. Redirecionamento
como "> foo" é executado (se for o caso) pela biblioteca de tempo de execução do spawned
programa. "sistema" Lista chamará a emulação "exec" da biblioteca de emulação Unix,
que tenta fornecer emulação do stdin, stdout, stderr em vigor no
pai, desde que o programa filho use uma versão compatível da emulação
biblioteca. escalar chamará a linha de comando nativa direta e nenhuma emulação de
um programa filho Unix existirá. Quilometragem precisarão variar. (RISCO OS)

"system LIST" sem o uso de sintaxe de objeto indireto ("system PROGRAM LIST")
pode voltar a tentar o shell se o primeiro "spawn()" falhar. (Win32)

Não libera automaticamente os identificadores de saída em algumas plataformas. (SunOS, Solaris,
HP-UX)

O valor de retorno é semelhante ao POSIX (deslocado em 8 bits), o que permite apenas espaço para
um valor inventado derivado dos bits de gravidade do código de condição nativo de 32 bits
(a menos que substituído por "use vmsish 'status'"). Se o código de condição nativo for um
que possui um valor POSIX codificado, o valor POSIX será decodificado para extrair o
valor de saída esperado. Para obter mais detalhes, consulte "$?" em perlvms. (VMS)

telldir Não implementado. (Android)

vezes os tempos "cumulativos" serão falsos. Em qualquer coisa que não seja Windows NT ou Windows
2000, a hora do "sistema" será falsa e a hora do "usuário" é na verdade a hora retornada
pela função "clock()" na biblioteca de tempo de execução C. (Win32)

Nao é útil. (RISCO OS)

truncar
Não implementado. (Versões mais antigas do VMS)

Truncamento apenas para comprimentos iguais ou menores. (VOS)

Se um FILEHANDLE for fornecido, ele deve ser gravável e aberto no modo de acréscimo (ou seja,
use "open(FH, '>>filename')" ou "sysopen(FH,...,O_APPEND|O_RDWR)". Se um nome de arquivo
é fornecido, não deve ser mantido aberto em outro lugar. (Win32)

umask Retorna undef onde não está disponível.

"umask" funciona, mas as permissões corretas são definidas apenas quando o arquivo é finalmente
fechado. (Amiga OS)

utime Somente a hora da modificação é atualizada. (VMS, RISC OS)

Pode não se comportar como esperado. O comportamento depende da biblioteca de tempo de execução C
implementação de "utime()", e o sistema de arquivos que está sendo usado. O sistema de arquivos FAT
normalmente não oferece suporte a um campo "tempo de acesso" e pode limitar os carimbos de data/hora a
uma granularidade de dois segundos. (Win32)

esperar
waitpid Só pode ser aplicado a identificadores de processo retornados para processos gerados usando
"system(1, ...)" ou pseudo processos criados com "fork()". (Win32)

Nao é útil. (RISCO OS)

Suportado Desafios

As seguintes plataformas são conhecidas por construir Perl 5.12 (a partir de abril de 2010, sua data de lançamento)
da distribuição de código-fonte padrão disponível emhttp://www.cpan.org/src>

Linux (x86, ARM, IA64)
HP-UX
AIX
Win32
Windows 2000
Windows XP
Servidor 2003 do Windows
Windows Vista
Servidor 2008 do Windows
Windows 7
Cygwin
Alguns testes são conhecidos por falhar:

· ext/XS-APItes/t/call_checker.t - Vejo


· dist/I18N-Collate/t/I18N-Collate.t

· ext/Win32CORE/t/win32core.t - pode falhar em instalações recentes do cygwin.

Solaris (x86, SPARC)
OpenVMS
Alfa (7.2 e posterior)
I64 (8.2 e posterior)
Symbian
NetBSD
FreeBSD
Debian GNU / kFreeBSD
Haiku
Irix (6.5. O que mais?)
OpenBSD
Libélula BSD
BSD da meia-noite
QNX Neutrino RTOS (6.5.0)
BSD do MirOS
Stratus OpenVOS (17.0 ou posterior)
Ressalvas:

problemas de time_t que podem ou não ser corrigidos
Symbian (Série 60 v3, 3.2 e 5 - o que mais?)
StratusVOS/OpenVOS
AIX
Android
GrátisMINT
Perl agora compila com FreeMiNT/Atari. Ele falha em alguns testes, que precisa de alguns
investigação.

A porta FreeMiNT usa GNU dld para recursos de módulos carregáveis. Então certifique-se de ter
essa biblioteca instalada ao construir o perl.

EOL Desafios

(Perl 5.20)
As seguintes plataformas eram suportadas por uma versão anterior do Perl, mas foram
oficialmente removido do código-fonte do Perl a partir de 5.20:

AT&T 3b1

(Perl 5.14)
As seguintes plataformas foram suportadas até 5.10. Eles ainda podem ter funcionado em 5.12,
mas o código de suporte foi removido para 5.14:

Windows 95
Windows 98
Windows ME
Windows NT4

(Perl 5.12)
As seguintes plataformas eram suportadas por uma versão anterior do Perl, mas foram
oficialmente removido do código-fonte do Perl a partir de 5.12:

Atari MinT
Domínio/SO Apollo
AppleMac OS 8/9
Tenon Machten

Suportado Desafios (Perl 5.8)

Em julho de 2002 (versão Perl 5.8.0), as seguintes plataformas foram capazes de construir Perl
da distribuição de código-fonte padrão disponível emhttp://www.cpan.org/src/>

AIX
Beos
BSD/OS (BSDi)
Cygwin
DG / UX
DOS DJGPP 1)
DYNIX/ptx
EPOC R5
FreeBSD
HI-UXMPP (Hitachi) (5.8.0 funcionou, mas não sabíamos)
HP-UX
IRIX
Linux
Mac OS Clássico
Mac OS X (Darwin)
MPE / iX
NetBSD
Netware
NonStop-UX
ReliantUNIX (anteriormente SINIX)
OpenBSD
OpenVMS (anteriormente VMS)
Abra UNIX (Unixware) (desde Perl 5.8.1/5.9.0)
OS / 2
OS/400 (usando o PASE) (desde Perl 5.8.1/5.9.0)
PowerUX
POSIX-BC (anteriormente BS2000)
QNX
Solaris
Sun OS 4
SUPER-UX (NEC)
Tru64 UNIX (anteriormente DEC OSF/1, Digital UNIX)
EXCLUSIVO
UNICOS / mk
UTS
VOS / Open VOS
Win95/98/ME/2K/XP 2)
WinCE
z/OS (anteriormente OS/390)
VM / ESA

1) no modo DOS, as portas DOS ou OS/2 podem ser usadas
2) compiladores: Borland, MinGW (GCC), VC6

As seguintes plataformas funcionaram com as versões anteriores (5.6 e 5.7), mas não
consiga corrigi-los ou testá-los a tempo da versão 5.8.0. Existe um muito bom
chance de que muitos deles funcionem bem com o 5.8.0.

BSD / OS
DomínioOS
Hurd
lynxOS
MachTen
PowerMAX
SCO SV
SVR4
Unixware
Windows 3.1

Conhecido por ser quebrado para 5.8.0 (mas 5.6.1 e 5.7.2 podem ser usados):

Amiga OS

As seguintes plataformas foram conhecidas por compilar Perl a partir da fonte no passado (5.005_03
e anteriores), mas não conseguimos verificar seu status para a versão atual,
seja porque as plataformas de hardware/software são raras ou porque não temos um
campeão nessas plataformas - ou ambos. Eles costumavam trabalhar, então vá em frente e tente
compilando-os, e deixe [email protected] de qualquer problema.

3b1
A / UX
Sistema operacional convexo
CX/UX
DC/OSx
DDE PMES
DOSEMX
Dynix
EP/IX
ESIX
FPS
GÊNIX
Colinas verdes
ISC
Mach Ten 68k
MPC
NOTÍCIAS-OS
Próxima Etapa
OpenSTEP
Opus
plano de 9
RISC/os
SCO ODT/OSR
Stellar
SVR2
TI1500
Titan OS
Ultrix
Unisys Dynix

As seguintes plataformas têm suas próprias distribuições de código-fonte e binários disponíveis
através dahttp://www.cpan.org/ports/>

Versão Perl

OS/400 (ILE)5.005_02
Guardião Tandem 5.004

As seguintes plataformas têm apenas binários disponíveis via
<http://www.cpan.org/ports/index.html>:

Versão Perl

Bolota RISCOS 5.005_02
AOS 5.002
Lynx OS 5.004_02

Embora sugerimos que você sempre construa seu próprio Perl a partir do código-fonte, tanto para
máxima configurabilidade e por segurança, caso esteja com pressa pode verificar
<http://www.cpan.org/ports/index.html> para distribuições binárias.

Use perlport online usando serviços onworks.net