perldiag - Online sa Cloud

PROGRAMA:

NAME

perldiag - iba't ibang Perl diagnostics

DESCRIPTION

Ang mga mensaheng ito ay inuri bilang mga sumusunod (nakalista sa pagtaas ng pagkakasunud-sunod ng desperasyon):

(W) Isang babala (opsyonal).
(D) Isang paghinto sa paggamit (pinagana bilang default).
(S) Isang matinding babala (pinagana bilang default).
(F) Isang nakamamatay na pagkakamali (nakulong).
(P) Isang panloob na error na hindi mo dapat makita (nakulong).
(X) Isang napaka-fatal na error (nontrappable).
(A) Isang alien na mensahe ng error (hindi nabuo ni Perl).

Ang karamihan ng mga mensahe mula sa unang tatlong klasipikasyon sa itaas (W, D & S) ay maaaring
kinokontrol gamit ang "mga babala" na pragma.

Kung ang isang mensahe ay maaaring kontrolin ng "mga babala" na pragma, ang kategorya ng babala nito ay kasama
kasama ang liham ng pag-uuri sa paglalarawan sa ibaba. Hal. "(W closed)" ay nangangahulugang a
babala sa kategoryang "sarado".

Ang mga opsyonal na babala ay pinagana sa pamamagitan ng paggamit ng "mga babala" na pragma o ang -w at -W switch.
Maaaring makuha ang mga babala sa pamamagitan ng pagtatakda ng $SIG{__WARN__} sa isang reference sa isang routine na gagawin
tawagin sa bawat babala sa halip na i-print ito. Tingnan ang perlvar.

Palaging pinapagana ang matitinding babala, maliban kung tahasang hindi pinagana ang mga ito sa
"babala" pragma o ang -X Lumipat.

Maaaring ma-trap ang mga na-trap na error gamit ang eval operator. Tingnan ang "eval" sa perlfunc. Sa
halos lahat ng kaso, ang mga babala ay maaaring piliing hindi pinagana o i-promote sa nakamamatay na mga error sa paggamit
ang "mga babala" pragma. Tingnan ang mga babala.

Ang mga mensahe ay nasa alphabetical order, nang walang pagsasaalang-alang sa upper o lower-case. Ilan sa
generic ang mga mensaheng ito. Ang mga spot na nag-iiba ay tinutukoy ng %s o iba pang printf-style
pagtakas. Ang mga pagtakas na ito ay binabalewala ng alpabetikong pagkakasunud-sunod, gayundin ang iba pang mga character
kaysa sa mga titik. Upang hanapin ang iyong mensahe, huwag pansinin ang anumang bagay na hindi isang sulat.

tanggapin () sa saradong socket %s
(W closed) Sinubukan mong gumawa ng accept sa isang closed socket. Nakalimutan mo bang suriin ang
ibalik ang halaga ng iyong socket () tumawag? Tingnan ang "tanggapin" sa perlfunc.

Ang Aliasing sa pamamagitan ng sanggunian ay eksperimental
(S experimental::refaliasing) Ang babalang ito ay inilalabas kung gagamit ka ng reference
constructor sa kaliwang bahagi ng isang pagtatalaga sa alias ng isang variable sa isa pa.
Pigilan lang ang babala kung gusto mong gamitin ang feature, ngunit alamin na sa paggawa nito
nanganganib kang gumamit ng isang pang-eksperimentong tampok na maaaring magbago o maging
inalis sa hinaharap na bersyon ng Perl:

walang babala "experimental::refaliasing";
gamitin ang tampok na "refaliasing";
\$x = \$y;

Masyadong malaki ang alokasyon: %x
(X) Hindi ka maaaring maglaan ng higit sa 64K sa isang MS-DOS machine.

Pinapayagan lang ang '%c' pagkatapos ng mga uri ng %s sa %s
(F) Ang mga modifier na '!', '<' at '>' ay pinahihintulutan pack() or i-unpack() pagkatapos lamang
ibang mga klase. Tingnan ang "pack" sa perlfunc.

Nalutas ang hindi maliwanag na tawag bilang CORE::%s(), maging kwalipikado bilang ganoon o gumamit ng &
(W ambiguous) Ang isang subroutine na iyong idineklara ay may parehong pangalan bilang isang Perl na keyword, at
ginamit mo ang pangalan nang walang kwalipikasyon para sa pagtawag sa isa o sa isa pa. Perl
nagpasya na tawagan ang builtin dahil ang subroutine ay hindi na-import.

Para pilitin ang interpretasyon bilang subroutine na tawag, maglagay ng ampersand bago ang
pangalan ng subroutine, o gawing kwalipikado ang pangalan kasama ng package nito. Bilang kahalili, maaari kang mag-import
ang subroutine (o magpanggap na ito ay na-import gamit ang "use subs" pragma).

Upang tahimik na bigyang-kahulugan ito bilang Perl operator, gamitin ang prefix na "CORE::" sa operator
(hal. "CORE::log($x)") o ideklara ang subroutine bilang object method (tingnan ang
"Mga Subroutine na Katangian" sa perlsub o mga katangian).

Hindi maliwanag na hanay sa transliteration operator
(F) Sumulat ka ng isang bagay tulad ng "tr/az-0//" na wala talagang ibig sabihin. Upang
magsama ng "-" na character sa isang transliterasyon, ilagay ito sa una o huli. (Nasa
nakaraan, ang "tr/az-0//" ay kasingkahulugan ng "tr/ay//", na malamang na hindi mo
sana ay inaasahan.)

Nalutas ang hindi maliwanag na paggamit ng %s bilang %s
(S ambiguous) May sinabi ka na maaaring hindi mabigyang-kahulugan sa paraang iniisip mo.
Karaniwan ay medyo madaling i-disambiguate ito sa pamamagitan ng pagbibigay ng nawawalang quote, operator,
pares o deklarasyon ng panaklong.

Ang hindi maliwanag na paggamit ng -%s ay nalutas bilang -&%s()
(S ambiguous) Sumulat ka ng isang bagay tulad ng "-foo", na maaaring ang string na "-foo", o isang
tawag sa function na "foo", negated. Kung sinadya mo ang string, isulat lang ang "-foo". Kung
ibig mong sabihin ang function na tawag, isulat ang "-foo()".

Nalutas ang hindi maliwanag na paggamit ng %c bilang operator %c
(S ambiguous) "%", "&", at "*" ay parehong infix operator (modulus, bitwise at, at
pagpaparami) at mga paunang espesyal na character (nagsasaad ng mga hash, subroutine at
typeglobs), at sinabi mo ang isang bagay tulad ng "*foo * foo" na maaaring bigyang-kahulugan bilang
alinman sa kanila. Ipinapalagay namin na ang infix operator ang ibig mong sabihin, ngunit mangyaring subukang gawin ito
mas malinaw -- sa ibinigay na halimbawa, maaari mong isulat ang "*foo * foo()" kung talagang sinadya mo
upang i-multiply ang isang glob sa resulta ng pagtawag sa isang function.

Nalutas ang hindi maliwanag na paggamit ng %c{%s} sa %c%s
(W ambiguous) Sumulat ka ng isang bagay tulad ng "@{foo}", na maaaring humihingi ng
variable @foo, o maaaring ito ay tumatawag sa isang function na pinangalanang foo, at dereferencing ito bilang isang
sanggunian ng array. Kung gusto mo ang variable, maaari mo lamang isulat ang @foo. Kung gusto mo
para tawagan ang function, isulat ang "@{foo()}" ... o maaaring wala ka lang variable at a
function na may parehong pangalan, at i-save ang iyong sarili ng maraming problema.

Nalutas ang hindi maliwanag na paggamit ng %c{%s[...]} sa %c%s[...]
Nalutas ang hindi maliwanag na paggamit ng %c{%s{...}} sa %c%s{...}
(W ambiguous) Sumulat ka ng isang bagay tulad ng "${foo[2]}" (kung saan kinakatawan ng foo ang pangalan ng isang
Perl keyword), na maaaring naghahanap ng element number 2 ng array na pinangalanang @foo, in
kung anong kaso mangyaring sumulat ng $foo[2], o maaaring sinadya mong magpasa ng hindi kilalang arrayref
sa function na pinangalanang foo, at pagkatapos ay gumawa ng scalar deref sa halaga na ibinabalik nito. kung ikaw
ibig sabihin, isulat ang "${foo([2])}".

Sa mga regular na expression, ang "${foo[2]}" syntax ay minsan ay kinakailangan upang i-disambiguate
sa pagitan ng mga subscript ng array at mga klase ng character. "/$length[2345]/", halimbawa, ay
bigyang-kahulugan bilang $length na sinusundan ng klase ng character na "[2345]". Kung isang array
subscript ang gusto mo, maiiwasan mo ang babala sa pamamagitan ng pagbabago ng "/${length[2345]}/"
sa hindi magandang tingnan na "/${\$length[2345]}/", sa pamamagitan ng pagpapalit ng pangalan ng iyong array sa isang bagay na
hindi tumutugma sa isang built-in na keyword, o sa pamamagitan lamang ng pag-off ng mga babala na may "hindi
mga babala 'malabo';".

'|' at '<' ay maaaring hindi parehong tinukoy sa command line
(F) Isang error na kakaiba sa VMS. Gumagawa ang Perl ng sarili nitong pag-redirect ng command line, at natagpuan
na ang STDIN ay isang pipe, at sinubukan mo ring i-redirect ang STDIN gamit ang '<'. Isa lang
STDIN stream sa isang customer, pakiusap.

'|' at '>' ay maaaring hindi parehong tinukoy sa command line
(F) Isang error na kakaiba sa VMS. Gumagawa si Perl ng sarili nitong pag-redirect ng command line, at nag-iisip
sinubukan mong i-redirect ang stdout pareho sa isang file at sa isang pipe sa isa pang command. Ikaw
kailangang pumili ng isa o sa iba, kahit na walang pumipigil sa iyo na mag-pipe sa isang
program o Perl script na 'naghahati' ng output sa dalawang stream, gaya ng

open(OUT,">$ARGV[0]") o mamatay na "Hindi magsulat sa $ARGV[0]: $!";
habang ( ) {
i-print;
i-print OUT;
}
isara OUT;

Ang paglalapat ng %s sa %s ay gagana sa scalar(%s)
(W misc) Ang pattern na tugma ("//"), pagpapalit ("s///"), at transliterasyon
Gumagana ang mga operator ng ("tr///") sa mga scalar value. Kung ilalapat mo ang isa sa mga ito sa isang array o a
hash, iko-convert nito ang array o hash sa isang scalar value (ang haba ng isang array, o
ang impormasyon ng populasyon ng isang hash) at pagkatapos ay magtrabaho sa scalar value na iyon. Ito ay malamang
hindi ang ibig mong gawin. Tingnan ang "grep" sa perlfunc at "map" sa perlfunc para sa
mga kahalili.

Arg masyadong maikli para sa msgsnd
(F) msgsnd() nangangailangan ng isang string ng hindi bababa sa kasing haba ng sizeof(long).

Ang argumentong "%s" ay hindi numeric%s
(W numeric) Ang ipinahiwatig na string ay ipinakain bilang isang argumento sa isang operator na inaasahang a
numerong halaga sa halip. Kung ikaw ay mapalad ang mensahe ay makikilala kung aling operator
ay napakalungkot.

Tandaan na para sa "Inf" at "NaN" (infinity at hindi-isang-number) ang kahulugan ng
Ang "numeric" ay medyo hindi karaniwan: ang mga string mismo (tulad ng "Inf") ay isinasaalang-alang
numeric, at anumang sumusunod sa kanila ay itinuturing na hindi numeric.

Hindi sarado ang listahan ng argumento para sa PerlIO layer na "%s"
(W layer) Kapag nagtulak ng layer na may mga argumento papunta sa Perl I/O system nakalimutan mo ang
) na nagsasara ng listahan ng argumento. (Ang mga layer ay nangangalaga sa pagbabago ng data sa pagitan ng
panlabas at panloob na mga representasyon.) Huminto si Perl sa pag-parse ng listahan ng layer dito
point at hindi sinubukang itulak ang layer na ito. Kung ang iyong programa ay hindi tahasan
humiling ng bagsak na operasyon, maaaring ito ay resulta ng halaga ng kapaligiran
variable na PERLIO.

Ang argumentong "%s" ay itinuturing bilang 0 sa pagtaas (++)
(W numeric) Ang ipinahiwatig na string ay ipinakain bilang argumento sa "++" na operator na
inaasahan ang alinman sa isang numero o isang string na tumutugma sa "/^[a-zA-Z]*[0-9]*\z/". Tingnan ang "Auto-
increment at Auto-deccrement" sa perlop para sa mga detalye.

nabigo ang paninindigan: %s
(X) Ang malloc package na kasama ng Perl ay nagkaroon ng internal failure.

Nabigo ang paninindigang %s: file "%s", linya %d
(X) Nabigo ang isang pangkalahatang assertion. Ang file na pinag-uusapan ay dapat suriin.

Ang nakatalagang halaga ay hindi isang sanggunian
(F) Sinubukan mong magtalaga ng isang bagay na hindi isang sanggunian sa isang sanggunian sa halaga
(hal., "\$x = $y"). Kung sinadya mong gawing alyas ang $x sa $y, gamitin ang "\$x = \$y".

Ang nakatalagang halaga ay hindi %s reference
(F) Sinubukan mong magtalaga ng reference sa isang reference constructor, ngunit ang dalawang reference
ay hindi sa parehong uri. Hindi ka maaaring mag-alyas ng isang scalar sa isang array, o isang array sa isang
hash; dapat magkatugma ang dalawang uri.

\$x = \@y; # error
\@x = \%y; # error
$y = [];
\$x = $y; # error; ibig mong sabihin ay \$y?

Ang pagtatalaga ng hindi zero sa $[ ay hindi na posible
(F) Kapag ang tampok na "array_base" ay hindi pinagana (hal., sa ilalim ng "gamitin ang v5.16;") ang espesyal na
variable na $[, na hindi na ginagamit, ngayon ay isang nakapirming zero value.

Pagtatalaga sa parehong listahan at scalar
(F) Kung magtatalaga ka sa isang conditional operator, ang 2nd at 3rd argument ay dapat alinman
parehong mga scalar o pareho ay mga listahan. Kung hindi, hindi malalaman ni Perl kung aling konteksto ang ibibigay
sa kanang bahagi.

<> sa require-statement ay dapat na mga quotes
(F) Sumulat ka ng "require " kung kailan mo dapat isulat ang "require 'file'".

Subukang i-access ang hindi pinapayagang key na '%s' sa isang pinaghihigpitang hash
(F) Ang bagsak na code ay nagtangkang kumuha o magtakda ng susi na wala sa kasalukuyang hanay
ng mga pinapayagang key ng isang pinaghihigpitang hash.

Subukang pagpalain sa isang libreng pakete
(F) Sumulat ka ng "bless $foo" na may isang argumento pagkatapos na maging sanhi ng kasalukuyang package
upang palayain. Hindi maisip ni Perl kung ano ang gagawin, kaya sumuka ito sa mga kamay sa kawalan ng pag-asa.

Subukang pagpalain sa isang sanggunian
(F) Ang argumento ng CLASSNAME sa pagpalain() operator ay inaasahang ang pangalan ng
package upang pagpalain ang resultang bagay sa. Sa halip ay nagbigay ka ng reference sa
something: baka nagsulat ka

pagpalain ang $sarili, $proto;

kapag sinadya mo

pagpalain ang $sarili, ref($proto) || $proto;

Kung gusto mo talagang mag-bless sa stringified na bersyon ng reference na ibinigay,
kailangan mong i-stringify ito sa iyong sarili, halimbawa sa pamamagitan ng:

pagpalain ang $sarili, "$proto";

Subukang i-clear ang tinanggal na array
(S debugging) Isang array ang itinalaga noong ito ay nililibre. Ang mga pinalayang halaga ay hindi
dapat na nakikita ng Perl code. Maaari rin itong mangyari kung ang XS code ay tumawag sa "av_clear"
mula sa isang custom na magic callback sa array.

Subukang tanggalin ang hindi pinapayagang key na '%s' mula sa isang pinaghihigpitang hash
(F) Tinangka ng bagsak na code na tanggalin mula sa isang pinaghihigpitang hash ang isang key na wala sa
key set nito.

Subukang tanggalin ang readonly na key na '%s' mula sa isang pinaghihigpitang hash
(F) Tinangka ng bagsak na code na tanggalin ang isang key na ang halaga ay idineklara na readonly
mula sa isang pinaghihigpitang hash.

Subukang palayain ang non-arena SV: 0x%x
(S internal) Ang lahat ng SV object ay dapat na inilalaan mula sa mga arena na magiging
mga basurang nakolekta sa labasan. Natuklasan ang isang SV na nasa labas ng alinman sa mga arena na iyon.

Subukang palayain ang hindi umiiral na nakabahaging string na '%s'%s
(S internal) Ang Perl ay nagpapanatili ng isang reference-counted internal table ng mga string upang i-optimize
ang imbakan at pag-access ng mga hash key at iba pang mga string. Ito ay nagpapahiwatig na may sumubok
upang bawasan ang bilang ng sanggunian ng isang string na hindi na makikita sa talahanayan.

Subukang palayain ang temperatura nang maaga: SV 0x%x
(S debugging) Ang mga na-mortal na halaga ay dapat na pinalaya ng free_tmps() gawain.
Ito ay nagpapahiwatig na may iba pang nagpapalaya sa SV bago ang free_tmps() karaniwan
nakakakuha ng pagkakataon, na nangangahulugang ang free_tmps() routine ay magiging freeing an
unreferenced scalar kapag sinubukan nitong palayain ito.

Subukang magbakante ng mga hindi naka-reference na glob pointer
(S internal) Ang mga bilang ng sanggunian ay nasira sa mga alyas ng simbolo.

Pagtatangkang palayain ang hindi natukoy na scalar: SV 0x%x
(S internal) Binawasan ni Perl ang bilang ng sanggunian ng isang scalar upang makita kung gagawin nito
pumunta sa 0, at natuklasan na napunta na ito sa 0 kanina, at dapat na
pinalaya, at sa katunayan, malamang ay napalaya. Ito ay maaaring magpahiwatig na SvREFCNT_dec() ay
tumawag ng masyadong maraming beses, o iyon SvREFCNT_inc() ay tinawag masyadong ilang beses, o na ang SV
ay na-mortal noong hindi ito dapat, o nasira ang alaalang iyon.

Subukang mag-pack ng pointer sa pansamantalang halaga
(W pack) Sinubukan mong magpasa ng pansamantalang halaga (tulad ng resulta ng isang function, o a
computed expression) sa "p" pack() template. Nangangahulugan ito na ang resulta ay naglalaman ng a
pointer sa isang lokasyon na maaaring maging invalid anumang oras, kahit na bago matapos ang
kasalukuyang pahayag. Gumamit ng mga literal o pandaigdigang halaga bilang mga argumento sa "p" pack()
template upang maiwasan ang babalang ito.

Na-abort ang pagtatangkang i-reload ang %s.
(F) Sinubukan mong mag-load ng file na may "use" o "require" na nabigong mag-compile nang isang beses
na. Hindi susubukan ng Perl na i-compile muli ang file na ito maliban kung tatanggalin mo ang entry nito
mula sa %INC. Tingnan ang "require" sa perlfunc at "%INC" sa perlvar.

Subukang itakda ang haba ng napalayang array
(W misc) Sinubukan mong itakda ang haba ng isang array na na-freeze. Maaari mong gawin
ito sa pamamagitan ng pag-iimbak ng reference sa scalar na kumakatawan sa huling index ng isang array at
mamaya pagtatalaga sa pamamagitan ng sanggunian na iyon. Halimbawa

$r = gawin {my @a; \$#a};
$$r = 503

Subukang gumamit ng reference bilang lvalue sa substr
(W substr) Nagbigay ka ng reference bilang unang argumento sa substr() ginamit bilang isang
lvalue, na medyo kakaiba. Marahil ay nakalimutan mong i-dereference muna ito. Tingnan mo
"substr" sa perlfunc.

Ang katangiang "naka-lock" ay hindi na ginagamit
(D hindi na ginagamit) Ginamit mo ang mga attribute na pragma upang baguhin ang "naka-lock" na katangian sa
isang code reference. Ang :locked attribute ay hindi na ginagamit, ay walang epekto mula noong 5005
ang mga thread ay inalis, at aalisin sa hinaharap na release ng Perl 5.

Itinatapon ng attribute prototype(%s) ang naunang katangian ng prototype sa parehong sub
(W misc) Isang sub ang idineklara bilang sub foo : prototype(A) : prototype(B) {}, halimbawa.
Dahil ang bawat sub ay maaari lamang magkaroon ng isang prototype, ang (mga) naunang deklarasyon ay itatapon
habang ang huli ay inilapat.

Ang katangiang "natatangi" ay hindi na ginagamit
(D hindi na ginagamit) Ginamit mo ang mga attribute na pragma para baguhin ang "natatanging" attribute sa
isang array, hash o scalar na sanggunian. Ang :unique attribute ay wala nang epekto simula noon
Perl 5.8.8, at aalisin sa hinaharap na release ng Perl 5.

Tumawag si av_reify sa tied array
(S debugging) Ito ay nagpapahiwatig na may nangyaring mali at nakuha ni Perl napaka lito
tungkol sa @_ o @DB::args na nakatali.

Hindi magandang haba ng arg para sa %s, ay %u, dapat ay %d
(F) Nagpasa ka ng buffer ng maling laki sa isa sa msgctl(), semctl() or shmctl().
Sa C parlance, ang mga tamang sukat ay, ayon sa pagkakabanggit, sizeof(struct msqid_ds *),
sizeof(struct semid_ds *), at sizeof(struct shmid_ds *).

Hindi magandang evalled na pattern ng pagpapalit
(F) Ginamit mo ang switch na "/e" upang suriin ang kapalit para sa isang pagpapalit, ngunit
Nakahanap si perl ng syntax error sa code na susuriin, malamang na isang hindi inaasahang karapatan
brace '}'.

Masamang filehandle: %s
(F) Isang simbolo ang ipinasa sa isang bagay na nagnanais ng filehandle, ngunit ang simbolo ay walang
filehandle na nauugnay dito. Marahil ay hindi mo ginawa ang isang bukas(), o ginawa ito sa iba
Pakete.

Masama libre() ignorado
(S malloc) Isang panloob na gawain na tinatawag libre() sa isang bagay na hindi pa nangyari
malloc ()ed sa unang lugar. Mandatory, ngunit maaaring hindi paganahin sa pamamagitan ng pagtatakda ng kapaligiran
variable na "PERL_BADFREE" hanggang 0.

Ang mensaheng ito ay madalas na makikita sa DB_File sa mga system na may "hard" dynamic
pag-link, tulad ng "AIX" at "OS/2". Ito ay isang bug ng "Berkeley DB" na hindi napapansin
kung ang "DB" ay gumagamit mapagpatawad sistema malloc ().

Masamang hash
(P) Ang isa sa mga internal na hash routine ay naipasa sa isang null HV pointer.

Masama ang pagkakalagay ng mga ().
(A) Hindi mo sinasadyang napatakbo ang iyong script csh sa halip na Perl. Suriin ang #!
linya, o manu-manong i-feed ang iyong script sa Perl mismo.

Masamang pangalan pagkatapos ng %s
(F) Sinimulan mong pangalanan ang isang simbolo sa pamamagitan ng paggamit ng package prefix, at pagkatapos ay hindi mo natapos ang
simbolo. Sa partikular, hindi ka maaaring mag-interpolate sa labas ng mga quote, kaya

$var = 'myvar';
$sym = mypack::$var;

ay hindi pareho

$var = 'myvar';
$sym = "mypack::$var";

Hindi magandang plugin na nakakaapekto sa keyword na '%s'
(F) Ang isang extension na gumagamit ng mekanismo ng keyword na plugin ay lumabag sa plugin API.

Masama realloc() ignorado
(S malloc) Isang panloob na gawain na tinatawag realloc() sa isang bagay na hindi pa nangyari
malloc ()ed sa unang lugar. Mandatory, ngunit maaaring hindi paganahin sa pamamagitan ng pagtatakda ng
environment variable na "PERL_BADFREE" hanggang 1.

Masamang simbolo para sa array
(P) Isang panloob na kahilingan ang hiniling na magdagdag ng array entry sa isang bagay na hindi isang simbolo
pagpasok sa mesa.

Masamang simbolo para sa dirhandle
(P) Isang panloob na kahilingan ang humiling na magdagdag ng dirhandle na entry sa isang bagay na hindi a
simbolo ng pagpasok ng talahanayan.

Masamang simbolo para sa filehandle
(P) Isang panloob na kahilingan ang humiling na magdagdag ng isang filehandle entry sa isang bagay na hindi a
simbolo ng pagpasok ng talahanayan.

Masamang simbolo para sa hash
(P) Isang panloob na kahilingan ang humiling na magdagdag ng hash entry sa isang bagay na hindi isang simbolo
pagpasok sa mesa.

Masamang simbolo para sa scalar
(P) Isang panloob na kahilingan ang humiling na magdagdag ng scalar entry sa isang bagay na hindi isang simbolo
pagpasok sa mesa.

Ang bareword ay matatagpuan sa kondisyon
(W bareword) Nakahanap ang compiler ng bareword kung saan inaasahan nito ang isang kondisyon, na
madalas na nagpapahiwatig na ang isang || o && ay na-parse bilang bahagi ng huling argumento ng
nakaraang konstruksyon, halimbawa:

buksan ang FOO || mamatay;

Maaari rin itong magpahiwatig ng maling spelling na pare-pareho na na-interpret bilang isang bareword:

gumamit ng pare-parehong TYPO => 1;
if (TYOP) { print "foo" }

Ang "mahigpit" na pragma ay kapaki-pakinabang sa pag-iwas sa gayong mga pagkakamali.

Hindi pinapayagan ang bareword na "%s" habang ginagamit ang "mahigpit na subs".
(F) Gamit ang "mahigpit na subs" na ginagamit, ang isang bareword ay pinapayagan lamang bilang isang subroutine identifier,
sa mga kulot na bracket o sa kaliwa ng "=>" na simbolo. Marahil ay kailangan mong ideklara ang isang
subroutine?

Ang bareword na "%s" ay tumutukoy sa hindi umiiral na package
(W bareword) Gumamit ka ng isang kwalipikadong bareword ng form na "Foo::", ngunit nakita ng compiler
walang ibang gamit ng namespace na iyon bago ang puntong iyon. Marahil ay kailangan mong ideklara ang isang
pakete?

Nabigo ang BEGIN--na-abort ang compilation
(F) Isang hindi na-trap na exception ang itinaas habang nagsasagawa ng BEGIN subroutine. Compilation
hihinto kaagad at ang interpreter ay lumabas.

BEGIN hindi ligtas pagkatapos ng mga error--na-abort ang compilation
(F) Nakahanap si Perl ng "BEGIN {}" subroutine (o isang "use" directive, na nagpapahiwatig ng "BEGIN
{}") pagkatapos maganap ang isa o higit pang mga error sa compilation. Mula noong sinadya
environment para sa "BEGIN {}" ay hindi magagarantiyahan (dahil sa mga error), at mula noon
ang kasunod na code ay malamang na nakasalalay sa tamang operasyon nito, sumuko na lang si Perl.

\%d mas mainam na isulat bilang $%d
(W syntax) Sa labas ng mga pattern, ang mga backreference ay nabubuhay bilang mga variable. Ang gamit ng
Ang mga backslashes ay grandfathered sa kanang bahagi ng isang substitution, ngunit
stylistically ito ay mas mahusay na gamitin ang variable na form dahil ang ibang Perl programmer ay
asahan ito, at mas gagana ito kung mayroong higit sa 9 na backreference.

Binary number > 0b11111111111111111111111111111111 non-portable
(W portable) Ang binary number na iyong tinukoy ay mas malaki kaysa sa 2**32-1 (4294967295) at
samakatuwid ay hindi portable sa pagitan ng mga system. Tingnan ang perlport para sa higit pa sa portability
alalahanin.

magbigkis() sa saradong socket %s
(W closed) Sinubukan mong gumawa ng bind sa isang closed socket. Nakalimutan mo bang suriin ang
ibalik ang halaga ng iyong socket () tumawag? Tingnan ang "bind" sa perlfunc.

binmode() sa saradong filehandle %s
(W unopen) Sinubukan mo binmode() sa isang filehandle na hindi nabuksan. Suriin ang iyong
kontrol ng daloy at bilang ng mga argumento.

Bit vector size > 32 non-portable
(W portable) Ang paggamit ng mga bit vector size na mas malaki sa 32 ay hindi portable.

Kakaibang kopya ng %s
(P) Nakita ni Perl ang isang pagtatangkang kopyahin ang isang panloob na halaga na hindi maaaring kopyahin.

Kakaibang SvTYPE [%d]
(P) Kapag nagsimula ng bagong thread o nagbabalik ng mga value mula sa isang thread, nakatagpo si Perl ng isang
di-wastong uri ng data.

Pareho o wala sa dulo ng hanay ay dapat na Unicode sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) (sa ilalim lamang ng "use re 'strict'" o sa loob ng "(?[...])")

Sa isang naka-bracket na klase ng character sa isang regular na pattern ng expression, mayroon kang isang hanay kung saan
may eksaktong isang dulo nito na tinukoy gamit ang "\N{}", at ang kabilang dulo ay tinukoy gamit
isang non-portable na mekanismo. Tinatrato ng Perl ang range bilang isang Unicode range, iyon ay, lahat ng
ang mga character sa loob nito ay itinuturing na mga Unicode na character, at maaaring
iba't ibang mga punto ng code sa ilang platform na pinapatakbo ng Perl. Halimbawa, "[\N{U+06}-\x08]"
ay itinuturing na parang sinabi mo sa halip na "[\N{U+06}-\N{U+08}]", iyon ay tumutugma sa
mga character na ang mga punto ng code sa Unicode ay 6, 7, at 8. Ngunit ang "\x08" na iyon ay maaaring
ipahiwatig na iba ang ibig mong sabihin, kaya tumaas ang babala.

Buffer overflow sa prime_env_iter: %s
(W internal) Isang babala na kakaiba sa VMS. Habang naghahanda si Perl na umulit
%ENV, nakatagpo ito ng lohikal na pangalan o kahulugan ng simbolo na masyadong mahaba, kaya ganoon
pinutol sa ipinakitang string.

Callback na tinatawag na exit
(F) Isang subroutine na na-invoke mula sa isang panlabas na pakete sa pamamagitan ng call_sv() lumabas sa pamamagitan ng pagtawag
lumabas.

Masyadong maagang tumawag si %s() para suriin ang prototype
(W prototype) Tumawag ka ng function na may prototype bago nakita ng parser ang a
kahulugan o deklarasyon para dito, at hindi masuri ni Perl kung naaayon ang tawag sa
Ang prototype. Kailangan mong magdagdag ng maagang prototype na deklarasyon para sa
subroutine na pinag-uusapan, o ilipat ang kahulugan ng subroutine bago ang tawag para makuha
tamang prototype checking. Bilang kahalili, kung sigurado kang tinatawagan mo ang
gumana nang tama, maaari kang maglagay ng ampersand bago ang pangalan upang maiwasan ang babala.
Tingnan ang perlsub.

Ang pagtawag sa POSIX::%s() ay hindi na ginagamit
(D hindi na ginagamit) Tumawag ka ng isang function na ang paggamit ay hindi na ginagamit. Tingnan ang pangalan ng function
sa POSIX para sa mga detalye.

Hindi maaaring chr %f
(F) Nagpasa ka ng di-wastong numero (tulad ng infinity o hindi-isang-number) sa "chr".

Hindi ma-compress ang %f sa pack
(F) Sinubukan mong i-compress ang isang infinity o not-a-number bilang unsigned integer na may BER,
na walang katuturan.

Hindi ma-compress ang integer sa pack
(F) Masyadong malaki ang argumento na i-pack("w",...) para i-compress. Na-compress ang BER
Ang integer na format ay magagamit lamang sa mga positibong integer, at sinubukan mong i-compress
isang napakalaking bilang (> 1e308). Tingnan ang "pack" sa perlfunc.

Hindi ma-compress ang mga negatibong numero sa pack
(F) Ang isang argumento na i-pack("w",...) ay negatibo. Ang BER compressed integer format ay maaaring
gamitin lamang sa mga positibong integer. Tingnan ang "pack" sa perlfunc.

Hindi ma-convert ang isang reference sa %s sa typeglob
(F) Direkta mong manipulahin ang talahanayan ng simbolo ng Perl, nag-imbak ng reference dito, pagkatapos ay sinubukan
upang ma-access ang simbolo na iyon sa pamamagitan ng conventional Perl syntax. Ang pag-access ay nagti-trigger ng Perl sa
autovivify ang typeglob na iyon, ngunit walang legal na conversion mula sa ganoong uri ng
reference sa isang typeglob.

Hindi makopya sa %s
(P) Nakita ni Perl ang isang pagtatangkang kopyahin ang isang halaga sa isang panloob na uri na hindi maaaring
direktang nakatalaga sa.

Hindi mahanap ang encoding na "%s"
(S io) Sinubukan mong maglapat ng encoding na hindi umiiral sa isang filehandle, alinman sa
bukas() or binmode().

Hindi ma-pack ang %f ng '%c'
(F) Sinubukan mong i-convert ang isang infinity o hindi-isang-number sa isang integer, na hindi
pakiramdam.

Hindi mai-print ang %f gamit ang '%c'
(F) Sinubukan mong mag-print ng infinity o not-a-number bilang character (%c), na hindi
kahulugan. Baka '%s' ang ibig mong sabihin, o pinag-stringify lang ito?

Hindi maitakda ang tied @DB::args
(F) Sinubukan ng "tumatawag" na itakda ang @DB::args, ngunit nakitang nakatali ito. Ang pagtali sa @DB::args ay hindi
suportado. (Bago idagdag ang error na ito, dati itong nag-crash.)

Hindi maitali ang hindi nare-reifiable na array
(P) Nagawa mong tawagan ang "tie" sa isang array na hindi nagpapanatili ng bilang ng sanggunian
sa mga argumento nito at hindi maaaring gawin ito. Ang ganitong mga array ay hindi kahit na dapat na maging
naa-access sa Perl code, ngunit ginagamit lamang sa loob.

Maaari lamang i-compress ang mga unsigned integer sa pack
(F) Ang isang argument na i-pack("w",...) ay hindi isang integer. Ang BER compressed integer
format ay magagamit lamang sa mga positibong integer, at sinubukan mong i-compress
iba pa. Tingnan ang "pack" sa perlfunc.

Hindi ma-bless ang non-reference na halaga
(F) Mga mahihirap na sanggunian lamang ang maaaring pagpalain. Ito ay kung paano "ipinatupad" ni Perl ang encapsulation ng
mga bagay. Tingnan ang perlobj.

Hindi maaaring "masira" sa isang loop topicalizer
(F) Tinawag mo ang "break", ngunit nasa "foreach" block ka sa halip na isang "given" block.
Marahil ay sinadya mong gamitin ang "susunod" o "huling".

Hindi maaaring "masira" sa labas ng isang partikular na bloke
(F) Tinawag mo ang "break", ngunit wala ka sa loob ng isang "given" block.

Hindi matawagan ang paraan na "%s" sa isang hindi natukoy na halaga
(F) Ginamit mo ang syntax ng isang method call, ngunit ang slot ay napuno ng object reference
o ang pangalan ng package ay naglalaman ng hindi natukoy na halaga. Isang bagay na tulad nito ang magpaparami ng
error:

$BADREF = undef;
proseso $BADREF 1,2,3;
$BADREF->proseso(1,2,3);

Hindi matawagan ang paraan na "%s" sa hindi pinagpalang reference
(F) Dapat malaman ng isang method na tawag kung saang package ito dapat tumakbo. Ito ay karaniwang nakakahanap
ito mula sa object reference na ibinibigay mo, ngunit hindi ka nagbigay ng object
sanggunian sa kasong ito. Ang isang sanggunian ay hindi isang sanggunian ng bagay hanggang sa ito ay naging
pinagpala. Tingnan ang perlobj.

Hindi matawagan ang paraan na "%s" nang walang package o object reference
(F) Ginamit mo ang syntax ng isang method call, ngunit ang slot ay napuno ng object reference
o ang pangalan ng package ay naglalaman ng isang expression na nagbabalik ng tinukoy na halaga na hindi alinman
isang object reference o isang pangalan ng package. Ang isang bagay na tulad nito ay magpaparami ng error:

$BADREF = 42;
proseso $BADREF 1,2,3;
$BADREF->proseso(1,2,3);

Hindi makatawag mro_isa_changed_in() sa hindi kilalang simbolo na talahanayan
(P) Nalito si Perl kung ang isang hash ay isang simpleng hash o isang simbolo ng table hash
kapag sinusubukang i-update ang mga cache ng @ISA.

Hindi makatawag mro_method_changed_in() sa hindi kilalang simbolo na talahanayan
(F) Sinubukan ng isang XS module na tawagan ang "mro_method_changed_in" sa isang hash na hindi naka-attach
sa talahanayan ng simbolo.

Hindi ma-chdir sa %s
(F) Tinawag mo ang "perl -x/foo/bar", ngunit /foo/bar ay hindi isang direktoryo na maaari mong chdir
sa, posibleng dahil wala ito.

Hindi masuri ang filesystem ng script na "%s" para sa nosuid
(P) Para sa ilang kadahilanan hindi mo masuri ang filesystem ng script para sa nosuid.

Hindi mapipilit ang %s sa %s sa %s
(F) Ang ilang uri ng mga SV, sa partikular na mga entry sa talahanayan ng totoong simbolo (typeglobs), ay hindi maaaring
mapipilitang huminto sa pagiging kung ano sila. Kaya hindi mo masasabi ang mga bagay tulad ng:

*foo += 1;

MAAARI mong sabihin

$foo = *foo;
$foo += 1;

ngunit pagkatapos ay hindi na naglalaman ng glob ang $foo.

Hindi maaaring "magpatuloy" sa labas ng isang kapag na-block
(F) Tinawag mo ang "magpatuloy", ngunit wala ka sa loob ng "kailan" o "default" na bloke.

Hindi makagawa ng pipe mailbox
(P) Isang error na kakaiba sa VMS. Ang proseso ay naghihirap mula sa naubos na mga quota o iba pa
mga problema sa pagtutubero.

Hindi maipahayag ang %s sa "%s"
(F) Tanging ang mga variable na scalar, array, at hash ang maaaring ideklara bilang "my", "our" o "state"
mga variable. Dapat silang magkaroon ng mga ordinaryong identifier bilang mga pangalan.

Hindi maaaring "default" sa labas ng isang topicalizer
(F) Gumamit ka ng "default" na bloke na wala sa loob ng "foreach" loop o a
"ibinigay" na bloke. (Tandaan na ang error na ito ay ibinibigay sa paglabas mula sa "default" na bloke, kaya
hindi mo makukuha ang error kung gumamit ka ng tahasang "magpatuloy".)

Hindi makagawa ng inplace na pag-edit: %s ay hindi isang regular na file
(S inplace) Sinubukan mong gamitin ang -i lumipat sa isang espesyal na file, tulad ng isang file sa / dev,
isang FIFO o isang hindi nae-edit na direktoryo. Hindi pinansin ang file.

Hindi makagawa ng inplace na pag-edit sa %s: %s
(S inplace) Nabigo ang paglikha ng bagong file para sa ipinahiwatig na dahilan.

Hindi makakagawa ng inplace na pag-edit nang walang backup
(F) Ikaw ay nasa isang sistema tulad ng MS-DOS na nalilito kung susubukan mong magbasa mula sa a
tinanggal (ngunit binuksan pa rin) na file. Kailangan mong sabihin ang "-i.bak", o iba pa.

Hindi makagawa ng inplace na pag-edit: %s ay hindi magiging kakaiba
(S inplace) Hindi sinusuportahan ng iyong filesystem ang mga filename na mas mahaba sa 14 na character at
Hindi nakagawa si Perl ng natatanging filename sa panahon ng inplace na pag-edit gamit ang -i Lumipat.
Hindi pinansin ang file.

Hindi magawa ang %s("%s") sa lokal na hindi UTF-8; nalutas sa "%s".
(W locale) Ikaw ay 1) tumatakbo sa ilalim ng ""use locale""; 2) ang kasalukuyang lokal ay hindi a
UTF-8 isa; 3) sinubukan mong gawin ang itinalagang operasyon ng pagbabago ng kaso sa tinukoy
Unicode character; at 4) ang resulta ng operasyong ito ay paghaluin ang Unicode at locale
mga panuntunan, na malamang na magkasalungat. Ang paghahalo ng iba't ibang uri ng panuntunan ay ipinagbabawal, kaya ang
ang operasyon ay hindi nagawa; sa halip ang resulta ay ang ipinahiwatig na halaga, kung saan ay ang pinakamahusay
magagamit na gumagamit ng ganap na mga panuntunan sa Unicode. Iyon pala ay halos palaging ang
orihinal na karakter, hindi nagbabago.

Sa pangkalahatan ay isang masamang ideya na paghaluin ang mga lokal na hindi UTF-8 at Unicode, at ang isyung ito ay isa
sa mga dahilan kung bakit. Ang babalang ito ay itinataas kapag ang mga panuntunan ng Unicode ay karaniwang sanhi
ang resulta ng operasyong ito upang maglaman ng isang character na nasa hanay na tinukoy ni
ang locale, 0..255, at samakatuwid ay napapailalim sa mga panuntunan ng locale, hindi ng Unicode.

Kung gumagamit ka ng lokal na puro para sa mga katangian nito na nauugnay sa mga bagay tulad nito
numeric at time formatting (at hindi "LC_CTYPE"), isaalang-alang ang paggamit ng pinaghihigpitang anyo ng
ang lokal na pragma (tingnan ang "Ang "gamitin ang lokal" pragma" sa perllocale) tulad ng
""use locale ':not_characters'"".

Tandaan na ang mga nabigong pagpapatakbo ng pagbabago ng kaso ay ginawa bilang resulta ng case-insensitive na "/i"
lalabas ang regular na pagtutugma ng expression sa babalang ito bilang may "fc" na operasyon
(bilang iyon ang tinatawag ng regular na expression engine sa likod ng mga eksena.)

Hindi makapaghintaypid sa mga flag
(F) Ang makinang ito ay wala rin waitpid() or wait4(), kaya lang waitpid() wala
ang mga watawat ay tinutularan.

Hindi maaaring tularan -%s sa #! linya
(F) Ang #! line ay tumutukoy sa isang switch na hindi makatwiran sa puntong ito. Para sa
halimbawa, ito ay isang uri ng hangal na maglagay ng -x sa #! linya.

Hindi maaaring %s %s-endian %ss sa platform na ito
(F) Ang byte-order ng iyong platform ay hindi big-endian o little-endian, o mayroon itong
kakaibang laki ng pointer. Pag-iimpake at pag-unpack ng malaki- o maliit na-endian na floating point
ang mga halaga at pointer ay maaaring hindi posible. Tingnan ang "pack" sa perlfunc.

Hindi maipatupad ang "%s": %s
(W exec) A sistema(), exec(), o hindi maisagawa ng piped open call ang pinangalanang program
para sa ipinahiwatig na dahilan. Kasama sa mga karaniwang dahilan ang: mali ang mga pahintulot sa
file, ang file ay hindi nakita sa $ENV{PATH}, ang executable na pinag-uusapan ay pinagsama-sama para sa
isa pang arkitektura, o ang #! linya sa isang script ay tumuturo sa isang interpreter na hindi
patakbuhin para sa katulad na mga kadahilanan. (O baka hindi sinusuportahan ng iyong system ang #! sa lahat.)

Hindi maipatupad ang %s
(F) Sinusubukan ni Perl na isagawa ang ipinahiwatig na programa para sa iyo dahil iyon ang
#! sabi ni line. Kung hindi iyon ang gusto mo, maaaring kailanganin mong banggitin ang "perl" sa #!
linya sa isang lugar.

Hindi maisagawa ang %s
(F) Ginamit mo ang -S switch, ngunit ang mga kopya ng script na isasagawa ay matatagpuan sa PATH
ay walang tamang mga pahintulot.

Hindi makahanap ng opnumber para sa "%s"
(F) Isang string ng anyong "CORE::word" ang ibinigay sa prototype(), ngunit walang builtin
na may pangalang "salita".

Hindi mahanap ang %s character property na "%s"
(F) Ginamit mo ang "\p{}" o "\P{}" ngunit ang katangian ng character sa pangalang iyon ay hindi maaaring
natagpuan. Baka mali ang spelling mo sa pangalan ng property? Tingnan ang "Mga naa-access na katangian
sa pamamagitan ng \p{} at \P{}" sa perluniprops para sa kumpletong listahan ng available na opisyal
ari-arian.

Hindi mahanap ang label na %s
(F) Sinabi mo na kumuha ng isang label na hindi binanggit kahit saan na posible para sa amin
upang pumunta sa. Tingnan ang "goto" sa perlfunc.

Hindi mahanap ang %s sa PATH
(F) Ginamit mo ang -S lumipat, ngunit ang script na isasagawa ay hindi matagpuan sa PATH.

Hindi mahanap ang %s sa PATH, '.' wala sa PATH
(F) Ginamit mo ang -S lumipat, ngunit ang script na isasagawa ay hindi matagpuan sa PATH,
o hindi bababa sa hindi sa tamang mga pahintulot. Ang script ay umiiral sa kasalukuyang
direktoryo, ngunit ipinagbabawal ng PATH ang pagpapatakbo nito.

Hindi mahanap ang string terminator %s kahit saan bago ang EOF
(F) Ang mga string ng Perl ay maaaring umabot sa maraming linya. Ang mensaheng ito ay nangangahulugan na ang pagsasara
tinanggal ang delimiter. Dahil ang mga naka-bracket na quote ay nagbibilang ng mga antas ng nesting, ang mga sumusunod
nawawala ang huling panaklong nito:

print q(Ang karakter na '(' ay nagsisimula ng isang side comment.);

Kung nakukuha mo ang error na ito mula sa isang dito-dokumento, maaaring isinama mo ang hindi nakikita
whitespace bago o pagkatapos ng iyong closing tag o maaaring walang linebreak pagkatapos nito.
Ang isang mahusay na editor ng programmer ay magkakaroon ng paraan upang matulungan kang mahanap ang mga character na ito (o kakulangan
ng mga karakter). Tingnan ang perlop para sa buong detalye dito-mga dokumento.

Hindi mahanap ang kahulugan ng Unicode property na "%s"
(F) Maaaring sinubukan mong gamitin ang "\p" na nangangahulugang isang Unicode property (halimbawa
Ang "\p{Lu}" ay tumutugma sa lahat ng malalaking titik). Kung sinadya mong gumamit ng Unicode property,
tingnan ang "Properties na maa-access sa pamamagitan ng \p{} at \P{}" sa perluniprops para sa kumpletong listahan
ng mga magagamit na ari-arian. Kung hindi mo sinasadyang gumamit ng Unicode property, i-escape ang
"\p", alinman sa pamamagitan ng "\\p" (ang "\p" lang") o ng "\Q\p" (ang natitirang bahagi ng string, o hanggang
"\E").

Hindi makapag-fork: %s
(F) Isang nakamamatay na error ang naganap habang sinusubukang mag-fork habang binubuksan ang pipeline.

Hindi makapag-fork, subukang muli sa loob ng 5 segundo
(W pipe) Nabigo ang isang tinidor sa isang piped open na may EAGAIN at susubukang muli pagkatapos ng lima
segundo.

Hindi makakuha ng filespec - stale stat buffer?
(S) Isang babala na kakaiba sa VMS. Ito ay lumitaw dahil sa pagkakaiba sa pagitan ng pag-access
mga pagsusuri sa ilalim ng VMS at sa ilalim ng modelong Unix na ipinapalagay ni Perl. Sa ilalim ng VMS, ang mga pagsusuri sa pag-access ay
ginawa sa pamamagitan ng filename, sa halip na sa pamamagitan ng mga bit sa stat buffer, upang ang mga ACL at iba pa
maaaring isaalang-alang ang mga proteksyon. Sa kasamaang palad, ipinapalagay ni Perl na ang stat
buffer ay naglalaman ng lahat ng kinakailangang impormasyon, at ipinapasa ito, sa halip na ang filespec,
sa nakagawiang pagsuri sa pag-access. Susubukan nitong kunin ang filespec gamit ang device
name at FID na nasa buffer ng stat, ngunit gagana lang ito kung hindi ka pa nakagawa ng a
kasunod na tawag sa CRTL stat () routine, dahil na-overwrite ang pangalan ng device
sa bawat tawag. Kung lumitaw ang babalang ito, nabigo ang paghahanap ng pangalan, at ang pag-access-
sumuko ang checking routine at nagbalik ng MALI, para lang maging konserbatibo. (Tandaan: Ang
alam ang routine ng pag-access sa pagsusuri tungkol sa operator ng Perl na "stat" at mga pagsubok sa file, kaya ikaw
hindi dapat makita ang babalang ito bilang tugon sa isang utos ng Perl; ito ay lumitaw lamang kung ilan
hindi gaanong tinatanggap ng internal code ang mga buffer ng stat.)

Hindi makuha ang pangalan ng device ng pipe mailbox
(P) Isang error na kakaiba sa VMS. Pagkatapos gumawa ng mailbox para kumilos bilang pipe, hindi magawa ni Perl
kunin ang pangalan nito para magamit sa ibang pagkakataon.

Hindi makakuha ng SYSGEN parameter value para sa MAXBUF
(P) Isang error na kakaiba sa VMS. Tinanong ni Perl ang $GETSYI kung gaano mo kalaki ang iyong mailbox
buffers to be, at hindi nakakuha ng sagot.

Hindi maaaring "goto" sa gitna ng isang foreach loop
(F) Ang isang "goto" na pahayag ay naisakatuparan upang tumalon sa gitna ng isang foreach loop. Ikaw
hindi makakarating doon mula dito. Tingnan ang "goto" sa perlfunc.

Hindi maka-"goto" sa isang pseudo block
(F) Ang isang "goto" na pahayag ay isinagawa upang tumalon mula sa kung ano ang maaaring magmukhang isang bloke,
maliban na ito ay hindi isang tamang bloke. Karaniwan itong nangyayari kung sinubukan mong tumalon
a pag-uri-uriin () block o subroutine, na isang hindi-hindi. Tingnan ang "goto" sa perlfunc.

Hindi mapunta sa subroutine mula sa isang eval-%s
(F) Ang "goto subroutine" na tawag ay hindi magagamit para tumalon mula sa isang eval na "string" o block.

Hindi mapunta sa subroutine mula sa isang sort sub (o katulad na callback)
(F) Ang tawag na "goto subroutine" ay hindi magagamit para tumalon mula sa paghahambing na sub para sa a
pag-uri-uriin (), o mula sa isang katulad na callback (tulad ng bawasan() function sa List::Util).

Hindi mapunta sa subroutine sa labas ng subroutine
(F) Ang malalim na mahiwagang "goto subroutine" na tawag ay maaari lamang palitan ang isang subroutine na tawag para sa
isa pa. Hindi ito makakagawa ng isa mula sa buong tela. Sa pangkalahatan ikaw ay dapat
Tinatawag ito mula sa isang AUTOLOAD na gawain lamang. Tingnan ang "goto" sa perlfunc.

Hindi maaaring balewalain ang signal CHLD, na pinipilit na i-default
(W signal) Natukoy ni Perl na ito ay pinapatakbo gamit ang SIGCHLD signal (minsan
kilala bilang SIGCLD) na hindi pinagana. Dahil ang hindi pagpapagana ng signal na ito ay makagambala sa tamang
pagpapasiya ng exit status ng mga proseso ng bata, na-reset ni Perl ang signal nito
default na halaga. Karaniwang ipinahihiwatig ng sitwasyong ito na ang programa ng magulang kung saan
Maaaring tumatakbo si Perl (hal. cron) ay napakawalang-ingat.

Hindi mapatay ang isang non-numeric na process ID
(F) Ang mga pagkakakilanlan ng proseso ay dapat na (nalagdaan) mga integer. Ito ay isang nakamamatay na pagkakamali upang subukan
pumatay() isang undefined, empty-string o kung hindi man ay non-numeric na process identifier.

Hindi maaaring "tumagal" sa labas ng isang loop block
(F) Ang isang "huling" pahayag ay naisakatuparan upang lumabas sa kasalukuyang bloke, maliban doon
mayroong ito itty bitty problema na tinatawag na walang kasalukuyang block. Tandaan na ang isang "kung"
o ang "iba" na bloke ay hindi binibilang bilang isang "loopish" na bloke, tulad ng hindi isang bloke na ibinigay sa
pag-uri-uriin (), mapa() or grep(). Maaari mong i-double ang mga kulot upang makakuha ng parehong epekto
gayunpaman, dahil ang mga panloob na kulot ay ituturing na isang bloke na umiikot nang isang beses. Tingnan mo
"huling" sa perlfunc.

Hindi ma-linearize ang anonymous na talahanayan ng simbolo
(F) Sinubukan ni Perl na kalkulahin ang method resolution order (MRO) ng isang package, ngunit nabigo
dahil walang pangalan ang imbakan ng package.

Hindi ma-load ang '%s' para sa module na %s
(F) Nabigo ang module na sinubukan mong i-load na mag-load ng dynamic na extension. Ito ay maaaring alinman
nangangahulugan na na-upgrade mo ang iyong bersyon ng perl sa isa na hindi tugma sa iyong luma
mga dynamic na extension (na alam na nangyayari sa pagitan ng mga pangunahing bersyon ng perl), o (higit pa
malamang) na ang iyong dynamic na extension ay binuo laban sa isang mas lumang bersyon ng library
na naka-install sa iyong system. Maaaring kailanganin mong buuin muli ang iyong lumang dynamic
mga extension.

Hindi ma-localize ang lexical variable %s
(F) Gumamit ka ng lokal sa isang variable na pangalan na dati nang idineklara bilang isang lexical
variable gamit ang "aking" o "estado". Ito ay hindi pinapayagan. Kung nais mong i-localize ang a
variable ng package na may parehong pangalan, gawing kwalipikado ito sa pangalan ng package.

Hindi ma-localize sa pamamagitan ng isang reference
(F) May sinabi ka tulad ng "local $$ref", na kasalukuyang hindi kayang hawakan ni Perl, dahil
kapag napupunta ito upang ibalik ang lumang halaga ng anumang itinuro ng $ref pagkatapos ng saklaw ng
ang lokal() ay tapos na, hindi ito makatitiyak na ang $ref ay magiging sanggunian pa rin.

Hindi mahanap ang %s
(F) Sinabi mong "gawin" (o "nangangailangan", o "gamitin") ang isang file na hindi mahanap. Perl
hinahanap ang file sa lahat ng lokasyong binanggit sa @INC, maliban kung ang pangalan ng file
kasama ang buong path sa file. Marahil ay kailangan mong itakda ang PERL5LIB o PERL5OPT
environment variable para sabihin kung nasaan ang dagdag na library, o baka kailangan ng script
idagdag ang pangalan ng library sa @INC. O baka mali lang ang spelling mo sa pangalan ng file. Tingnan mo
"nangangailangan" sa perlfunc at lib.

Hindi mahanap ang auto/%s.al sa @INC
(F) Ang isang function (o paraan) ay tinawag sa isang package na nagpapahintulot sa autoload, ngunit mayroon
walang function sa autoload. Karamihan sa mga posibleng dahilan ay isang maling pagkaka-print sa isang function/paraan
pangalan o isang pagkabigo sa "AutoSplit" ang file, sabihin, sa pamamagitan ng paggawa ng "make install".

Hindi mahanap ang mai-load na bagay para sa module %s sa @INC
(F) Ang module na iyong na-load ay sinusubukang mag-load ng isang panlabas na library, tulad ng halimbawa,
foo.so or bar.dll, ngunit hindi mahanap ng DynaLoader module ang library na ito. Tingnan mo
DynaLoader.

Hindi mahanap ang object method na "%s" sa pamamagitan ng package na "%s"
(F) Tumawag ka ng isang pamamaraan nang tama, at tama itong nagpahiwatig ng isang pakete na gumagana bilang
isang klase, ngunit hindi tinukoy ng package na iyon ang partikular na pamamaraang iyon, ni ang alinman sa mga ito
mga batayang klase. Tingnan ang perlobj.

Hindi mahanap ang object method na "%s" sa pamamagitan ng package na "%s" (marahil nakalimutan mong i-load ang "%s"?)
(F) Tumawag ka ng isang pamamaraan sa isang klase na hindi umiiral, at ang pamamaraan ay hindi maaaring maging
matatagpuan sa UNIVERSAL. Madalas itong nangangahulugan na ang isang pamamaraan ay nangangailangan ng isang pakete na hindi
na-load.

Hindi mahanap ang package %s para sa @%s::ISA
(W syntax) Ang @ISA array ay naglalaman ng pangalan ng isa pang package na tila hindi
umiiral.

Hindi mahanap ang PerlIO%s
(F) Sinubukan mong gamitin sa bukas() isang PerlIO layer na wala, hal open(FH,
">:nosuchlayer", "somefile").

Hindi makagawa ng pagtatalaga ng listahan sa %ENV sa system na ito
(F) Ang pagtatalaga ng listahan sa %ENV ay hindi suportado sa ilang system, lalo na ang VMS.

Hindi maaaring gawing pandaigdigan ang mga na-load na simbolo sa platform na ito habang nilo-load ang %s
(S) Ipinasa ng isang module ang flag na 0x01 sa DynaLoader::dl_load_file() upang humiling na
ang mga simbolo mula sa nakasaad na file ay ginawang magagamit sa buong mundo sa loob ng proseso, ngunit iyon
hindi available ang functionality sa platform na ito. Habang ang module ay malamang na pa rin
sa trabaho, maaari nitong pigilan ang perl interpreter na mag-load ng iba pang mga extension na nakabatay sa XS
na kailangang direktang mag-link sa mga function na tinukoy sa C o XS code sa nakasaad
file.

Hindi mabago ang %s sa %s
(F) Hindi ka pinapayagang magtalaga sa item na ipinahiwatig, o kung hindi man ay subukang baguhin ito,
gaya ng may auto-increment.

Hindi mabago ang hindi umiiral na substring
(P) Ang panloob na gawain na gumagawa ng pagtatalaga sa a substr() ay binigyan ng NULL.

Hindi mabago ang hindi-lvalue na subroutine na tawag
(F) Ang mga subroutine na nilalayong gamitin sa konteksto ng halaga ay dapat na ideklara nang ganoon. Tingnan mo
"Lvalue subroutines" sa perlsub.

Hindi mabago ang reference sa %s sa %s assignment
(F) Limitado lamang na bilang ng mga konstruksyon ang maaaring gamitin bilang argumento sa isang sanggunian
constructor sa kaliwang bahagi ng isang assignment, at ang ginamit mo ay hindi isa sa
sila. Tingnan ang "Pagtatalaga sa Mga Sanggunian" sa perlref.

Hindi mabago ang reference sa naka-localize na parenthesized array sa pagtatalaga ng listahan
(F) Ang pagtatalaga sa "\local(@array)" o "\(local @array)" ay hindi suportado, dahil hindi ito
malinaw kung ano ang dapat gawin. Kung gusto mong gawing sumangguni ang @array sa iba
array, gamitin ang "\@array = \@other_array". Kung nais mong gawin ang mga elemento ng @array
mga alias ng mga scalar na tinutukoy sa kanang bahagi, gamitin ang "\(@array) =
@scalar_refs".

Hindi mabago ang reference sa nakakulong na hash sa pagtatalaga ng listahan
(F) Ang pagtatalaga sa "\(%hash)" ay hindi suportado. Kung ang ibig mong gawin ay sumangguni sa %hash
ilang iba pang hash, gamitin ang "\%hash = \%other_hash". Kung nais mong gawin ang mga elemento ng
%hash sa mga alias ng mga scalar na tinutukoy sa kanang bahagi, gumamit ng hash slice:
"\@hash{@keys} = @those_scalar_refs".

Hindi ma-msgrcv sa read-only na var
(F) Ang target ng isang msgrcv ay dapat na mabago upang magamit bilang isang buffer ng pagtanggap.

Hindi maaaring "susunod" sa labas ng isang loop block
(F) Ang isang "susunod" na pahayag ay naisakatuparan upang ulitin ang kasalukuyang bloke, ngunit walang
kasalukuyang bloke. Tandaan na ang isang "if" o "else" block ay hindi binibilang bilang isang "loopish" block,
bilang ay hindi isang bloke na ibinigay sa pag-uri-uriin (), mapa() or grep(). Karaniwan mong madodoble ang
kulot upang makakuha ng parehong epekto bagaman, dahil ang panloob na mga kulot ay ituturing na a
harangan ang mga loop nang isang beses. Tingnan ang "susunod" sa perlfunc.

Hindi mabuksan ang %s: %s
(S inplace) Ang implicit na pagbubukas ng isang file sa pamamagitan ng paggamit ng "<>" filehandle, alinman
tahasan sa ilalim ng "-n" o "-p" na command-line switch, o tahasang, nabigo para sa
ipinahiwatig na dahilan. Kadalasan ito ay dahil wala kang pahintulot sa pagbabasa para sa isang file
na pinangalanan mo sa command line.

(F) Sinubukan mong tawagan si perl gamit ang -e lumipat, ngunit / dev / null (o ang iyong pagpapatakbo
katumbas ng system) ay hindi mabuksan.

Hindi makapagbukas ng reference
(W io) Sinubukan mong magbukas ng scalar reference para sa pagbabasa o pagsusulat, gamit ang 3-arg
bukas() syntax:

buksan ang FH, '>', $ref;

ngunit ang iyong bersyon ng perl ay pinagsama-sama nang walang perlio, at ang form na ito ng open ay hindi
suportado.

Hindi mabuksan ang bidirectional pipe
(W pipe) Sinubukan mong sabihin ang "open(CMD, "|cmd|")", na hindi sinusuportahan. Maaari mong subukan
alinman sa ilang mga module sa Perl library upang gawin ito, tulad ng IPC::Open2.
Bilang kahalili, idirekta ang output ng pipe sa isang file gamit ang ">", at pagkatapos ay basahin ito sa ilalim ng a
ibang file handle.

Hindi mabuksan ang error file %s bilang stderr
(F) Isang error na kakaiba sa VMS. Gumagawa ang Perl ng sarili nitong pag-redirect ng command line, at
hindi mabuksan ang file na tinukoy pagkatapos ng '2>' o '2>>' sa command line para sa pagsusulat.

Hindi mabuksan ang input file na %s bilang stdin
(F) Isang error na kakaiba sa VMS. Gumagawa ang Perl ng sarili nitong pag-redirect ng command line, at
hindi mabuksan ang file na tinukoy pagkatapos ng '<' sa command line para sa pagbabasa.

Hindi mabuksan ang output file na %s bilang stdout
(F) Isang error na kakaiba sa VMS. Gumagawa ang Perl ng sarili nitong pag-redirect ng command line, at
hindi mabuksan ang file na tinukoy pagkatapos ng '>' o '>>' sa command line para sa pagsusulat.

Hindi mabuksan ang output pipe (pangalan: %s)
(P) Isang error na kakaiba sa VMS. Gumagawa ang Perl ng sarili nitong pag-redirect ng command line, at
hindi mabuksan ang pipe kung saan magpapadala ng data na nakalaan para sa stdout.

Hindi mabuksan ang perl script na "%s": %s
(F) Ang script na iyong tinukoy ay hindi mabubuksan para sa ipinahiwatig na dahilan.

Kung nagde-debug ka ng script na gumagamit ng #!, at karaniwang umaasa sa $PATH ng shell
paghahanap, ang pagpipiliang -S ay nagiging sanhi ng perl na gawin ang paghahanap na iyon, kaya hindi mo na kailangang i-type ang
path o "`which $scriptname`".

Hindi mabasa ang kapaligiran ng CRTL
(S) Isang babala na kakaiba sa VMS. Sinubukan ni Perl na basahin ang isang elemento ng %ENV mula sa CRTL's
panloob na hanay ng kapaligiran at natuklasang nawawala ang array. Kailangan mong malaman
kung saan nailagay ng iyong CRTL ang kapaligiran o tinukoy nito PERL_ENV_TABLES (tingnan ang perlvms) kaya
hindi hinahanap ang kapaligiran na iyon.

Hindi ma-"redo" sa labas ng loop block
(F) Ang isang "redo" na pahayag ay naisakatuparan upang i-restart ang kasalukuyang block, ngunit walang
kasalukuyang bloke. Tandaan na ang isang "if" o "else" block ay hindi binibilang bilang isang "loopish" block,
bilang ay hindi isang bloke na ibinigay sa pag-uri-uriin (), mapa() or grep(). Karaniwan mong madodoble ang
kulot upang makakuha ng parehong epekto bagaman, dahil ang panloob na mga kulot ay ituturing na a
harangan ang mga loop nang isang beses. Tingnan ang "redo" sa perlfunc.

Hindi maalis ang %s: %s, nilaktawan ang file
(S inplace) Humiling ka ng inplace na pag-edit nang hindi gumagawa ng backup na file. Si Perl noon
hindi maalis ang orihinal na file upang palitan ito ng binagong file. Ang file ay
naiwang walang pagbabago.

Hindi mapalitan ang pangalan ng %s sa %s: %s, nilaktawan ang file
(S inplace) Ang pagpapalit ng pangalan na ginawa ng -i nabigo ang switch sa ilang kadahilanan, marahil dahil
wala kang pahintulot sa pagsulat sa direktoryo.

Hindi mabuksan muli ang input pipe (pangalan: %s) sa binary mode
(P) Isang error na kakaiba sa VMS. Naisip ni Perl na ang stdin ay isang tubo, at sinubukan itong muling buksan
upang tanggapin ang binary data. Naku, nabigo ito.

Hindi maaaring kumatawan sa karakter para sa Ox%X sa platform na ito
(F) May mahirap na limitasyon sa kung gaano kalaki ang isang character code point dahil sa
pangunahing katangian ng UTF-8, lalo na sa mga platform ng EBCDIC. Ang ibinigay na code point
lumampas diyan. Ang tanging solusyon ay ang hindi gumamit ng ganoong kalaking code point.

Hindi ma-reset ang %ENV sa system na ito
(F) Tinawag mo ang "reset('E')" o katulad nito, na sinubukang i-reset ang lahat ng variable sa
kasalukuyang package na nagsisimula sa "E". Sa pangunahing package, kasama doon ang %ENV.
Ang pag-reset ng %ENV ay hindi sinusuportahan sa ilang system, lalo na ang VMS.

Hindi malutas ang paraan na "%s" na overloading "%s" sa package na "%s"
(F)(P) Error sa paglutas ng overloading na tinukoy ng isang pangalan ng pamamaraan (kumpara sa a
subroutine reference): walang ganitong paraan na matatawag sa pamamagitan ng package. Kung ang pangalan ng pamamaraan ay
"???", isa itong panloob na error.

Hindi maibalik ang %s mula sa subroutine ng lvalue
(F) Nakakita si Perl ng pagtatangkang ibalik ang mga ilegal na halaga (gaya ng pansamantala o readonly
values) mula sa isang subroutine na ginamit bilang isang lvalue. Ito ay hindi pinapayagan.

Hindi makabalik sa labas ng subroutine
(F) Ang return statement ay naisakatuparan sa mainline code, iyon ay, kung saan walang
subroutine na tawag para bumalik. Tingnan ang perlsub.

Hindi maibalik ang %s sa lvalue scalar context
(F) Sinubukan mong magbalik ng kumpletong array o hash mula sa isang subroutine ng lvalue, ngunit ikaw
tinawag ang subroutine sa paraang nagpaisip kay Perl na isa lang ang gusto mong ibalik
halaga. Marahil ay sinadya mong magsulat ng mga panaklong sa paligid ng tawag sa subroutine,
na nagsasabi kay Perl na ang tawag ay dapat nasa konteksto ng listahan.

Hindi ma-stat ang script na "%s"
(P) Sa ilang kadahilanan hindi mo magagawa fstat () ang script kahit na bukas mo na ito.
Kakaiba.

Hindi makuha ang log ng %g
(F) Para sa mga ordinaryong tunay na numero, hindi mo maaaring kunin ang logarithm ng isang negatibong numero o
sero. Mayroong isang Math::Complex na pakete na kasama ng Perl, bagaman, kung ikaw
talagang gustong gawin iyon para sa mga negatibong numero.

Hindi makuha ang sqrt ng %g
(F) Para sa mga ordinaryong tunay na numero, hindi mo maaaring kunin ang square root ng isang negatibong numero.
Mayroong isang Math::Complex na pakete na kasama ng Perl, bagaman, kung ikaw talaga
gustong gawin iyon.

Hindi ma-undef ang aktibong subroutine
(F) Hindi mo maaaring i-undefine ang isang routine na kasalukuyang tumatakbo. Maaari mong, gayunpaman, muling tukuyin
ito habang ito ay tumatakbo, at maaari mo ring i-undef ang redefined subroutine habang ang luma
tumatakbo ang routine. Pumunta figure.

Hindi ma-upgrade ang %s (%d) sa %d
(P) Ang panloob na sv_upgrade routine ay nagdaragdag ng "mga miyembro" sa isang SV, na ginagawa itong mas
dalubhasang uri ng SV. Ang nangungunang ilang uri ng SV ay napakaespesyalista, gayunpaman, iyon
hindi sila maaaring mag-interconvert. Ang mensaheng ito ay nagpapahiwatig na ang naturang conversion ay
sinubukan.

Hindi magamit ang '%c' pagkatapos -mname
(F) Sinubukan mong tawagan si perl gamit ang -m lumipat, ngunit naglagay ka ng isang bagay maliban sa "="
pagkatapos ng pangalan ng module.

Hindi maaaring gumamit ng hash bilang reference
(F) Sinubukan mong gumamit ng hash bilang sanggunian, tulad ng sa "%foo->{"bar"}" o
"%$ref->{"hello"}". Ang mga bersyon ng perl <= 5.22.0 ay ginamit upang payagan ang syntax na ito, ngunit
hindi dapat. Ito ay hindi na ginagamit sa perl 5.6.1.

Hindi maaaring gumamit ng array bilang reference
(F) Sinubukan mong gumamit ng array bilang reference, tulad ng sa "@foo->[23]" o "@$ref->[99]".
Ang mga bersyon ng perl <= 5.22.0 ay ginamit upang payagan ang syntax na ito, ngunit hindi dapat. Ito ay
hindi na ginagamit sa perl 5.6.1.

Hindi maaaring gumamit ng anonymous na talahanayan ng simbolo para sa paghahanap ng paraan
(F) Ang panloob na gawain na gumagawa ng paraan ng paghahanap ay ibinigay ng isang talahanayan ng simbolo na
walang pangalan. Ang mga talahanayan ng simbolo ay maaaring maging anonymous halimbawa sa pamamagitan ng hindi pagtukoy
stashes: "undef %Some::Package::".

Hindi maaaring gumamit ng hindi natukoy na halaga bilang %s reference
(F) Ang isang halaga na ginamit bilang alinman sa isang hard reference o isang symbolic reference ay dapat na isang tinukoy
halaga. Nakakatulong ito upang maalis ang ilang mapanlinlang na mga pagkakamali.

Hindi maaaring gumamit ng bareword ("%s") bilang %s ref habang ginagamit ang "mga mahigpit na ref."
(F) Ang mga hard reference lamang ang pinapayagan ng "strict refs". Ang mga simbolikong sanggunian ay
hindi pinayagan. Tingnan ang perlref.

Hindi magamit ang %! dahil hindi available ang Errno.pm
(F) Sa unang pagkakataon ang "%!" hash ang ginagamit, awtomatikong nilo-load ng perl ang Errno.pm
modyul. Ang Errno module ay inaasahang magtatali sa %! hash upang magbigay ng mga simbolikong pangalan para sa
$! mga halaga ng errno.

Hindi magagamit ang parehong '<' at '>' pagkatapos i-type ang '%c' sa %s
(F) Ang isang uri ay hindi maaaring pilitin na magkaroon ng parehong big-endian at little-endian byte-order sa
sa parehong oras, kaya hindi pinapayagan ang kumbinasyong ito ng mga modifier. Tingnan ang "pack" sa
perlfunc.

Hindi magagamit ang 'defined(@array)' (Marahil ay dapat mo na lang alisin ang tinukoy()?)
(F) tinukoy() ay hindi kapaki-pakinabang sa mga array dahil sinusuri nito ang isang hindi natukoy skalar halaga.
Kung gusto mong makita kung walang laman ang array, gamitin lang ang "if (@array) { # not empty }" para sa
Halimbawa.

Hindi magagamit ang 'defined(%hash)' (Marahil ay dapat mo na lang alisin ang tinukoy()?)
(F) ang "defined()" ay karaniwang hindi tama sa mga hash.

Bagama't mali ang "defined %hash" sa isang simpleng hindi pa nagagamit na hash, nagiging totoo ito sa
ilang di-halatang pangyayari, kabilang ang mga iterator, mahihinang sanggunian, mga pangalan ng itago,
kahit na nananatiling totoo pagkatapos ng "undef %hash". Ang mga bagay na ito ay gumagawa ng "tinukoy na %hash" nang patas
walang silbi sa pagsasanay, kaya ito ngayon ay bumubuo ng isang nakamamatay na error.

Kung ang isang tseke para sa hindi walang laman ang gusto mo pagkatapos ay ilagay lamang ito sa boolean na konteksto (tingnan
"Scalar values" sa perldata):

kung (%hash) {
# walang laman
}

Kung "tinukoy mo ang %Foo::Bar::QUUX" para tingnan kung may ganoong variable ng package
pagkatapos ay hindi talaga iyon maaasahan, at hindi ito isang magandang paraan upang magtanong tungkol sa
mga feature ng isang package, o kung ito ay na-load, atbp.

Hindi magamit ang %s para sa loop variable
(P) Nalito ang parser kapag sinusubukang i-parse ang isang "foreach" na loop.

Hindi magamit ang pandaigdigang %s sa "%s"
(F) Sinubukan mong ideklara ang isang mahiwagang variable bilang isang lexical variable. Hindi ito
pinapayagan, dahil ang magic ay maaaring itali sa isang lokasyon lamang (ibig sabihin, ang global
variable) at ito ay hindi kapani-paniwalang nakakalito na magkaroon ng mga variable sa iyong programa na
mukhang mahiwagang variable ngunit hindi.

Hindi magamit ang '%c' sa isang pangkat na may ibang byte-order sa %s
(F) Sinubukan mong pilitin ang ibang byte-order sa isang uri na nasa loob na ng a
pangkat na may isang byte-order modifier. Halimbawa hindi mo mapipilit ang little-endianness sa isang
tipong nasa loob ng big-endian group.

Hindi magagamit ang "aking %s" sa paghahambing ng pag-uuri
(F) Ang mga pandaigdigang variable na $a at $b ay nakalaan para sa mga paghahambing ng pag-uuri. Nabanggit mo
$a o $b sa parehong linya ng <=> o cmp operator, at ang variable ay nagkaroon ng mas maaga
idineklara bilang isang leksikal na variable. I-qualify ang uri ng variable gamit ang
pangalan ng package, o palitan ang pangalan ng lexical variable.

Hindi magamit ang %s ref bilang %s ref
(F) Pinaghalo mo ang iyong mga uri ng sanggunian. Kailangan mong i-dereference ang isang reference ng
uri na kailangan. Maaari mong gamitin ang ref() function upang subukan ang uri ng sanggunian, kung
kailangan.

Hindi magagamit ang string ("%s") bilang %s ref habang ginagamit ang "mga mahigpit na ref."
Hindi magagamit ang string ("%s"...) bilang %s ref habang ginagamit ang "strict refs".
(F) Sinabihan mo si Perl na i-dereference ang isang string, isang bagay na "gumagamit ng mahigpit" na mga bloke
maiwasan itong mangyari nang hindi sinasadya. Tingnan ang "Mga simbolikong sanggunian" sa perlref. Ito ay maaaring
na-trigger ng isang "@" o "$" sa isang double-quoted na string kaagad bago interpolating
isang variable, halimbawa sa "user @$twitter_id", na nagsasabing tratuhin ang mga nilalaman ng
$twitter_id bilang isang sanggunian ng array; gumamit ng "\" para magkaroon ng literal na "@" na simbolo na sinusundan ng
ang mga nilalaman ng $twitter_id: "user \@$twitter_id".

Hindi magamit ang subscript sa %s
(F) Sinubukan ng compiler na bigyang-kahulugan ang isang naka-bracket na expression bilang isang subscript. Ngunit sa
kaliwa ng mga bracket ay isang expression na hindi mukhang isang hash o array
reference, o anumang bagay na maaaring i-subscribe.

Hindi magagamit ang \%c para ibig sabihin ay $%c sa expression
(W syntax) Sa isang ordinaryong expression, ang backslash ay isang unary operator na lumilikha ng a
pagtukoy sa argumento nito. Ang paggamit ng backslash upang ipahiwatig ang isang backreference sa a
Ang katugmang substring ay wasto lamang bilang bahagi ng isang pattern ng regular na expression. Sinusubukang gawin
ito sa ordinaryong Perl code ay gumagawa ng isang halaga na nagpi-print ng hitsura
SCALAR(0xdecaf). Gamitin ang $1 na form sa halip.

Hindi makapagpahina ng isang nonreference
(F) Tinangka mong pahinain ang isang bagay na hindi isang sanggunian. Mga sanggunian lamang ang maaari
manghina.

Hindi maaaring "kailan" sa labas ng isang topicalizer
(F) Gumamit ka ng a kailan() bloke na wala sa loob ng isang "foreach" loop o isang "ibinigay"
harangan. (Tandaan na ang error na ito ay ibinibigay sa paglabas mula sa block na "kailan", kaya hindi mo gagawin
makuha ang error kung nabigo ang laban, o kung gumamit ka ng tahasang "magpatuloy".)

Hindi maaaring x= sa read-only na halaga
(F) Sinubukan mong ulitin ang isang pare-parehong halaga (kadalasan ang hindi natukoy na halaga) na may isang
assignment operator, na nagpapahiwatig ng pagbabago sa mismong halaga. Marahil kailangan mo
kopyahin ang halaga sa isang pansamantalang, at ulitin iyon.

Ang karakter na sumusunod sa "\c" ay dapat na napi-print na ASCII
(F) Sa "\cX", X dapat ay isang napi-print (hindi makontrol) na karakter ng ASCII.

Tandaan na ang mga ASCII na character na hindi nagmamapa para makontrol ang mga character ay hindi hinihikayat, at
bubuo ng babala (kapag pinagana) ""\c%c" ay mas malinaw na nakasulat bilang
"%s"".

Character sa 'C' na format na nakabalot sa pack
(W pack) Sabi mo

pack("C", $x)

kung saan ang $x ay alinman sa mas mababa sa 0 o higit sa 255; ang "C" na format ay para lamang sa pag-encode
mga native na character ng operating system (ASCII, EBCDIC, at iba pa) at hindi para sa Unicode
character, kaya kumilos si Perl na parang sinadya mo

pack("C", $x & 255)

Kung gusto mo talagang mag-pack ng mga Unicode codepoint, gamitin na lang ang "U" na format.

Character sa 'c' na format na nakabalot sa pack
(W pack) Sabi mo

pack("c", $x)

kung saan ang $x ay mas mababa sa -128 o higit sa 127; ang "c" na format ay para lamang sa
pag-encode ng mga native na character ng operating system (ASCII, EBCDIC, at iba pa) at hindi para sa
Mga character na Unicode, kaya kumilos si Perl na parang sinadya mo

pack("c", $x & 255);

Kung gusto mo talagang mag-pack ng mga Unicode codepoint, gamitin na lang ang "U" na format.

Character sa '%c' na format na nakabalot sa unpack
(W unpack) Sinubukan mo ang isang katulad

i-unpack("H", "\x{2a1}")

kung saan inaasahan ng format na magproseso ng isang byte (isang character na may halagang mas mababa sa 256), ngunit a
mas mataas na halaga ang ibinigay sa halip. Ginagamit ng Perl ang value modulus 256 sa halip, na parang ikaw
ay nagbigay:

i-unpack("H", "\x{a1}")

Character sa 'W' na format na nakabalot sa pack
(W pack) Sabi mo

pack("U0W", $x)

kung saan ang $x ay mas mababa sa 0 o higit sa 255. Gayunpaman, inaasahan ng "U0"-mode ang lahat
mga halaga na babagsak sa pagitan [0, 255], kaya kumilos si Perl na parang ibig mong sabihin:

pack("U0W", $x & 255)

(Mga) character sa '%c' na format na nakabalot sa pack
(W pack) Sinubukan mo ang isang katulad

pack("u", "\x{1f3}b")

kung saan inaasahan ng format na magproseso ng pagkakasunod-sunod ng mga byte (character na may value sa ibaba
256), ngunit ang ilan sa mga character ay may mas mataas na halaga. Ginagamit ng Perl ang mga halaga ng character
modulus 256 sa halip, na parang nagbigay ka ng:

pack("u", "\x{f3}b")

(Mga) character sa '%c' na format na nakabalot sa unpack
(W unpack) Sinubukan mo ang isang katulad

i-unpack("s", "\x{1f3}b")

kung saan inaasahan ng format na magproseso ng pagkakasunod-sunod ng mga byte (character na may value sa ibaba
256), ngunit ang ilan sa mga character ay may mas mataas na halaga. Ginagamit ng Perl ang mga halaga ng character
modulus 256 sa halip, na parang nagbigay ka ng:

i-unpack("s", "\x{f3}b")

ang mga kahulugan ng charnames alyas ay maaaring hindi naglalaman ng pagkakasunod-sunod ng maraming espasyo
(F) Tinukoy mo ang isang pangalan ng character na mayroong maraming mga character na espasyo sa isang hilera. Baguhin
ang mga ito sa iisang espasyo. Karaniwan ang mga pangalang ito ay tinukoy sa ":alias" na pag-import
argument na "gumamit ng mga charnames", ngunit maaari silang tukuyin ng isang tagasalin na naka-install sa
$^H{charnames}. Tingnan ang "CUSTOM ALIASES" sa mga charnames.

ang mga kahulugan ng charnames alias ay maaaring hindi naglalaman ng trailing white-space
(F) Tinukoy mo ang isang pangalan ng character na nagtapos sa isang character na espasyo. Tanggalin ang
trailing space (s). Karaniwan ang mga pangalang ito ay tinukoy sa ":alias" import argument sa
"gumamit ng mga charnames", ngunit maaari silang tukuyin ng isang tagasalin na naka-install sa
$^H{charnames}. Tingnan ang "CUSTOM ALIASES" sa mga charnames.

Hindi na ginagamit ang \C sa regex; minarkahan ng <-- DITO sa m/%s/
(D deprecated, regexp) Ang \C character class ay hindi na ginagamit, at magiging a
compile-time na error sa isang hinaharap na release ng perl (pansamantalang v5.24). Ang konstruksyon na ito
nagbibigay-daan sa iyo na tumugma sa isang solong byte ng kung ano ang bumubuo sa isang multi-byte na solong UTF8 na character,
at sinisira ang encapsulation. Ito rin ay kasalukuyang napaka buggy. Kung kailangan mo talaga
iproseso ang mga indibidwal na byte, malamang na gusto mong i-convert ang iyong string sa isa kung saan
ang bawat pinagbabatayan na byte ay nakaimbak bilang isang character, na may utf8::encode().

Ang "\c%c" ay mas malinaw na isinulat bilang "%s"
(W syntax) Ang "\cX" construct ay inilaan upang maging isang paraan upang tukuyin ang hindi napi-print
mga karakter. Ginamit mo ito para sa isang napi-print, na mas mainam na isulat nang simple
mismo, marahil ay nauunahan ng backslash para sa mga hindi salita na character. Ginagawa ito sa paraang ikaw
did ay hindi portable sa pagitan ng ASCII at EBCDIC platform.

Ang konteksto ng pagpapalit ng cloning ay hindi naipatupad
(F) Ang paggawa ng bagong thread sa loob ng "s///" operator ay hindi suportado.

closedir() sinubukan sa di-wastong dirhandle %s
(W io) Ang dirhandle na sinubukan mong isara ay maaaring sarado o hindi talaga isang dirhandle.
Suriin ang iyong daloy ng kontrol.

isara () sa hindi pa nabuksang filehandle %s
(W unoened) Sinubukan mong isara ang isang filehandle na hindi nabuksan.

Tinatawag na prototype ng pagsasara
(F) Kung ang pagsasara ay may mga katangian, ang subroutine na ipinasa sa isang tagapangasiwa ng katangian ay ang
prototype na na-clone kapag may ginawang bagong pagsasara. Ang subroutine na ito ay hindi maaaring
tinawag.

Nawawala ang code pagkatapos ng '/'
(F) Mayroon kang (sub-)template na nagtatapos sa '/'. Dapat may isa pang template
code kasunod ng slash. Tingnan ang "pack" sa perlfunc.

Ang code point na 0x%X ay hindi Unicode, maaaring hindi portable
(S non_unicode) Mayroon kang code point sa itaas ng Unicode maximum na U+10FFFF.

Pinapayagan ng Perl ang mga string na maglaman ng superset ng mga Unicode code point, hanggang sa limitasyon ng
kung ano ang maiimbak sa isang unsigned integer sa iyong system, ngunit maaaring hindi tanggapin ang mga ito
ng ibang mga wika/sistema. Noong unang panahon, legal sa ilang pamantayan ang magkaroon ng code
mga puntos hanggang 0x7FFF_FFFF, ngunit hindi mas mataas. Kinakailangan ang mga puntos ng code sa itaas ng 0xFFFF_FFFF
mas malaki kaysa sa isang 32 bit na salita.

%s: Hindi nahanap ang command
(A) Hindi mo sinasadyang napatakbo ang iyong script csh o isa pang shell sa halip na Perl.
Suriin ang #! linya, o manu-manong i-feed ang iyong script sa Perl mismo. Ang #! linya sa
ang tuktok ng iyong file ay maaaring magmukhang

#!/usr/bin/perl -w

Nabigo ang compilation sa require
(F) Hindi ma-compile ni Perl ang isang file na tinukoy sa isang "kailangan" na pahayag. Ginagamit ito ni Perl
generic na mensahe kapag wala sa mga error na nakatagpo nito ay sapat na malubha upang ihinto
compilation agad.

Lumampas ang kumplikadong regular na limitasyon sa recursion ng subexpression (%d).
(W regexp) Ang regular na expression engine ay gumagamit ng recursion sa mga kumplikadong sitwasyon kung saan
kailangan ang back-tracking. Ang lalim ng recursion ay limitado sa 32766, o marahil ay mas mababa sa
mga arkitektura kung saan ang stack ay hindi maaaring lumago nang basta-basta. ("Simple" at "medium"
ang mga sitwasyon ay hinahawakan nang walang recursion at hindi napapailalim sa isang limitasyon.) Subukan
paikliin ang string sa ilalim ng pagsusuri; pag-loop sa Perl code (hal. sa "habang")
sa halip na sa regular na expression engine; o muling pagsusulat ng regular na expression kaya
na ito ay mas simple o mas mababa ang backtrack. (Tingnan ang perlfaq2 para sa impormasyon sa Mastering
regular expression.)

ikonekta () sa saradong socket %s
(W sarado) Sinubukan mong kumonekta sa isang saradong socket. Nakalimutan mo bang suriin ang
ibalik ang halaga ng iyong socket () tumawag? Tingnan ang "kunekta" sa perlfunc.

Constant(%s): Ang tawag sa &{$^H{%s}} ay hindi nagbalik ng tinukoy na halaga
(F) Ang subroutine na nakarehistro upang mahawakan ang patuloy na labis na karga (tingnan ang labis na karga) o a
custom na charnames handler (tingnan ang "CUSTOM TRANSLATORS" sa charnames) ay nagbalik ng hindi natukoy
halaga.

Constant(%s): $^H{%s} ay hindi tinukoy
(F) Nakakita ang parser ng mga hindi pagkakapare-pareho habang sinusubukang tukuyin ang isang overloaded
pare-pareho. Marahil ay nakalimutan mong i-load ang kaukulang overload pragma?

Ang Constant ay hindi %s reference
(F) Ang isang pare-parehong halaga (marahil ay ipinahayag gamit ang "use constant" pragma) ay pagiging
dereferenced, ngunit ito ay katumbas ng maling uri ng reference. Ang mensahe ay nagpapahiwatig
ang uri ng sanggunian na inaasahan. Ito ay karaniwang nagpapahiwatig ng isang syntax error sa
dereferencing ang pare-pareho ang halaga. Tingnan ang "Constant Functions" sa perlsub at constant.

Ang mga constant mula sa mga lexical na variable na posibleng mabago sa ibang lugar ay hindi na ginagamit
(D deprecated) Sumulat ka ng isang katulad

aking $var;
$sub = sub () { $var };

ngunit ang $var ay isinangguni sa ibang lugar at maaaring mabago pagkatapos ng "sub" na expression ay
sinusuri. Alinman ito ay tahasang binago sa ibang lugar ("$var = 3") o ito ay ipinasa sa
isang subroutine o sa isang operator tulad ng "printf" o "map", na maaaring baguhin o hindi ang
variable

Ayon sa kaugalian, nakuha ng Perl ang halaga ng variable sa puntong iyon at lumiko
ang subroutine sa isang pare-parehong karapat-dapat para sa inlining. Sa mga kasong iyon kung saan ang
variable ay maaaring mabago sa ibang lugar, sinisira nito ang pag-uugali ng mga pagsasara, kung saan ang
kinukuha ng subroutine ang variable mismo, sa halip na ang halaga nito, kaya nagbabago ang hinaharap sa
ang variable ay makikita sa return value ng subroutine.

Hindi na ginagamit ang paggamit na ito, dahil malamang na magbago ang gawi sa isang bersyon sa hinaharap
ng Perl.

Kung nilayon mong maging karapat-dapat ang subroutine para sa inlining, siguraduhing ang
variable ay hindi isinangguni sa ibang lugar, posibleng sa pamamagitan ng pagkopya nito:

aking $var2 = $var;
$sub = sub () { $var2 };

Kung gusto mo ang subroutine na ito na maging isang pagsasara na nagpapakita ng mga pagbabago sa hinaharap sa
variable na isinara nito, magdagdag ng tahasang "pagbabalik":

aking $var;
$sub = sub () { return $var };

Ang patuloy na subroutine %s ay muling tinukoy
(W redefine)(S) Muling tinukoy mo ang isang subroutine na dating karapat-dapat para sa
inlining. Tingnan ang "Constant Functions" sa perlsub para sa komentaryo at mga solusyon.

Ang patuloy na subroutine %s ay hindi natukoy
(W misc) Hindi mo natukoy ang isang subroutine na dating karapat-dapat para sa inlining.
Tingnan ang "Constant Functions" sa perlsub para sa komentaryo at mga solusyon.

Hindi alam ang constant(%s).
(F) Ang parser ay nakakita ng mga hindi pagkakapare-pareho habang sinusubukang tukuyin ang isang overloaded
pare-pareho, o kapag sinusubukang hanapin ang pangalan ng character na tinukoy sa "\N{...}" escape.
Marahil nakalimutan mong i-load ang kaukulang overload pragma?

:const ay experimental
(S experimental::const_attr) Ang attribute na "const" ay experimental. Kung gusto mo
gamitin ang feature, huwag paganahin ang babala na may "walang babala 'experimental::const_attr'",
ngunit alamin na sa paggawa nito ay nasa panganib ka na ang iyong code ay maaaring masira sa hinaharap
Perl na bersyon.

:const ay hindi pinahihintulutan sa pinangalanang subroutines
(F) Ang katangiang "const" ay nagdudulot ng isang hindi kilalang subroutine na tumakbo at ang halaga nito
nakunan sa oras na ito ay na-clone. Ang mga pinangalanang subroutine ay hindi naka-clone ng ganito,
kaya ang katangian ay walang kahulugan sa kanila.

Hindi nagbalik ng reference ang paraan ng pagkopya
(F) Ang paraan na nag-overload sa "=" ay maraming surot. Tingnan ang "Copy Constructor" sa sobrang karga.

&CORE::%s ay hindi matatawag nang direkta
(F) Sinubukan mong tumawag ng subroutine sa "CORE::" namespace na may &foo syntax o
sa pamamagitan ng isang sanggunian. Ang ilang mga subroutine sa package na ito ay hindi pa matatawag sa ganoong paraan,
ngunit dapat tawaging barewords. Ang isang bagay na tulad nito ay gagana:

MAGSIMULA { *shove = \&CORE::push; }
itulak ang @array, 1,2,3; # pushes on sa @array

CORE::%s ay hindi isang keyword
(F) Ang CORE:: namespace ay nakalaan para sa Perl na mga keyword.

Sirang regexp opcode %d > %d
(P) Isa itong error sa Perl, o, kung gumagamit ka ng isa, ang iyong custom na regular
expression engine. Kung hindi ang huli, iulat ang problema sa pamamagitan ng perlbug utility.

sirang regexp pointer
(P) Ang regular na expression engine ay nalito sa kung ano ang regular na expression compiler
Ibinigay ito.

sirang regexp program
(P) Ang regular na expression engine ay nakapasa sa isang regexp program na walang wastong magic
numero.

Sirang malloc ptr 0x%x sa 0x%x
(P) Ang malloc package na kasama ng Perl ay nagkaroon ng internal failure.

Bilangin pagkatapos ng haba/code sa i-unpack
(F) Mayroon kang template sa pag-unpack na nagsasaad ng isang string na binibilang ang haba, ngunit mayroon ka rin
tinukoy ang isang tahasang laki para sa string. Tingnan ang "pack" sa perlfunc.

Malalim na recursion sa anonymous na subroutine
Malalim na recursion sa subroutine na "%s"
(W recursion) Ang subroutine na ito ay tinawag ang sarili nito (direkta o hindi direktang) 100 beses
higit pa sa ibinalik nito. Ito ay malamang na nagpapahiwatig ng isang walang katapusang recursion, maliban kung
nagsusulat ka ng mga kakaibang benchmark na programa, kung saan iba ang ipinapahiwatig nito.

Ang threshold na ito ay maaaring baguhin mula sa 100, sa pamamagitan ng muling pag-compile ng perlas binary, na nagtatakda ng C
pre-processor macro "PERL_SUB_DEPTH_WARN" sa nais na halaga.

(?(DEFINE)....) ay hindi pinapayagan ang mga sangay sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng isang bagay tulad ng "(?(DEFINE)...|..)" na labag sa batas. Ang pinaka-malamang
sanhi ng error na ito ay ang pag-iwan mo ng panaklong sa loob ng "...." na bahagi.

Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan.

Hindi tinukoy ng %s ang alinman sa package o VERSION--nabigo ang pagsusuri sa bersyon
(F) May sinabi ka tulad ng "use Module 42" pero sa Module file ay wala
mga deklarasyon ng package o isang $VERSION.

delete argument ay index/value array slice, gumamit ng array slice
(F) Ginamit mo ang index/value array slice syntax (%array[...]) bilang argumento sa "tanggalin".
Malamang ang ibig mong sabihin ay @array[...] na may @ na simbolo sa halip.

delete argument ay key/value hash slice, gumamit ng hash slice
(F) Ginamit mo ang key/value hash slice syntax (%hash{...}) bilang argumento para "tanggalin".
Malamang ang ibig mong sabihin ay @hash{...} na may @ na simbolo sa halip.

delete argument ay hindi isang HASH o ARRAY elemento o slice
(F) Ang argument na "tanggalin" ay dapat na alinman sa hash o array element, gaya ng:

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

o isang hash o array slice, gaya ng:

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

Masyadong mahaba ang delimiter para dito
(F) Sa isang konstruksyon dito na dokumento tulad ng "<
hawakan. Kailangan mong maging seryosong baluktot upang magsulat ng code na nag-trigger ng error na ito.

Hindi na ginagamit ang paggamit ng aking() sa maling kondisyon
(D hindi na ginagamit) Gumamit ka ng deklarasyon na katulad ng "my $x if 0". Nagkaroon ng mahabang-
nakatayong bug sa Perl na nagiging sanhi ng isang lexical na variable na hindi ma-clear sa paglabas ng saklaw
kapag ang deklarasyon nito ay may kasamang maling kondisyon. Pinagsamantalahan ito ng ilang tao
bug upang makamit ang isang uri ng static na variable. Dahil balak naming ayusin ang bug na ito, hindi namin gagawin
gusto ng mga taong umaasa sa pag-uugaling ito. Makakamit mo ang isang katulad na static na epekto sa pamamagitan ng
pagdedeklara ng variable sa isang hiwalay na bloke sa labas ng function, hal

sub f { my $x kung 0; ibalik ang $x++ }

nagiging

{ aking $x; sub f { return $x++ } }

Simula sa perl 5.10.0, maaari mo ring gamitin ang mga variable na "estado" upang magkaroon ng mga lexical na
ay pinasimulan nang isang beses lamang (tingnan ang tampok):

sub f { estado $x; ibalik ang $x++ }

Gumawa si DESTROY ng bagong sanggunian sa patay na bagay na '%s'
(F) A DESTROY() paraan ay lumikha ng isang bagong sanggunian sa bagay na kung saan ay lamang pagiging
Nawasak. Nalilito si Perl, at mas gustong i-abort kaysa gumawa ng nakabitin
sanggunian.

Hindi nakagawa ng wastong header
Tingnan ang Server error.

Hindi nagbalik ng totoong halaga si %s
(F) Ang isang kinakailangang (o ginamit) na file ay dapat magbalik ng isang tunay na halaga upang ipahiwatig na ito ay pinagsama-sama
tama at tama ang pagpapatakbo ng initialization code nito. Tradisyonal na tapusin ang ganoong a
file na may "1;", kahit na ang anumang tunay na halaga ay magagawa. Tingnan ang "kailangan" sa perlfunc.

(Ang ibig mo bang sabihin ay &%s sa halip?)
(W misc) Marahil ay tinukoy mo ang isang na-import na subroutine na &FOO bilang $FOO o ilang katulad nito.

(Ang ibig mo bang sabihin ay "lokal" sa halip na "atin"?)
(W misc) Tandaan na ang "aming" ay hindi naglo-localize sa ipinahayag na global variable. meron ka
idineklara itong muli sa parehong leksikal na saklaw, na tila kalabisan.

(Ang ibig mo bang sabihin ay $ o @ sa halip na %?)
(W) Malamang na sinabi mo ang %hash{$key} kapag ang ibig mong sabihin ay $hash{$key} o @hash{@keys}. Sa
sa kabilang banda, baka sinadya mo lang %hash at nadala.

Namatay
(F) Pumasa ka mamatay () isang walang laman na string (ang katumbas ng "die """) o tinawag mo ito
na walang args at $@ ay walang laman.

Walang data ang dokumento
Tingnan ang Server error.

Hindi tinukoy ng %s ang %s::VERSION--nabigo ang pagsusuri sa bersyon
(F) May sinabi ka tulad ng "gamitin ang Module 42" ngunit hindi tinukoy ng Module ang isang $VERSION.

Ang '/' ay hindi kumukuha ng paulit-ulit na bilang
(F) Hindi ka maaaring maglagay ng paulit-ulit na bilang ng anumang uri pagkatapos mismo ng '/' code. Tingnan ang "pack" sa
perlfunc.

Hindi alam kung paano makakuha ng pangalan ng file
(P) Ang "PerlIO_getname", isang perl internal I/O function na partikular sa VMS, ay tinawag kahit papaano.
sa ibang plataporma. Hindi ito dapat mangyari.

Hindi alam kung paano pangasiwaan ang magic ng uri na \%o
(P) Ang panloob na paghawak ng mga mahiwagang variable ay isinumpa.

do_study: wala sa memorya
(P) Dapat nahuli ito ng safemalloc() sa halip.

(Kailangan mo bang ideklara ang %s?)
(S syntax) Ito ay isang edukadong hula na ginawa kasabay ng mensaheng "%s found
kung saan inaasahan ng operator". Madalas itong nangangahulugang isang subroutine o pangalan ng module ay ginagawa
isinangguni na hindi pa idineklara. Maaaring dahil ito sa mga problema sa pag-order sa
iyong file, o dahil sa nawawalang "sub", "package", "require", o "use" na pahayag.
Kung nagre-refer ka ng isang bagay na hindi pa natukoy, hindi mo talaga kailangan
tukuyin ang subroutine o package bago ang kasalukuyang lokasyon. Maaari kang gumamit ng walang laman
"sub foo;" o "package FOO;" para magpasok ng "pasulong" na deklarasyon.

dump() mas mahusay na nakasulat bilang CORE::dump()
(W misc) Ginamit mo ang obsolescent na "dump()" built-in na function, nang hindi ganap na kwalipikado
ito bilang "CORE::dump()". Baka may typo. Tingnan ang "dump" sa perlfunc.

hindi sinusuportahan ang dump
(F) Hindi sinusuportahan ng iyong makina ang dump/undump.

Kopyahin libre() ignorado
(S malloc) Isang panloob na gawain na tinatawag libre() sa isang bagay na napalaya na.

Duplicate na modifier '%c' pagkatapos ng '%c' sa %s
(W unpack) Inilapat mo ang parehong modifier nang higit sa isang beses pagkatapos ng isang uri sa isang pack
template. Tingnan ang "pack" sa perlfunc.

bawat isa sa sanggunian ay eksperimental
(S experimental::autoderef) "bawat isa" na may scalar argument ay eksperimental at maaaring
baguhin o alisin sa hinaharap na bersyon ng Perl. Kung nais mong kunin ang panganib sa paggamit
ang tampok na ito, huwag paganahin ang babalang ito:

walang babala "experimental::autoderef";

elseif dapat elsif
(S syntax) Walang keyword na "elseif" sa Perl dahil sa tingin ni Larry ay pangit ito. Iyong
Ang code ay bibigyang-kahulugan bilang isang pagtatangka na tumawag sa isang paraan na pinangalanang "elseif" para sa klase
ibinalik ng sumusunod na bloke. Malamang na hindi ito ang gusto mo.

Walang laman ang \%c{} sa regex; minarkahan ng <-- DITO sa m/%s/
(F) "\p" at "\P" ay ginagamit upang ipakilala ang isang pinangalanang Unicode property, gaya ng inilarawan sa
perlunicode at perlre. Ginamit mo ang "\p" o "\P" sa isang regular na expression nang wala
pagtukoy sa pangalan ng ari-arian.

nabigo ang pagpasok ng epektibong %s
(F) Habang nasa ilalim ng "use filetest" pragma, inililipat ang tunay at epektibong mga uid o
nabigo ang gids.

Ang %ENV ay may alias sa %s
(F) Tumatakbo ka sa ilalim ng taint mode, at ang %ENV variable ay na-alyas sa isa pa
hash, kaya hindi na nito ipinapakita ang estado ng kapaligiran ng programa. Ito ay
posibleng insecure.

Error sa pag-convert ng detalye ng file %s
(F) Isang error na kakaiba sa VMS. Dahil maaaring kailangang harapin ni Perl ang mga detalye ng file
sa alinman sa VMS o Unix syntax, kino-convert nito ang mga ito sa isang solong form kapag dapat itong gumana
direkta sa kanila. Maaaring nagpasa ka ng di-wastong detalye ng file sa Perl, o
nakahanap ka ng kaso na hindi pinangangasiwaan ng mga routine ng conversion. Sinabi ni Drat.

Eval-grupo sa hindi secure na regular na pagpapahayag
(F) Nakakita si Perl ng may bahid na data kapag sinusubukang mag-compile ng isang regular na expression na iyon
naglalaman ng "(?{ ... })" na zero-width na assertion, na hindi ligtas. Tingnan ang "(?{ code })" sa
perlre, at perlsec.

Hindi pinapayagan ang eval-group sa runtime, gumamit ng re 'eval' sa regex m/%s/
(F) Sinubukan ni Perl na mag-compile ng isang regular na expression na naglalaman ng "(?{ ... })" zero-width
assertion sa oras ng pagtakbo, tulad ng gagawin kapag ang pattern ay naglalaman ng mga interpolated na halaga.
Dahil iyon ay isang panganib sa seguridad, ito ay hindi pinapayagan. Kung pipilitin mo, maaari mo pa ring gawin
ito sa pamamagitan ng paggamit ng "re 'eval'" pragma o sa pamamagitan ng tahasang pagbuo ng pattern mula sa an
interpolated string sa run time at ginagamit iyon sa isang eval(). Tingnan ang "(?{ code })" sa
perlre.

Hindi pinapayagan ang eval-group, gumamit ng re 'eval' sa regex m/%s/
(F) Ang isang regular na expression ay naglalaman ng "(?{ ... })" zero-width assertion, ngunit iyon
pinapayagan lang ang construct kapag may bisa ang "use re 'eval'" pragma. Tingnan ang "(?{ code
})" sa perlre.

Ang EVAL na walang pagbabago sa pos ay lumampas sa limitasyon sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng pattern na nag-nest ng masyadong maraming EVAL na tawag nang hindi gumagamit ng anumang text.
I-restructure ang pattern para maubos ang text.

Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan.

Masyadong mahaba <> operator
(F) Ang mga nilalaman ng isang <> operator ay hindi maaaring lumampas sa maximum na laki ng isang Perl
identifier. Kung sinusubukan mo lang mag-glob ng mahabang listahan ng mga filename, subukang gamitin ang
glob() operator, o ilagay ang mga filename sa isang variable at glob na.

exec? Hindi ako *ganyan* uri ng operating system
(F) Ang function na "exec" ay hindi ipinatupad sa ilang mga system, hal., Symbian OS. Tingnan mo
perlport.

Na-abort ang pagpapatupad ng %s dahil sa mga error sa compilation.
(F) Ang huling buod na mensahe kapag nabigo ang isang Perl compilation.

ang umiiral na argumento ay hindi isang HASH o ARRAY na elemento o isang subroutine
(F) Ang argument na "umiiral" ay dapat na hash o array element o isang subroutine na may
ampersand, tulad ng:

$foo{$bar}
$ref->{"susie"}[12]
&gumawa ng paraan

ang umiiral na argumento ay hindi isang subroutine na pangalan
(F) Ang argument na "umiiral" para sa "umiiral na &sub" ay dapat na isang subroutine na pangalan, at hindi isang
subroutine na tawag. Ang "exists &sub()" ay bubuo ng error na ito.

Paglabas sa eval sa pamamagitan ng %s
(W exit) Ikaw ay lumalabas sa isang eval sa pamamagitan ng hindi kinaugalian na paraan, gaya ng isang goto, o isang loop
pahayag ng kontrol.

Paglabas sa format sa pamamagitan ng %s
(W exit) Ikaw ay lumalabas sa isang format sa pamamagitan ng hindi kinaugalian na paraan, tulad ng isang goto, o isang
pahayag ng kontrol ng loop.

Paglabas ng pseudo-block sa pamamagitan ng %s
(W exit) Ikaw ay lumalabas sa isang medyo espesyal na block construct (tulad ng isang sort block o
subroutine) sa pamamagitan ng hindi kinaugalian na paraan, gaya ng goto, o loop control statement. Tingnan mo
"sort" sa perlfunc.

Paglabas sa subroutine sa pamamagitan ng %s
(W exit) Ikaw ay lumalabas sa isang subroutine sa pamamagitan ng hindi kinaugalian na paraan, tulad ng isang goto, o isang
pahayag ng kontrol ng loop.

Paglabas ng pagpapalit sa pamamagitan ng %s
(W exit) Ikaw ay lumalabas sa isang pagpapalit sa pamamagitan ng hindi kinaugalian na paraan, tulad ng pagbabalik,
isang goto, o isang loop control statement.

Inaasahan ang malapit na bracket sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Sumulat ka ng isang katulad

(?13

upang tukuyin ang isang nakakakuhang pangkat ng anyong "(?PARNO)", ngunit tinanggal ang ")".

Inaasahan ang '(?flags:(?[...' sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang "(?[...])" na pinahabang klase ng character na regular expression construct ay nagpapahintulot lamang
mga klase ng character (kabilang ang mga pagtakas sa klase ng character tulad ng "\d"), mga operator, at
panaklong. Ang isang exception ay "(?flags:...)" na naglalaman ng kahit isang flag at
eksaktong isang "(?[...])" construct. Pinapayagan nito ang isang regular na expression na naglalaman ng just
"(?[...])" na interpolated. Kung nakikita mo ang mensahe ng error na ito, malamang na mayroon ka
ilang iba pang "(?...)" construct sa loob ng iyong klase ng karakter. Tingnan ang "Extended Bracketed
Mga Klase ng Character" sa perlrecharclass.

Hindi pinagana ang pang-eksperimentong aliasing sa pamamagitan ng reference
(F) Upang gumawa ng aliasing sa pamamagitan ng mga sanggunian, kailangan mo munang paganahin ang tampok:

walang babala "experimental::refaliasing";
gamitin ang tampok na "refaliasing";
\$x = \$y;

Hindi pinagana ang mga pang-eksperimentong subroutine na lagda
(F) Upang gumamit ng mga subroutine na lagda, kailangan mo munang paganahin ang mga ito:

walang babala "experimental::signatures";
gamitin ang tampok na "pirma";
sub foo ($kaliwa, $kanan) { ... }

Hindi pinagana ang pang-eksperimentong "%s" subs
(F) Upang gumamit ng lexical subs, kailangan mo munang paganahin ang mga ito:

walang babala 'experimental::lexical_subs';
gamitin ang tampok na 'lexical_subs';
ang aking sub foo { ... }

Tahasang pagpapala sa '' (ipagpalagay na pangunahing package)
(W misc) Pinagpapala mo ang isang sanggunian sa isang walang haba na string. Ito ay may epekto ng
binabasbasan ang sanggunian sa pangunahing pakete. Karaniwang hindi ito ang gusto mo.
Isaalang-alang ang pagbibigay ng default na target na pakete, hal bless($ref, $p || 'MyPackage');

%s: Syntax ng expression
(A) Hindi mo sinasadyang napatakbo ang iyong script csh sa halip na Perl. Suriin ang #!
linya, o manu-manong i-feed ang iyong script sa Perl mismo.

Nabigo ang %s--napatigil ang pila ng tawag
(F) Isang hindi na-trap na exception ang itinaas habang nagsasagawa ng UNITCHECK, CHECK, INIT, o END
subroutine. Ang pagpoproseso ng natitirang pila ng naturang mga gawain ay
maagang natapos.

Maling [] saklaw na "%s" sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp)(F) Ang hanay ng klase ng character ay dapat magsimula at magtapos sa literal na character, hindi
isa pang klase ng character tulad ng "\d" o "[:alpha:]". Ang "-" sa iyong maling hanay ay
binibigyang kahulugan bilang literal na "-". Sa isang "(?[...])" construct, ito ay isang error, sa halip
kaysa sa isang babala. Pag-isipang banggitin ang "-", "\-". Ang <-- DITO ay nagpapakita kung nasaan
ang regular na expression ang problema ay natuklasan. Tingnan ang perlre.

Malalang VMS error (status=%d) sa %s, line %d
(P) Isang error na kakaiba sa VMS. May hindi kanais-nais na nangyari sa isang serbisyo ng VMS system o
RTL routine; Ang katayuan sa paglabas ni Perl ay dapat magbigay ng higit pang mga detalye. Ang filename sa "sa %s"
at ang numero ng linya sa "line %d" ay nagsasabi sa iyo kung aling seksyon ng Perl source code ang
namimighati

Ang fcntl ay hindi ipinatupad
(F) Ang iyong makina ay tila hindi nagpapatupad fcntl(). Ano ito, isang PDP-11 o
isang bagay?

Nagbalik ang FETCHSIZE ng negatibong halaga
(F) Isang nakatali na hanay na sinasabing may negatibong bilang ng mga elemento, na hindi posible.

Masyadong malawak ang field sa 'u' na format sa pack
(W pack) Ang bawat linya sa isang uuencoded string ay nagsisimula sa isang indicator ng haba na hindi magagawa
i-encode ang mga halaga sa itaas 63. Kaya walang saysay na humiling ng haba ng linya na mas malaki kaysa
na. Ang Perl ay kikilos na parang tinukoy mo ang "u63" bilang format.

Binuksan lang ang filehandle %s para sa input
(W io) Sinubukan mong magsulat sa isang read-only na filehandle. Kung sinadya mo itong basahin-
sumulat ng filehandle, kailangan mong buksan ito gamit ang "+<" o "+>" o "+>>" sa halip na gamit ang "<"
o wala. Kung balak mo lang isulat ang file, gamitin ang ">" o ">>". Tingnan ang "bukas" sa
perlfunc.

Binuksan lang ang filehandle %s para sa output
(W io) Sinubukan mong magbasa mula sa isang filehandle na binuksan lamang para sa pagsusulat, Kung sinadya mo ito
para maging read/write filehandle, kailangan mong buksan ito gamit ang "+<" o "+>" o "+>>"
sa halip na may ">". Kung balak mo lang magbasa mula sa file, gamitin ang "<". Tingnan ang "bukas"
sa perlfunc. Ang isa pang posibilidad ay sinubukan mong buksan ang filedescriptor 0 (din
kilala bilang STDIN) para sa output (baka isinara mo ang STDIN kanina?).

Ang filehandle %s ay muling binuksan bilang %s para lamang sa input
(W io) Nagbukas ka para sa pagbabasa ng filehandle na nakakuha ng parehong filehandle id bilang STDOUT
o STDERR. Nangyari ito dahil isinara mo ang STDOUT o STDERR dati.

Ang Filehandle STDIN ay muling binuksan bilang %s para lamang sa output
(W io) Nagbukas ka para sa pagsusulat ng filehandle na nakakuha ng parehong filehandle id bilang STDIN.
Nangyari ito dahil isinara mo ang STDIN dati.

Ang huling $ ay dapat na \$ o $name
(F) Dapat mo na ngayong magpasya kung ang huling $ sa isang string ay sinadya upang maging literal
dollar sign, o sinadya upang ipakilala ang isang variable na pangalan na nawawala. Kaya
kailangan mong ilagay ang alinman sa backslash o ang pangalan.

kawan() sa saradong filehandle %s
(W closed) Ang filehandle na sinusubukan mong gawin kawan() ilang oras na nagsara
bago ngayon. Suriin ang iyong daloy ng kontrol. kawan() gumagana sa filehandles. Ikaw ba
sinusubukang tumawag kawan() sa isang dirhandle na may parehong pangalan?

Hindi winakasan ang format
(F) Ang isang format ay dapat wakasan ng isang linya na may nag-iisang tuldok. Nakarating si Perl sa dulo ng
iyong file nang hindi nakakahanap ng ganoong linya.

Ang format na %s ay muling tinukoy
(W redefine) Muling tinukoy mo ang isang format. Upang sugpuin ang babalang ito, sabihin

{
walang babala 'muling tukuyin';
eval "format NAME =...";
}

Natagpuan = sa kondisyon, dapat na ==
(W syntax) Sabi mo

kung ($foo = 123)

kapag sinadya mo

kung ($foo == 123)

(o isang bagay na tulad nito).

Nakita ang %s kung saan inaasahan ang operator
(S syntax) Alam ng Perl lexer kung aasahan ang isang termino o isang operator. Kung nakikita nito
kung ano ang alam nitong termino noong inaasahan nitong makakita ng operator, ibinibigay nito sa iyo ito
babala. Karaniwang ipinapahiwatig nito na ang isang operator o delimiter ay tinanggal, tulad ng a
tuldok-kuwit.

ibinalik ng gdbm store ang %d, errno %d, key na "%s"
(S) Isang babala mula sa extension ng GDBM_File na nabigo ang isang tindahan.

hindi ipinatupad ang gethostent
(F) Ang iyong C library ay tila hindi nagpapatupad gethostent(), malamang dahil kung ito
ginawa, ito ay pakiramdam ng moral na obligasyon na ibalik ang bawat hostname sa Internet.

makakuha ng%pangalan() sa saradong socket %s
(W closed) Sinubukan mong kumuha ng socket o peer socket na pangalan sa isang closed socket. ginawa mo ba
kalimutang suriin ang ibinalik na halaga ng iyong socket () tumawag ka?

ibinalik ng getpwnam ang di-wastong UIC %#o para sa user na "%s"
(S) Isang babala na kakaiba sa VMS. Ang tawag sa "sys$getuai" na pinagbabatayan ng "getpwnam"
nagbalik ang operator ng di-wastong UIC.

getsockopt() sa saradong socket %s
(W closed) Sinubukan mong kumuha ng opsyon sa socket sa closed socket. Nakalimutan mo na ba
suriin ang return value ng iyong socket () tumawag? Tingnan ang "getsockopt" sa perlfunc.

ang ibinigay ay eksperimental
(S experimental::smartmatch) Ang "ibinigay" ay depende sa smartmatch, na eksperimental, kaya
maaaring magbago o maalis pa ang pag-uugali nito sa anumang paglabas ng perl sa hinaharap. Tingnan ang
paliwanag sa ilalim ng "Mga Detalye ng Eksperimento sa ibinigay at kailan" sa perlsyn.

Ang pandaigdigang simbolo na "%s" ay nangangailangan ng tahasang pangalan ng package (nakalimutan mo bang ideklara ang "aking %s"?)
(F) Sinabi mo na "gumamit ng mahigpit" o "gumamit ng mahigpit na mga vars", na nagpapahiwatig na ang lahat ng mga variable
ay dapat na leksikal na saklaw (gamit ang "aking" o "estado"), na idineklara muna gamit
"aming", o tahasang kwalipikadong sabihin kung saang package naroroon ang global variable (gamit ang
"::").

nabigo ang glob (%s)
(S glob) Nagkaroon ng problema sa (mga) panlabas na programa na ginamit para sa "glob" at
"<*.c>". Karaniwan, nangangahulugan ito na nagbigay ka ng pattern na "glob" na naging sanhi ng
panlabas na programa upang mabigo at lumabas na may nonzero na katayuan. Kung ang mensahe ay nagpapahiwatig
na ang abnormal na paglabas ay nagresulta sa isang coredump, maaari rin itong mangahulugan na ang iyong csh (C
shell) ay nasira. Kung gayon, dapat mong baguhin ang lahat ng mga variable na nauugnay sa csh
config.sh: Kung mayroon kang tcsh, gawin ang mga variable na sumangguni dito na parang csh (hal.
"full_csh='/usr/bin/tcsh'"); kung hindi, gawin silang walang laman (maliban sa "d_csh"
dapat 'undef') para isipin ni Perl na nawawala ang csh. Sa alinmang kaso, pagkatapos
pag-edit ng config.sh, patakbuhin ang "./Configure -S" at muling itayo ang Perl.

Hindi natapos ang glob
(F) Ang lexer ay nakakita ng isang kaliwang angle bracket sa isang lugar kung saan ito ay umaasa ng isang termino, kaya
hinahanap nito ang katumbas na right angle bracket, at hindi ito nahanap. Mga pagkakataon
nag-iwan ka ba ng ilang kinakailangang panaklong kanina sa linya, at talagang sinadya mo a
"mas mababa sa".

Nabigo ang gmtime(%f).
(W overflow) Tinawag mo ang "gmtime" na may numerong hindi nito kayang hawakan: masyadong malaki,
masyadong maliit, o NaN. Ang ibinalik na halaga ay "undef".

masyadong malaki ang gmtime(%f).
(W overflow) Tinawag mo ang "gmtime" na may numerong mas malaki kaysa sa maaasahan nito
hawakan at ang "gmtime" ay malamang na nagbalik ng maling petsa. Na-trigger din ang babalang ito
na may NaN (ang espesyal na hindi-isang-numero na halaga).

masyadong maliit ang gmtime(%f).
(W overflow) Tinawag mo ang "gmtime" na may numerong mas maliit kaysa sa maaasahan nito
hawakan at ang "gmtime" ay malamang na nagbalik ng maling petsa.

Nagkaroon ng error mula sa DosAllocMem
(P) Isang error na kakaiba sa OS/2. Malamang na gumagamit ka ng hindi na ginagamit na bersyon ng
Perl, at hindi ito dapat mangyari.

dapat may label ang goto
(F) Hindi tulad ng "susunod" o "huling", hindi ka pinapayagang pumunta sa isang hindi natukoy na
patutunguhan. Tingnan ang "goto" sa perlfunc.

Pumunta sa hindi natukoy na subroutine%s
(F) Sinubukan mong tumawag ng subroutine na may "goto &sub" syntax, ngunit ang ipinahiwatig
Ang subroutine ay hindi pa natukoy, o kung ito ay, ito ay mula noon ay hindi natukoy.

Ang pangalan ng grupo ay dapat magsimula sa isang hindi digit na character ng salita sa regex; minarkahan ng <-- DITO sa
MS/
(F) Dapat sundin ng mga pangalan ng grupo ang mga panuntunan para sa mga perl identifier, ibig sabihin, dapat silang magsimula
na may hindi digit na karakter ng salita. Ang karaniwang dahilan ng error na ito ay ang paggamit ng (?&0) sa halip
ng (?0). Tingnan ang perlre.

()-pangkat ay nagsisimula sa isang bilang
(F) Nagsimula ang isang ()-grupo sa isang bilang. Ang isang bilang ay dapat sumunod sa isang bagay: a
template character o isang ()-group. Tingnan ang "pack" sa perlfunc.

May mga error sa compilation ang %s.
(F) Ang huling buod na mensahe kapag nabigo ang isang "perl -c".

Kinailangang lumikha ng %s nang hindi inaasahan
(S panloob) Isang nakagawiang humingi ng isang simbolo mula sa isang talahanayan ng simbolo na dapat magkaroon
umiral na, ngunit sa ilang kadahilanan ay hindi ito nangyari, at kailangang gawin sa isang emergency
batayan upang maiwasan ang isang core dump.

Masyadong maraming error ang %s
(F) Ang parser ay sumuko sa pagsubok na i-parse ang program pagkatapos ng 10 mga error. Dagdag pa
ang mga mensahe ng error ay malamang na hindi nagbibigay-kaalaman.

Ang pagkakaroon ng higit sa isang /%c regexp modifier ay hindi na ginagamit
(D hindi na ginagamit, regexp) Ginamit mo ang nakasaad na regular na expression pattern modifier sa
hindi bababa sa dalawang beses sa isang string ng mga modifier. Ito ay hindi na ginagamit upang gawin ito sa ito
partikular na modifier, upang payagan ang mga extension sa hinaharap sa wikang Perl.

Hexadecimal float: exponent overflow
(W overflow) Ang hexadecimal floating point ay may mas malaking exponent kaysa sa floating
mga sumusuporta sa punto.

Hexadecimal float: exponent underflow
(W overflow) Ang hexadecimal floating point ay may mas maliit na exponent kaysa sa lumulutang
mga sumusuporta sa punto.

Hexadecimal float: panloob na error (%s)
(F) May nangyaring hindi maganda sa paghawak ng hexadecimal float.

Hexadecimal float: overflow ng mantissa
(W overflow) Ang literal na hexadecimal floating point ay may mas maraming bit sa mantissa (ang
bahagi sa pagitan ng 0x at exponent, na kilala rin bilang fraction o significand)
kaysa sa sinusuportahan ng floating point.

Hexadecimal float: pagkawala ng katumpakan
(W overflow) Ang hexadecimal floating point ay may panloob na mas maraming digit kaysa sa maaari
output. Ito ay maaaring sanhi ng hindi sinusuportahang mahabang double format, o ng 64-bit integer
hindi magagamit (kinakailangan upang makuha ang mga digit sa ilalim ng ilang mga pagsasaayos).

Hexadecimal float: hindi sinusuportahang mahabang double format
(F) Na-configure mo ang Perl na gumamit ng mahahabang doble ngunit ang mga panloob ng mahabang doble
hindi alam ang format; samakatuwid ang hexadecimal float output ay imposible.

Hexadecimal number > 0xffffffff non-portable
(W portable) Ang hexadecimal number na iyong tinukoy ay mas malaki sa 2**32-1 (4294967295)
at samakatuwid ay hindi portable sa pagitan ng mga system. Tingnan ang perlport para sa higit pa sa portability
alalahanin.

Masyadong mahaba ang identifier
(F) Nililimitahan ng Perl ang mga identifier (mga pangalan para sa mga variable, function, atbp.) sa humigit-kumulang 250
mga character para sa mga simpleng pangalan, at medyo higit pa para sa mga tambalang pangalan (tulad ng $A::B).
Lumampas ka sa mga limitasyon ni Perl. Ang mga hinaharap na bersyon ng Perl ay malamang na alisin ang mga ito
di-makatwirang mga limitasyon.

Hindi pinapansin ang zero na haba \N{} sa klase ng character sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) Ang pinangalanang Unicode na character na escapes ("\N{...}") ay maaaring magbalik ng zero-length
pagkakasunod-sunod. Kapag ang ganitong pagtakas ay ginamit sa isang klase ng karakter hindi maganda ang pag-uugali nito
tinukoy. Suriin kung ang tamang pagtakas ay ginamit, at ang tamang charname
nasa saklaw ang handler.

Ilegal na binary digit %s
(F) Gumamit ka ng digit maliban sa 0 o 1 sa isang binary na numero.

Binalewala ang iligal na binary digit %s
(W digit) Maaaring sinubukan mong gumamit ng digit maliban sa 0 o 1 sa isang binary na numero.
Ang interpretasyon ng binary number ay huminto bago ang nakakasakit na digit.

Ilegal na character pagkatapos ng '_' sa prototype para sa %s : %s
(W illegalproto) May nakitang ilegal na karakter sa isang prototype na deklarasyon. Ang '_'
sa isang prototype ay dapat na sundan ng isang ';', na nagpapahiwatig na ang iba pang mga parameter ay
opsyonal, o isa sa '@' o '%', dahil tatanggap ang dalawang iyon ng 0 o higit pang pinal
parameter.

Ilegal na karakter \%o (carriage return)
(F) Karaniwang tinatrato ng Perl ang mga carriage return sa teksto ng programa gaya ng ginagawa nito sa iba
whitespace, na nangangahulugang hindi mo dapat makita ang error na ito kapag ginawa ang Perl gamit ang
karaniwang mga pagpipilian. Para sa ilang kadahilanan, ang iyong bersyon ng Perl ay lumilitaw na binuo
kung wala itong suporta. Makipag-usap sa iyong Perl administrator.

Ilegal na character sa prototype para sa %s : %s
(W illegalproto) May nakitang ilegal na karakter sa isang prototype na deklarasyon. Legal
ang mga character sa mga prototype ay $, @, %, *, ;, [, ], &, \, at +. Marahil ikaw ay
sinusubukang magsulat ng subroutine signature ngunit hindi muna pinagana ang feature na iyon ("use
feature 'signatures'"), kaya ang iyong lagda ay sa halip ay binigyang-kahulugan bilang isang masamang prototype.

Ilegal na deklarasyon ng hindi kilalang subroutine
(F) Kapag ginagamit ang "sub" na keyword upang bumuo ng hindi kilalang subroutine, kailangan mong palaging
tukuyin ang isang bloke ng code. Tingnan ang perlsub.

Ilegal na deklarasyon ng subroutine %s
(F) Ang isang subroutine ay hindi naideklara nang tama. Tingnan ang perlsub.

Ilegal na paghahati ng zero
(F) Sinubukan mong hatiin ang isang numero sa 0. Maaaring may mali sa iyong lohika, o
kailangan mong maglagay ng kondisyon para mabantayan laban sa walang kabuluhang input.

Binalewala ang iligal na hexadecimal digit %s
(W digit) Maaaring sinubukan mong gumamit ng character maliban sa 0 - 9 o A - F, a - f sa isang
hexadecimal na numero. Ang interpretasyon ng hexadecimal number ay huminto bago ang
ilegal na karakter.

Ilegal na modulus zero
(F) Sinubukan mong hatiin ang isang numero sa 0 upang makuha ang natitira. Karamihan sa mga numero ay hindi kumukuha
sa mabait na ito.

Ilegal na bilang ng mga bit sa vec
(F) Ang bilang ng mga bit sa vec() (ang ikatlong argumento) ay dapat na kapangyarihan ng dalawa mula 1 hanggang
32 (o 64, kung sinusuportahan iyon ng iyong platform).

Ilegal na octal digit %s
(F) Gumamit ka ng 8 o 9 sa isang octal na numero.

Binalewala ang iligal na octal digit na %s
(W digit) Maaaring sinubukan mong gumamit ng 8 o 9 sa isang octal na numero. Interpretasyon ng
huminto ang octal number bago ang 8 o 9.

Ilegal na pattern sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Sumulat ka ng isang katulad

(?+foo)

Ang "+" ay wasto lamang kapag sinusundan ng mga digit, na nagsasaad ng isang kumukuhang grupo. Tingnan mo
"(?PARNO)".

Ilegal na suidscript
(F) Ang script na pinapatakbo sa ilalim ng suiperl ay kahit papaano ay ilegal.

Ilegal na switch sa PERL5OPT: -%c
(X) Ang PERL5OPT environment variable ay maaari lamang gamitin upang itakda ang mga sumusunod na switch:
-[CDIMUdmtw].

Hindi nabuong halaga ng kapaligiran ng CRTL na "%s"
(W internal) Isang babala na kakaiba sa VMS. Sinubukan ni Perl na basahin ang panloob ng CRTL
environ array, at nakatagpo ng isang elemento na walang "=" delimiter na ginamit upang paghiwalayin
mga susi mula sa mga halaga. Ang elemento ay hindi pinapansin.

Maling nabuong mensahe sa prime_env_iter: |%s|
(W internal) Isang babala na kakaiba sa VMS. Sinubukan ni Perl na magbasa ng isang lohikal na pangalan o CLI
kahulugan ng simbolo kapag naghahanda na umulit sa %ENV, at hindi nakita ang inaasahan
delimiter sa pagitan ng susi at halaga, kaya hindi pinansin ang linya.

(sa paglilinis) %s
(W misc) Ang prefix na ito ay karaniwang nagpapahiwatig na a DESTROY() paraan itinaas ang ipinahiwatig
pagbubukod. Dahil ang mga destructors ay karaniwang tinatawag ng system sa mga arbitrary na punto
sa panahon ng pagpapatupad, at madalas na maraming beses, ang babala ay inilabas nang isang beses lamang
para sa anumang bilang ng mga pagkabigo na kung hindi man ay magreresulta sa parehong mensahe
inulit

Ang pagkabigo ng mga callback ng user na ipinadala gamit ang flag na "G_KEEPERR" ay maaari ding magresulta sa
babalang ito. Tingnan ang "G_KEEPERR" sa perlcall.

Hindi kumpletong expression sa loob ng '(?[ ])' sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Nagkaroon ng syntax error sa loob ng "(?[ ])". Ito ay maaaring mangyari kung ang expression
sa loob ng construct ay ganap na walang laman, o kung mayroong masyadong marami o kakaunting operand
para sa bilang ng mga operator. Si Perl ay hindi sapat na matalino upang bigyan ka ng mas tumpak
indikasyon kung ano ang mali.

Hindi pare-parehong hierarchy sa panahon ng C3 merge ng klase na '%s': nabigo ang pagsasama sa parent na '%s'
(F) Ang method resolution order (MRO) ng ibinigay na klase ay hindi C3-consistent, at ikaw
pinagana ang C3 MRO para sa klase na ito. Tingnan ang dokumentasyon ng C3 sa mro para sa higit pa
impormasyon.

Sa EBCDIC ang mga bahagi ng v-string ay hindi maaaring lumampas sa 2147483647
(F) Isang error na kakaiba sa EBCDIC. Sa panloob, ang mga v-string ay iniimbak bilang Unicode code
puntos, at naka-encode sa EBCDIC bilang UTF-EBCDIC. Ang pag-encode ng UTF-EBCDIC ay limitado sa
code point na hindi hihigit sa 2147483647 (0x7FFFFFFF).

Walang katapusang recursion sa regex
(F) Gumamit ka ng pattern na tumutukoy sa sarili nito nang hindi gumagamit ng anumang input text. Ikaw
dapat suriin ang pattern upang matiyak na ang mga recursive pattern ay kumonsumo ng text o
mabibigo.

Ang pagsisimula ng mga variable ng estado sa konteksto ng listahan na kasalukuyang ipinagbabawal
(F) Sa kasalukuyan, pinahihintulutan lamang ng pagpapatupad ng "estado" ang pagsisimula ng scalar
mga variable sa kontekstong scalar. Isulat muli ang "estado ($a) = 42" bilang "estado $a = 42" upang baguhin
mula sa listahan hanggang sa kontekstong scalar. Ang mga konstruksyon gaya ng "state (@a) = foo()" ay magiging
suportado sa hinaharap na perl release.

%%s[%s] sa kontekstong scalar ay mas mahusay na isinulat bilang $%s[%s]
(W syntax) Sa kontekstong scalar, gumamit ka ng array index/value slice (ipinahiwatig ng %)
upang pumili ng isang elemento ng isang array. Sa pangkalahatan, mas mahusay na humingi ng scalar
halaga (ipinahiwatig ng $). Ang pagkakaiba ay palaging kumikilos si $foo[&bar] na parang a
scalar, kapwa sa halagang ibinabalik nito at kapag sinusuri ang argumento nito, habang
Nagbibigay ang %foo[&bar] ng konteksto ng listahan sa subscript nito, na makakagawa ng mga kakaibang bagay kung
isang subscript lang ang inaasahan mo. Kapag tinawag sa konteksto ng listahan, ibinabalik din nito ang
index (kung ano ang ibinabalik ng &bar) bilang karagdagan sa halaga.

%%s{%s} sa kontekstong scalar na mas mahusay na isinulat bilang $%s{%s}
(W syntax) Sa kontekstong scalar, gumamit ka ng hash key/value slice (ipinahiwatig ng %) upang
pumili ng isang elemento ng isang hash. Sa pangkalahatan, mas mahusay na humingi ng scalar value
(ipinahiwatig ng $). Ang pagkakaiba ay ang $foo{&bar} ay palaging kumikilos na parang scalar,
kapwa sa halagang ibinabalik nito at kapag sinusuri ang argumento nito, habang ang @foo{&bar} at
nagbibigay ng konteksto ng listahan sa subscript nito, na maaaring gumawa ng mga kakaibang bagay kung ikaw ay
umaasa lamang ng isang subscript. Kapag tinawag sa konteksto ng listahan, ibinabalik din nito ang susi
karagdagan sa halaga.

Hindi secure na dependency sa %s
(F) Sinubukan mong gumawa ng isang bagay na hindi nagustuhan ng mekanismo ng pagdumi. Ang dumi
naka-on ang mekanismo kapag nagpapatakbo ka ng setuid o setgid, o kapag tinukoy mo -T sa
i-on ito nang tahasan. Nilagyan ng label ng mekanismo ng pagdumi ang lahat ng data na direktang nakukuha
o hindi direkta mula sa gumagamit, na itinuturing na hindi karapat-dapat sa iyong tiwala. Kung mayroon man
ang naturang data ay ginagamit sa isang "mapanganib" na operasyon, nakukuha mo ang error na ito. Tingnan ang perlsec para sa
karagdagang informasiyon.

Hindi secure na direktoryo sa %s
(F) Hindi mo magagamit sistema(), exec(), o isang piped open sa isang setuid o setgid script kung
Ang $ENV{PATH} ay naglalaman ng isang direktoryo na maaaring isulat ng mundo. Gayundin, ang PATH ay dapat
hindi naglalaman ng anumang kamag-anak na direktoryo. Tingnan ang perlsec.

Hindi secure ang $ENV{%s} habang pinapatakbo ang %s
(F) Hindi mo magagamit sistema(), exec(), o isang piped open sa isang setuid o setgid script kung
alinman sa $ENV{PATH}, $ENV{IFS}, $ENV{CDPATH}, $ENV{ENV}, $ENV{BASH_ENV} o $ENV{TERM}
ay nagmula sa data na ibinibigay (o posibleng ibigay) ng user. Ang script ay dapat
itakda ang landas sa isang kilalang halaga, gamit ang mapagkakatiwalaang data. Tingnan ang perlsec.

Hindi secure na pag-aari na tinukoy ng user %s
(F) Nakakita si Perl ng may bahid na data kapag sinusubukang mag-compile ng isang regular na expression na iyon
naglalaman ng isang tawag sa isang function ng katangian ng character na tinukoy ng gumagamit, ibig sabihin, "\p{IsFoo}" o
"\p{InFoo}". Tingnan ang "User-Defined Character Properties" sa perlunicode at perlsec.

Integer overflow sa format na string para sa %s
(F) Ang mga index at lapad na tinukoy sa format na string ng "printf()" o "sprintf()"
ay masyadong malaki. Ang mga numero ay hindi dapat umapaw sa laki ng mga integer para sa iyong
arkitektura.

Integer overflow sa %s number
(S overflow) Ang hexadecimal, octal o binary na numero na iyong tinukoy bilang a
literal o bilang argumento sa hex() or okt() ay masyadong malaki para sa iyong arkitektura, at mayroon
na-convert sa isang floating point number. Sa isang 32-bit na arkitektura ang pinakamalaking
hexadecimal, octal o binary number na kinakatawan nang walang overflow ay 0xFFFFFFFF,
037777777777, o 0b11111111111111111111111111111111 ayon sa pagkakabanggit. Tandaan na si Perl
malinaw na nagpo-promote ng lahat ng numero sa isang floating point na representasyon
panloob--napapailalim sa pagkawala ng mga error sa katumpakan sa mga susunod na operasyon.

Integer overflow sa srand
(S overflow) Ang numerong naipasa mo sa srand ay masyadong malaki para magkasya sa iyong
integer na representasyon ng arkitektura. Ang bilang ay pinalitan ng pinakamalaki
suportado ng integer (0xFFFFFFFF sa mga 32-bit na arkitektura). Nangangahulugan ito na maaari kang makakuha
mas kaunting randomness kaysa sa iyong inaasahan, dahil iba't ibang mga random na buto sa itaas ng maximum na kalooban
ibalik ang parehong pagkakasunud-sunod ng mga random na numero.

Integer overflow sa bersyon
Integer overflow sa bersyon %d
(W overflow) Masyadong malaki ang ilang bahagi ng pagsisimula ng bersyon para sa laki ng
mga integer para sa iyong arkitektura. Hindi ito babala dahil walang makatwiran
dahilan para subukan ng isang bersyon at gumamit ng elementong mas malaki kaysa sa karaniwang 2**32. Ito ay
kadalasang sanhi ng pagsubok na gumamit ng ilang kakaibang operasyong matematika bilang isang bersyon, tulad ng
100 / 9.

Panloob na sakuna sa regex; minarkahan ng <-- DITO sa m/%s/
(P) May nangyaring hindi maganda sa regular na expression parser. Ang <-- HERE ay nagpapakita
kung saan sa regular na expression ang problema ay natuklasan.

Panloob na hindi pagkakapare-pareho sa pagsubaybay sa mga vfork
(S) Isang babala na kakaiba sa VMS. Sinusubaybayan ni Perl kung ilang beses kang tumawag
"fork" at "exec", upang matukoy kung ang kasalukuyang tawag sa "exec" ay dapat makaapekto sa
kasalukuyang script o isang subprocess (tingnan ang "exec LIST" sa perlvms). Kahit papaano, ang bilang na ito ay mayroon
maging scrambled, kaya si Perl ay gumagawa ng hula at tinatrato ang "exec" na ito bilang isang kahilingan sa
wakasan ang Perl script at isagawa ang tinukoy na command.

panloob % p ay maaaring sumalungat sa hinaharap na mga extension ng printf
(S internal) Ang panloob na gawain ng Perl na humahawak sa "printf" at "sprintf" na pag-format
sumusunod sa bahagyang naiibang hanay ng mga panuntunan kapag tinawag mula sa C o XS code.
Sa partikular, ang mga format na binubuo ng mga digit na sinusundan ng "p" (hal., "%7p") ay nakalaan
para magamit sa hinaharap. Kung nakita mo ang mensaheng ito, sinubukan ng isang XS module na tawagan ang routine na iyon
na may isang nakalaan na format.

Panloob na urp sa regex; minarkahan ng <-- DITO sa m/%s/
(P) May nangyaring hindi maganda sa regular na expression parser. Ang <-- HERE ay nagpapakita
kung saan sa regular na expression ang problema ay natuklasan.

Ang %s (...) ay binibigyang kahulugan bilang function
(W syntax) Nasiraan mo ang panuntunang nagsasabing sinusundan ng anumang operator ng listahan
Ang mga panaklong ay nagiging isang function, kasama ang lahat ng mga argumento ng mga operator ng listahan na matatagpuan sa loob
ang mga panaklong. Tingnan ang "Mga Tuntunin at Mga Operator ng Listahan (Pakaliwa)" sa perlop.

Sa '(?...)', ang '(' at '?' ay dapat na magkatabi sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang dalawang-character na sequence na "(?" sa kontekstong ito sa isang pattern ng regular na expression
dapat ay isang hindi mahahati na token, na walang namamagitan sa pagitan ng "(" at ang "?",
ngunit pinaghiwalay mo sila ng whitespace.

Di-wastong katangian ng %s: %s
(F) Ang ipinahiwatig na katangian para sa isang subroutine o variable ay hindi nakilala ng Perl o
ng isang handler na ibinigay ng user. Tingnan ang mga katangian.

Di-wastong %s attribute: %s
(F) Ang mga ipinahiwatig na katangian para sa isang subroutine o variable ay hindi nakilala ng Perl
o ng isang handler na ibinigay ng user. Tingnan ang mga katangian.

Di-wastong character sa charname alias kahulugan; minarkahan ng <-- DITO sa '%s
(F) Sinubukan mong gumawa ng custom na alias para sa pangalan ng character, na may opsyong ":alias".
upang "gumamit ng mga charnames" at ang tinukoy na character sa ipinahiwatig na pangalan ay hindi wasto. Tingnan mo
"CUSTOM ALIASES" sa mga charnames.

Di-wastong \0 character sa %s para sa %s: %s\0%s
(W syscalls) Naka-embed na \0 character sa mga pathname o iba pang argumento ng system call
gumawa ng babala sa 5.20. Ang mga bahagi pagkatapos ng \0 ay dating hindi pinansin ng system
tawag.

Di-wastong character sa \N{...}; minarkahan ng <-- DITO sa \N{%s}
(F) Ilang character lang ang valid para sa mga pangalan ng character. Ang ipinahiwatig ay hindi.
Tingnan ang "CUSTOM ALIASES" sa mga charnames.

Di-wastong conversion sa %s: "%s"
(W printf) Hindi naiintindihan ni Perl ang ibinigay na conversion ng format. Tingnan ang "sprintf" sa
perlfunc.

Di-wastong pagtakas sa tinukoy na pag-encode sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp)(F) Ang numeric escape (halimbawa "\xHH") ng value na < 256 ay hindi tumutugma
sa iisang character sa pamamagitan ng conversion mula sa encoding na tinukoy ng
encoding pragma. Ang pagtakas ay pinalitan ng REPLACEMENT CHARACTER (U+FFFD) sa halip,
maliban sa loob ng "(?[ ])", kung saan ito ay isang nakamamatay na error. Ang <-- HERE ay nagpapakita kung nasaan
sa regular na ekspresyon ang pagtakas ay natuklasan.

Di-wastong hexadecimal na numero sa \N{U+...}
Di-wastong hexadecimal na numero sa \N{U+...} sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang character constant na kinakatawan ng "..." ay hindi wastong hexadecimal na numero.
Maaaring ito ay walang laman, o sinubukan mong gumamit ng character maliban sa 0 - 9 o A - F, a - f
sa isang hexadecimal na numero.

Di-wastong pangalan ng module %s na may -%c na opsyon: naglalaman ng solong ':'
(F) Ang argumento ng module sa perl's -m at -M Ang mga opsyon sa command-line ay hindi maaaring maglaman ng isa
mga colon sa pangalan ng module, ngunit sa mga argumento lamang pagkatapos ng "=". Sa ibang salita,
-MFoo::Bar=:baz ay ok, ngunit -MFoo:Bar=baz ay hindi.

Di-wastong pangalan ng mro: '%s'
(F) Sinubukan mong "mro::set_mro("classname", "foo")" o "gamitin ang mro 'foo'", kung saan ang "foo" ay
hindi isang wastong method resolution order (MRO). Sa kasalukuyan, ang tanging mga wastong suportado
ay "dfs" at "c3", maliban kung nag-load ka ng module na isang MRO plugin. Tingnan mo si mro at
perlmroapi.

Di-wastong negatibong numero (%s) sa chr
(W utf8) Nagpasa ka ng negatibong numero sa "chr". Hindi wasto ang mga negatibong numero
mga numero ng character, kaya ibinabalik nito ang kapalit na karakter ng Unicode (U+FFFD).

di-wastong opsyon -D%c, gamitin ang -D'' upang makita ang mga pagpipilian
(S debugging) Tinawag si Perl na may mga di-wastong mga flag ng debugger. Tawagan ang perl gamit ang -D
opsyon na walang mga flag upang makita ang listahan ng mga katanggap-tanggap na halaga. Tingnan din ang "-Dletters" sa
perlrun.

Di-wastong quantifier sa {,} sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang pattern ay mukhang isang {min,max} quantifier, ngunit ang min o max ay hindi maaaring
na-parse bilang isang wastong numero - alinman ito ay may mga nangungunang zero, o ito ay kumakatawan sa masyadong malaki a
numero upang makayanan. Ang <-- HERE ay nagpapakita kung saan sa regular na expression ang problema
ay nadiskubre. Tingnan ang perlre.

Di-wastong [] range na "%s" sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang saklaw na tinukoy sa isang klase ng character ay may pinakamababang character na mas malaki kaysa sa
pinakamataas na karakter. Ang isang posibilidad ay nakalimutan mo ang "{}" mula sa iyong pagtatapos
"\x{}" - "\x" na walang curly braces ay maaari lamang umabot sa "ff". Ang <-- HERE ay nagpapakita
kung saan sa regular na expression ang problema ay natuklasan. Tingnan ang perlre.

Di-wastong hanay na "%s" sa operator ng transliterasyon
(F) Ang hanay na tinukoy sa tr/// o y/// operator ay may pinakamababang character na mas mataas
kaysa sa pinakamataas na karakter. Tingnan ang perlop.

Di-wastong separator character %s sa listahan ng attribute
(F) May nakita maliban sa colon o whitespace sa pagitan ng mga elemento ng an
listahan ng katangian. Kung ang nakaraang katangian ay may nakakulong na listahan ng parameter, marahil
masyadong maagang natapos ang listahang iyon. Tingnan ang mga katangian.

Di-wastong separator character %s sa PerlIO layer specification %s
(W layer) Kapag nagtutulak ng mga layer papunta sa Perl I/O system, isang bagay maliban sa colon
o nakita ang whitespace sa pagitan ng mga elemento ng isang listahan ng layer. Kung ang nakaraan
Ang attribute ay may nakakulong na listahan ng parameter, marahil ang listahang iyon ay winakasan din
lalong madaling panahon.

Di-wastong format ng mahigpit na bersyon (%s)
(F) Ang isang numero ng bersyon ay hindi nakakatugon sa "mahigpit" na pamantayan para sa mga bersyon. Isang "mahigpit"
ang numero ng bersyon ay isang positibong decimal na numero (integer o decimal-fraction) na wala
exponentiation o kung hindi ay isang dotted-decimal v-string na may nangungunang 'v' na character at at
hindi bababa sa tatlong sangkap. Ipinapahiwatig ng naka-parentesis na teksto kung aling pamantayan ang hindi natugunan.
Tingnan ang module ng bersyon para sa higit pang mga detalye sa mga pinapayagang format ng bersyon.

Di-wastong uri '%s' sa %s
(F) Ang ibinigay na karakter ay hindi wastong pack o uri ng unpack. Tingnan ang "pack" sa perlfunc.

(W) Ang ibinigay na character ay hindi wastong pack o unpack type ngunit dati ay tahimik
hindi pinansin

Di-wastong format ng bersyon (%s)
(F) Hindi naabot ng numero ng bersyon ang pamantayang "lax" para sa mga bersyon. Isang "lax" na bersyon
ang numero ay isang positibong decimal na numero (integer o decimal-fraction) na wala
exponentiation o kaya naman ay isang dotted-decimal v-string. Kung ang v-string ay may mas kaunti sa
tatlong bahagi, dapat itong magkaroon ng nangungunang 'v' na karakter. Kung hindi, ang nangungunang 'v' ay
opsyonal. Ang mga bersyon ng decimal at dotted-decimal ay maaaring may sumusunod na "alpha"
component na pinaghihiwalay ng isang underscore na character pagkatapos ng fractional o dotted-decimal
sangkap. Ipinapahiwatig ng naka-parentesis na teksto kung aling pamantayan ang hindi natugunan. Tingnan ang
module ng bersyon para sa higit pang mga detalye sa mga pinapayagang format ng bersyon.

Di-wastong bersyon object
(F) Ang panloob na istraktura ng object ng bersyon ay hindi wasto. Marahil ang mga panloob
ay binago nang direkta sa ilang paraan o isang arbitraryong sanggunian ay binasbasan sa
"bersyon" na klase.

Sa '(*VERB...)', ang '(' at '*' ay dapat na magkatabi sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang dalawang-character na sequence na "(*" sa kontekstong ito sa isang pattern ng regular na expression
dapat ay isang hindi mahahati na token, na walang namamagitan sa pagitan ng "(" at ang "*",
pero pinaghiwalay mo sila.

hindi ipinatupad ang ioctl
(F) Ang iyong makina ay tila hindi nagpapatupad ioctl(), na medyo kakaiba para sa isang
makina na sumusuporta sa C.

ioctl() sa hindi pa nabubuksang %s
(W unopen) Sinubukan mo ioctl() sa isang filehandle na hindi nabuksan. Suriin ang iyong
kontrol ng daloy at bilang ng mga argumento.

Hindi available ang mga layer ng IO (tulad ng '%s').
(F) Ang iyong Perl ay hindi na-configure upang magkaroon ng PerlIO, at samakatuwid ay hindi mo magagamit ang IO
mga layer. Upang magkaroon ng PerlIO, dapat na i-configure ang Perl sa 'useperlio'.

Hindi ipinatupad ang IO::Socket::atmark sa arkitektura na ito
(F) Ang iyong makina ay hindi nagpapatupad ng sockatmark() functionality, ni bilang isang sistema
tawag o isang ioctl na tawag (SIOCATMARK).

Ang '%s' ay isang hindi kilalang bound type sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ginamit mo ang "\b{...}" o "\B{...}" at ang "..." ay hindi alam ni Perl. Ang kasalukuyan
ang mga valid ay ibinibigay sa "\b{}, \b, \B{}, \B" sa perlrebackslash.

Ang "%s" ay mas malinaw na isinulat bilang "%s" sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) (sa ilalim lamang ng "use re 'strict'" o sa loob ng "(?[...])")

Tinukoy mo ang isang character na may ibinigay na mas malinaw na paraan ng pagsulat nito, at alin
portable din sa mga platform na tumatakbo na may iba't ibang set ng character.

Hindi na sinusuportahan ang $*
(D deprecated, syntax) Ang espesyal na variable na $*, na hindi na ginagamit sa mga mas lumang perl, ay naging
inalis noong 5.10.0 at hindi na sinusuportahan. Sa mga nakaraang bersyon ng perl ang paggamit
ng $* pinagana o hindi pinagana ang multi-line na pagtutugma sa loob ng isang string.

Sa halip na gumamit ng $* dapat mong gamitin ang "/m" (at maaaring "/s") regexp modifiers. Ikaw
maaaring paganahin ang "/m" para sa isang lexical na saklaw (kahit isang buong file) na may "use re '/m'". (Sa mas matanda
mga bersyon: kapag ang $* ay naitakda sa isang tunay na halaga, ang lahat ng mga regular na expression ay kumilos na parang
isinulat ang mga ito gamit ang "/m".)

Hindi na sinusuportahan ang $#
(D hindi na ginagamit, syntax) Ang espesyal na variable na $#, na hindi na ginagamit sa mas lumang mga perl, ay naging
inalis noong 5.10.0 at hindi na sinusuportahan. Dapat mong gamitin ang printf/sprintf
function sa halip.

Ang '%s' ay hindi isang sanggunian ng code
(W overload) Ang pangalawa (ikaapat, ikaanim, ...) argument ng overload::constant ay kailangang
maging isang sanggunian ng code. Alinman sa isang hindi kilalang subroutine, o isang reference sa isang subroutine.

Ang '%s' ay hindi isang overloadable na uri
(W overload) Sinubukan mong mag-overload ng pare-parehong uri na hindi alam ng overload package.

-ginamit ko nang walang mga filename sa command line, nagbabasa mula sa STDIN
(S inplace) Ang "-i" na opsyon ay naipasa sa command line, na nagpapahiwatig na ang script
ay nilayon upang i-edit ang mga file sa lugar, ngunit walang mga file na ibinigay. Ito ay karaniwang a
pagkakamali, dahil ang pag-edit sa STDIN sa lugar ay hindi makatuwiran, at maaaring nakakalito dahil
maaari nitong gawing parang nakabitin ang perl kapag sinusubukan lang nitong basahin
STDIN. Dapat kang magpasa ng filename para i-edit, o alisin ang "-i" sa command
linya. Tingnan ang perlrun para sa higit pang mga detalye.

Junk sa dulo ng regexp sa regex m/%s/
(P) Ang regular na expression parser ay nalilito.

Ang mga susi sa sanggunian ay pang-eksperimento
(S experimental::autoderef) Ang "mga key" na may scalar argument ay eksperimental at maaaring
baguhin o alisin sa hinaharap na bersyon ng Perl. Kung nais mong kunin ang panganib sa paggamit
ang tampok na ito, huwag paganahin ang babalang ito:

walang babala "experimental::autoderef";

Hindi nakita ang label para sa "huling %s"
(F) Pinangalanan mo ang isang loop na aalisin, ngunit sa kasalukuyan ay wala ka sa loop ng pangalang iyon,
hindi kahit bilangin mo kung saan ka tinawag. Tingnan ang "huling" sa perlfunc.

Hindi nakita ang label para sa "susunod na %s"
(F) Pinangalanan mo ang isang loop upang magpatuloy, ngunit sa kasalukuyan ay wala ka sa loop ng pangalang iyon, hindi
kahit bilangin mo kung saan ka tinawag. Tingnan ang "huling" sa perlfunc.

Hindi nakita ang label para sa "redo %s"
(F) Pinangalanan mo ang isang loop upang i-restart, ngunit sa kasalukuyan ay wala ka sa loop ng pangalang iyon, hindi
kahit bilangin mo kung saan ka tinawag. Tingnan ang "huling" sa perlfunc.

nabigo ang pag-alis sa epektibong %s
(F) Habang nasa ilalim ng "use filetest" pragma, inililipat ang tunay at epektibong mga uid o
nabigo ang gids.

haba/code pagkatapos ng dulo ng string sa i-unpack
(F) Habang nag-a-unpack, naubos na ang string buffer kapag may nag-unpack na haba/code
Sinubukan ng kumbinasyon na makakuha ng higit pang data. Nagreresulta ito sa hindi natukoy na halaga para sa
haba. Tingnan ang "pack" sa perlfunc.

haba() ginamit sa %s (ang ibig mo bang sabihin ay "scalar(%s)"?)
(W syntax) Ginamit mo haba() sa alinman sa isang array o isang hash kapag malamang na gusto mo a
bilang ng mga item.

Ang laki ng array ay maaaring makuha sa pamamagitan ng paggawa:

scalar(@array);

Ang bilang ng mga item sa isang hash ay maaaring makuha sa pamamagitan ng paggawa:

scalar(mga susi %hash);

Sinubukan ng Lexing code na ilagay ang hindi Latin-1 na character sa Latin-1 na input
(F) Sinusubukan ng isang extension na magpasok ng teksto sa kasalukuyang parse (gamit ang
lex_stuff_pvn o katulad), ngunit sinubukang magpasok ng character na hindi maaaring maging bahagi nito
ang kasalukuyang input. Ito ay isang likas na patibong ng mekanismo ng pagpupuno, at isa sa
mga dahilan para maiwasan ito. Kung saan kinakailangan na maglagay, ang pagpupuno lamang ng plain ASCII ay
inirerekumenda.

Internal na error sa Lexing code (%s)
(F) Ang Lexing code na ibinigay ng isang extension ay lumabag sa API ng lexer sa isang nakikitang paraan.

makinig () sa saradong socket %s
(W closed) Sinubukan mong makinig sa saradong socket. Nakalimutan mo bang suriin ang
ibalik ang halaga ng iyong socket () tumawag? Tingnan ang "makinig" sa perlfunc.

Hindi ipinatupad ang form ng listahan ng piped open
(F) Sa ilang mga platform, lalo na ang Windows, ang tatlo-o-higit pang-argumentong anyo ng "bukas"
ay hindi sumusuporta sa mga tubo, gaya ng "open($pipe, '|-', @args)". Gamitin ang dalawang-argumento
"open($pipe, '|prog arg1 arg2...')" form sa halip.

%s: hindi tugma ang na-load na library at perl binary (nakuha ang handshake key %p, kailangan %p)
(P) Nilo-load ang isang dynamic na library na naglo-load na ".so" o ".dll" sa prosesong iyon
ay binuo laban sa ibang build ng perl kaysa sa nasabing library ay pinagsama-sama
laban sa. Ang muling pag-install ng XS module ay malamang na ayusin ang error na ito.

Maaaring hindi gumana nang maayos ang lokal na '%s'.%s
(W locale) Ginagamit mo ang pinangalanang locale, na hindi UTF-8, at aling perl
ay natukoy na hindi ganap na tugma sa kung ano ang maaari nitong hawakan. Ang pangalawang %s ay nagbibigay ng a
dahilan.

Sa ngayon, ang pinakakaraniwang dahilan ay ang locale ay may mga character sa loob nito
kinakatawan ng higit sa isang byte. Ang tanging mga lokal na kakayanan ni Perl ay ang
Mga lokal na UTF-8. Malamang na ang tinukoy na lokal ay hindi UTF-8 para sa isang East Asian
wika tulad ng Chinese o Japanese. Kung ang lokal ay isang superset ng ASCII, ang ASCII
bahagi nito ay maaaring gumana sa Perl.

Ang ilang esensyal na hindi na ginagamit na mga lokal na hindi superset ng ASCII, pangunahin ang mga nasa ISO
646 o iba pang 7-bit na lokal, gaya ng ASMO 449, ay maaari ding magkaroon ng mga problema, depende sa
anong mga bahagi ng set ng character ng ASCII ang nabago ng lokal at ginagamit din
sa pamamagitan ng programa. Ang mensahe ng babala ay naglilista ng mga matukoy na magkasalungat na character.

Tandaan na hindi lahat ng hindi pagkakatugma ay makikita.

Kung mangyari ito sa iyo, wala kang magagawa kundi lumipat para gumamit ng iba
locale o gamitin ang Encode para isalin mula sa locale sa UTF-8; kung ito ay hindi praktikal,
binalaan ka na may mga bagay na maaaring masira.

Ang mensaheng ito ay na-output sa bawat oras na ang isang masamang lokal ay inililipat sa loob ng saklaw
ng "use locale", o sa unang posibleng maapektuhang operasyon kung ang "use locale"
nagmamana ng masama. Hindi ito itinaas para sa anumang mga operasyon mula sa POSIX module.

nabigo ang localtime(%f).
(W overflow) Tinawag mo ang "localtime" na may numerong hindi nito kayang hawakan: masyadong malaki,
masyadong maliit, o NaN. Ang ibinalik na halaga ay "undef".

masyadong malaki ang localtime(%f).
(W overflow) Tinawag mo ang "localtime" na may numerong mas malaki kaysa sa maaasahan nito
hawakan at ang "localtime" ay malamang na nagbalik ng maling petsa. Ang babalang ito ay din
na-trigger sa NaN (ang espesyal na hindi-isang-numero na halaga).

masyadong maliit ang localtime(%f).
(W overflow) Tinawag mo ang "localtime" na may numerong mas maliit kaysa sa kaya nito
mapagkakatiwalaang hawakan at ang "localtime" ay malamang na nagbalik ng maling petsa.

Tumingin sa likod ng mas mahaba kaysa sa %d na hindi ipinatupad sa regex m/%s/
(F) Sa kasalukuyan ay may limitasyon sa haba ng string na kayang hawakan ng hitsura sa likod.
Maaaring bawasan ang paghihigpit na ito sa isang release sa hinaharap.

Nawala ang katumpakan kapag %s %f ng 1
(W imprecision) Masyadong malaki ang value na sinubukan mong dagdagan o bawasan ng isa
para tumpak na mag-imbak ang pinagbabatayan na representasyon ng floating point, kaya ang target
ng "++" o "--" ay hindi nagbabago. Inilabas ni Perl ang babalang ito dahil mayroon na
inilipat mula sa mga integer patungo sa lumulutang na punto kapag ang mga halaga ay masyadong malaki para sa mga integer, at
ngayon kahit na ang floating point ay hindi sapat. Maaaring naisin mong lumipat sa paggamit ng Math::BigInt
tahasang

lstat () sa filehandle%s
(W io) Sinubukan mong gumawa ng lstat sa isang filehandle. Anong ibig sabihin mo dyan? lstat ()
may katuturan lamang sa mga filename. (Ginawa ni Perl ang isang fstat () sa halip sa filehandle.)

lvalue attribute %s natukoy nang subroutine
(W misc) Bagama't pinapayagan ito ng attributes.pm, pag-on o pag-off ng lvalue attribute
ang isang subroutine ng Perl na natukoy na ay hindi palaging gumagana nang maayos. Maaaring o
maaaring hindi gawin ang gusto mo, depende sa kung anong code ang nasa loob ng subroutine, nang eksakto
ang mga detalye ay maaaring magbago sa pagitan ng mga bersyon ng Perl. Gawin mo lang ito kung alam mo talaga kung ano
ang iyong ginagawa.

Binalewala ang katangian ng lvalue pagkatapos matukoy ang subroutine
(W misc) Gamit ang ":lvalue" declarative syntax para gawing lvalue ang subroutine ng Perl
hindi pinahihintulutan ang subroutine pagkatapos itong matukoy. Upang gawin ang subroutine na isang
lvalue subroutine, idagdag ang lvalue attribute sa kahulugan, o ilagay ang "sub foo
:lvalue;" deklarasyon bago ang kahulugan.

Tingnan din ang attributes.pm.

Ang mahiwagang mga constant ng listahan ay hindi suportado
(F) Nagtalaga ka ng mahiwagang array sa isang stash element, at pagkatapos ay sinubukan mong gamitin ang
subroutine mula sa parehong slot. Hinihiling mo kay Perl na gawin ang isang bagay na hindi nito magagawa,
ang mga detalye ay maaaring magbago sa pagitan ng mga bersyon ng Perl.

Malformed integer sa [] sa pack
(F) Sa pagitan ng mga bracket na may kasamang numeric na pag-uulit, bilang lamang ng mga digit ang pinapayagan.
Tingnan ang "pack" sa perlfunc.

Malformed integer sa [] sa unpack
(F) Sa pagitan ng mga bracket na may kasamang numeric na pag-uulit, bilang lamang ng mga digit ang pinapayagan.
Tingnan ang "pack" sa perlfunc.

Maling nabuo PERLLIB_PREFIX
(F) Isang error na kakaiba sa OS/2. Ang PERLLIB_PREFIX ay dapat na nasa anyo

prefix1;prefix2

or
prefix1 prefix2

na may walang laman na prefix1 at prefix2. Kung ang "prefix1" ay talagang isang prefix ng isang builtin
path sa paghahanap ng library, ang prefix2 ay pinapalitan. Maaaring lumitaw ang error kung ang mga bahagi ay
hindi natagpuan, o masyadong mahaba. Tingnan ang "PERLLIB_PREFIX" sa perlos2.

Maling nabuong prototype para sa %s: %s
(F) Sinubukan mong gumamit ng function na may malformed na prototype. Ang syntax ng function
ang mga prototype ay binibigyan ng maikling pagsusuri sa oras ng pag-compile para sa mga halatang error tulad ng hindi wasto
mga karakter. Ang isang mas mahigpit na pagsusuri ay tatakbo kapag ang function ay tinawag. Marahil ang
Sinusubukan ng may-akda ng function na magsulat ng subroutine na lagda ngunit hindi iyon pinagana
feature muna ("gamitin ang feature na 'signatures'"), kaya ang lagda ay sa halip ay binigyang-kahulugan
bilang isang masamang prototype.

Maling nabuong UTF-8 na character (%s)
(S utf8)(F) Natukoy ni Perl ang isang string na hindi sumusunod sa mga panuntunan sa pag-encode ng UTF-8, kahit na
kahit na naka-on ang flag ng UTF8.

Ang isang posibleng dahilan ay ang ikaw mismo ang nagtakda ng flag ng UTF8 para sa data na naisip mo
ay nasa UTF-8 ngunit hindi (ito ay halimbawa ng legacy na 8-bit na data). Upang bantayan laban sa
ito, maaari mong gamitin ang Encode::decode_utf8.

Kung gagamitin mo ang ":encoding(UTF-8)" PerlIO layer para sa input, ang mga invalid na byte sequence ay
maganda ang paghawak, ngunit kung gagamit ka ng ":utf8", ang bandila ay nakatakda nang hindi pinapatunayan ang
data, posibleng magresulta sa mensahe ng error na ito.

Tingnan din ang "Handling Malformed Data" sa Encode.

Maling nabuong UTF-8 na character kaagad pagkatapos ng '%s'
(F) Sinabi mong "gumamit ng utf8", ngunit ang file ng programa ay hindi sumusunod sa pag-encode ng UTF-8
mga tuntunin. Ang mensahe ay nagpi-print ng maayos na naka-encode na mga character bago ang una
masama. Kung pinagana ang mga babala ng "utf8," bubuo ng babala na nagbibigay ng higit pa
mga detalye tungkol sa uri ng malformation.

Ang maling porma ng UTF-8 ay ibinalik ng \N{%s} kaagad pagkatapos ng '%s'
(F) Ibinalik ng charnames handler ang mali ang pormang UTF-8.

Maling nabuong string ng UTF-8 sa '%c' na format sa pag-unpack
(F) Sinubukan mong i-unpack ang isang bagay na hindi sumusunod sa mga panuntunan sa pag-encode ng UTF-8 at
Hindi mahulaan ni perl kung paano gumawa ng higit na pag-unlad.

Maling nabuong string ng UTF-8 sa pack
(F) Sinubukan mong mag-pack ng isang bagay na hindi sumusunod sa mga panuntunan sa pag-encode at perl ng UTF-8
ay hindi mahulaan kung paano gumawa ng higit pang pag-unlad.

Maling nabuong UTF-8 string sa i-unpack
(F) Sinubukan mong i-unpack ang isang bagay na hindi sumusunod sa mga panuntunan sa pag-encode ng UTF-8 at
Hindi mahulaan ni perl kung paano gumawa ng higit na pag-unlad.

Malformed UTF-16 surrogate
(F) Akala ni Perl ay nagbabasa ito ng UTF-16 na naka-encode na data ng character ngunit habang ginagawa ito Perl
nakilala ang isang malformed Unicode surrogate.

Ang mandatory parameter ay sumusunod sa opsyonal na parameter
(F) Sa isang subroutine na lagda, sumulat ka ng isang bagay tulad ng "$a = undef, $b", na ginagawang an
opsyonal ang mas naunang parameter at mandatory ang isang mamaya. Ang mga parameter ay napunan mula sa kaliwa
sa kanan, kaya imposible para sa tumatawag na alisin ang isang naunang isa at ipasa ang isang mamaya
isa. Kung gusto mong kumilos na parang napuno ang mga parameter mula kanan hanggang kaliwa, ipahayag
ang pinakakanang opsyonal at pagkatapos ay i-shuffle ang mga parameter sa paligid ng subroutine
katawan.

Itinugma ang non-Unicode code point 0x%X laban sa Unicode property; maaaring hindi portable
(S non_unicode) Binibigyang-daan ng Perl ang mga string na maglaman ng superset ng mga puntos ng Unicode code; bawat isa
Ang code point ay maaaring kasing laki ng kung ano ang naiimbak sa isang unsigned integer sa iyong system,
ngunit ang mga ito ay maaaring hindi tanggapin ng ibang mga wika/sistema. Ang mensaheng ito ay nangyayari kapag
nagtugma ka ng string na naglalaman ng ganoong code point laban sa isang regular na expression
pattern, at ang code point ay itinugma laban sa isang Unicode property, "\p{...}" o
"\P{...}". Ang mga katangian ng Unicode ay tinukoy lamang sa mga punto ng Unicode code, kaya ang resulta
ng tugmang ito ay hindi natukoy ng Unicode, ngunit tinatrato ng Perl (nagsisimula sa v5.20) ang hindi Unicode
mga puntos ng code na parang mga karaniwang hindi nakatalagang Unicode, at tumugma sa isang ito
naaayon. Tinutukoy kung tumutugma ang isang naibigay na property sa mga code point na ito o hindi
sa "Properties na maa-access sa pamamagitan ng \p{} at \P{}" sa perluniprops.

Ang mensaheng ito ay pinipigilan (maliban kung ito ay ginawang nakamamatay) kung ito ay hindi materyal sa
mga resulta ng tugma kung ang code point ay Unicode o hindi. Halimbawa, ang ari-arian
Ang "\p{ASCII_Hex_Digit}" ay maaari lamang tumugma sa 22 character na "[0-9A-Fa-f]", kaya malinaw na lahat
iba pang mga punto ng code, Unicode o hindi, ay hindi tutugma dito. (At ang "\P{ASCII_Hex_Digit}" ay
tumugma sa bawat code point maliban sa 22 na ito.)

Ang pagtanggap sa mensaheng ito ay nagpapahiwatig na ang kinalabasan ng laban ay maaaring mangyari
kabaligtaran ng totoong nangyari. Kung sa tingin mo iyon ang kaso, maaari mong hilingin
upang gawing nakamamatay ang kategorya ng mga babala na "non_unicode"; kung sumasang-ayon ka sa desisyon ni Perl,
baka gusto mong i-off ang kategoryang ito.

Tingnan ang "Higit pa sa mga Unicode code point" sa perlunicode para sa higit pang impormasyon.

Ang %s ay tumutugma sa null string nang maraming beses sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) Ang pattern na iyong tinukoy ay magiging isang walang katapusang loop kung ang regular
hindi partikular na sinuri iyon ng expression engine. Ang <-- HERE ay nagpapakita kung nasaan
sa regular na expression ang problema ay natuklasan. Tingnan ang perlre.

Lumampas ang maximum na bilang ng mga nakabinbing signal (%u).
(F) Na-abort ang Perl dahil sa masyadong mataas na bilang ng mga nakabinbing signal. Ito ay karaniwang nagpapahiwatig
na sinubukan ng iyong operating system na maghatid ng mga signal nang napakabilis (na may napakataas
priyoridad), pinagutom ang proseso ng perl mula sa mga mapagkukunang kakailanganin nito upang maabot ang isang punto
kung saan maaari itong magproseso ng mga signal nang ligtas. (Tingnan ang "Mga Ipinagpaliban na Signal (Mga Ligtas na Signal)" sa
perlipc.)

Maaaring sumalungat ang "%s" sa nakalaan na salita sa hinaharap
(W) Ang babalang ito ay maaaring dahil sa pagpapatakbo ng perl5 script sa pamamagitan ng perl4 interpreter,
lalo na kung ang binibigyang babala ay "use" o "my".

Maaaring hindi gamitin ang '%' sa pack
(F) Hindi ka makakapag-pack ng string sa pamamagitan ng pagbibigay ng checksum, dahil ang proseso ng checksumming
nawawalan ng impormasyon, at hindi ka maaaring pumunta sa ibang paraan. Tingnan ang "unpack" sa perlfunc.

Paraan para sa operasyon %s ay hindi nakita sa package %s sa panahon ng pagpapala
(F) Isang pagtatangka ay ginawa upang tukuyin ang isang entry sa isang overloading talahanayan na hindi
lutasin sa isang wastong subroutine. Tingnan ang labis na karga.

Ang pamamaraan %s ay hindi pinahihintulutan
Tingnan ang Server error.

Maaaring isang runaway na multi-line %s string na nagsisimula sa linyang %d
(S) Isang advisory na nagsasaad na ang nakaraang error ay maaaring sanhi ng isang nawawala
delimiter sa isang string o pattern, dahil mas maaga itong natapos sa kasalukuyang
linya.

Maling _ sa numero
(W syntax) Ang isang underscore (underbar) sa isang numeric constant ay hindi naghiwalay ng dalawang digit.

Nawawalang argumento sa %s
(W nawawala) Tumawag ka ng isang function na may mas kaunting mga argumento kaysa sa iba pang mga argumento sa iyo
ibinibigay na ipinahiwatig ay kakailanganin.

Kasalukuyang inilalabas lamang kapag ang isang printf-type na format ay nangangailangan ng higit pang mga argumento kaysa noon
ibinibigay, ngunit maaaring magamit sa hinaharap para sa iba pang mga kaso kung saan maaari naming statically
matukoy na ang mga argumento sa mga function ay nawawala, hal para sa "pack" sa perlfunc
function.

Nawawalang argumento kay -%c
(F) Ang argumento sa ipinahiwatig na command line switch ay dapat sumunod kaagad pagkatapos
ang switch, nang walang intervening space.

Walang braces sa \N{}
Nawawalang braces sa \N{} sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Maling syntax ng literal na pangalan ng character na "\N{charname}" sa loob ng double-quotish
konteksto. Maaari rin itong mangyari kapag may puwang (o komento) sa pagitan ng "\N" at
ang "{" sa isang regex na may "/x" modifier. Hindi binabago ng modifier na ito ang
kinakailangan na sundin kaagad ng brace ang "\N".

Walang braces sa \o{}
(F) Ang isang "\o" ay dapat na sundan kaagad ng isang "{" sa double-quotish na konteksto.

Nawawalang kuwit pagkatapos ng unang argumento sa %s function
(F) Habang nagbibigay-daan sa iyo ang ilang mga function na tumukoy ng filehandle o isang "indirect object"
bago ang listahan ng argumento, hindi ito isa sa kanila.

Nawawalang command sa piped open
(W pipe) Ginamit mo ang "open(FH, "| command")" o "open(FH, "command |")" construction,
ngunit ang utos ay nawawala o blangko.

Nawawala ang control char name sa \c
(F) Ang isang double-quoted na string ay nagtapos sa "\c", nang walang kinakailangang control character
pangalan.

Nawawala ang ']' sa prototype para sa %s : %s
(W illegalproto) Sinimulan ang isang pagpapangkat sa "[" ngunit hindi isinara ng "]".

Nawawalang pangalan sa "%s sub"
(F) Ang syntax para sa lexically scoped subroutines ay nangangailangan na sila ay may isang pangalan na may
na maaari nilang matagpuan.

Nawawalang $ on loop variable
(F) Malamang nagprograma ka na csh Sobra. Ang mga variable ay palaging
nabanggit kasama ang $ sa Perl, hindi katulad sa mga shell, kung saan maaari itong mag-iba mula sa isang linya hanggang
ang susunod.

(Nawawalang operator bago ang %s?)
(S syntax) Ito ay isang edukadong hula na ginawa kasabay ng mensaheng "%s found
kung saan inaasahan ng operator". Kadalasan ang nawawalang operator ay isang kuwit.

Nawawala o hindi natukoy na argumento na kailangan
(F) Sinubukan mong tawagan ang require nang walang argumento o may hindi natukoy na halaga bilang an
argumento. Inaasahan ng Require ang alinman sa isang pangalan ng package o isang file-specification bilang isang
argumento. Tingnan ang "kailangan" sa perlfunc.

Nawawala ang kanang brace sa \%c{} sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Nawawala ang kanang brace sa "\x{...}", "\p{...}", "\P{...}", o "\N{...}".

Walang kanang brace sa \N{}
Nawawala ang kanang brace sa \N{} o hindi nakatakas na kaliwang brace pagkatapos ng \N
(F) Ang "\N" ay may dalawang kahulugan.

Ang tradisyonal ay sinusundan ito ng isang pangalan na nakapaloob sa mga braces, ibig sabihin ay ang
character (o pagkakasunod-sunod ng mga character) na ibinigay ng pangalang iyon. Kaya ang "\N{ASTERISK}" ay
isa pang paraan ng pagsulat ng "*", may bisa sa parehong double-quoted na mga string at regular na expression
mga pattern. Sa mga pattern, wala itong kahulugan na ginagawa ng hindi nakatakas na "*".

Simula sa Perl 5.12.0, ang "\N" ay maaari ding magkaroon ng karagdagang kahulugan (lamang) sa mga pattern,
ibig sabihin ay upang tumugma sa isang hindi bagong linya na character. (Ito ay maikli para sa "[^\n]", at tulad ng "." ngunit
ay hindi apektado ng "/s" regex modifier.)

Ito ay maaaring humantong sa ilang mga kalabuan. Kapag ang "\N" ay hindi agad sinundan ng kaliwa
brace, ipinapalagay ni Perl ang "[^\n]" na kahulugan. Gayundin, kung ang mga braces ay bumubuo ng isang wastong quantifier
gaya ng "\N{3}" o "\N{5,}", ipinapalagay ni Perl na nangangahulugan ito na tumugma sa ibinigay na dami
ng mga hindi bagong linya (sa mga halimbawang ito, 3; at 5 o higit pa, ayon sa pagkakabanggit). Sa lahat ng iba pa
kaso, kung saan mayroong "\N{" at katugmang "}", ipinapalagay ni Perl na ang pangalan ng character ay
ninanais.

Gayunpaman, kung walang katugmang "}", hindi alam ni Perl kung ito ay napagkamalan na tinanggal,
o kung ang "[^\n]{" ay ninanais, at itinataas ang error na ito. Kung ibig mong sabihin ang dating, idagdag ang
kanang suhay; kung ang huli ang ibig mong sabihin, takasan ang brace gamit ang backslash, tulad nito:
"\N\{"

Nawawala ang kanang kulot o square bracket
(F) Ang lexer ay nagbilang ng mas maraming pambungad na kulot o parisukat na mga bracket kaysa sa mga pagsasara. Bilang isang
pangkalahatang tuntunin, makikita mong nawawala ito malapit sa lugar kung saan ka huling nag-edit.

(Nawawala ang semicolon sa nakaraang linya?)
(S syntax) Ito ay isang edukadong hula na ginawa kasabay ng mensaheng "%s found
kung saan inaasahan ng operator". Huwag awtomatikong maglagay ng semicolon sa nakaraang linya
dahil lang nakita mo ang mensaheng ito.

Sinubukan ang pagbabago ng isang read-only na value
(F) Sinubukan mo, direkta o hindi direkta, na baguhin ang halaga ng isang pare-pareho. hindi mo ginawa,
siyempre, subukan ang "2 = 1", dahil nahuli iyon ng compiler. Ngunit isang madaling paraan upang gawin ang
parehong bagay ay:

sub mod { $_[0] = 1 }
mod(2);

Ang isa pang paraan ay ang magtalaga sa a substr() wala iyon sa dulo ng string.

Ang isa pang paraan ay ang magtalaga sa isang "foreach" na loop Var kailan Var ay alias sa isang pare-pareho
sa hitsura LIST:

$x = 1;
foreach my $n ($x, 2) {
$n *= 2; # binago ang $x, ngunit nabigo sa pagtatangka
} # baguhin ang 2

Sinubukan ang pagbabago ng hindi nagagawang halaga ng array, %s
(F) Sinubukan mong gumawa ng isang array value spring na umiral, at ang subscript ay
malamang na negatibo, kahit na nagbibilang mula sa dulo ng array pabalik.

Sinubukan ang pagbabago ng hindi nagagawang hash value, %s
(P) Sinubukan mong magkaroon ng hash value, at hindi ito magawa
para sa ilang kakaibang dahilan.

Dapat pare-pareho ang pangalan ng module
(F) Tanging isang hubad na pangalan ng module ang pinapayagan bilang unang argumento sa isang "paggamit".

Kinakailangan ang pangalan ng module na may opsyong -%c
(F) Sinasabi ng mga opsyon na "-M" o "-m" na dapat mag-load si Perl ng ilang module, ngunit tinanggal mo
ang pangalan ng modyul. Kumonsulta sa perlrun para sa buong detalye tungkol sa "-M" at "-m".

Higit sa isang argumento sa '%s' bukas
(F) Ang function na "bukas" ay hiniling na magbukas ng maramihang mga file. Ito ay maaaring mangyari kung ikaw
ay sinusubukang magbukas ng pipe sa isang utos na kumukuha ng listahan ng mga argumento, ngunit mayroon
nakalimutang tukuyin ang isang piped open mode. Tingnan ang "bukas" sa perlfunc para sa mga detalye.

mprotect para sa COW string %p %u ay nabigo sa %d
(S) Pinagsama mo ang perl gamit ang -DPERL_DEBUG_READONLY_COW (tingnan ang "Kopyahin sa Pagsulat" sa
perlguts), ngunit hindi maaaring gawing read-only ang isang shared string buffer.

nabigo ang mprotect para sa %p %u sa %d
(S) Pinagsama mo ang perl gamit ang -DPERL_DEBUG_READONLY_OPS (tingnan ang perlhacktips), ngunit isang op
hindi maaaring gawing read-only ang puno.

mprotect RW para sa COW string %p %u ay nabigo sa %d
(S) Pinagsama mo ang perl gamit ang -DPERL_DEBUG_READONLY_COW (tingnan ang "Kopyahin sa Pagsulat" sa
perlguts), ngunit ang isang read-only shared string buffer ay hindi maaaring gawing mutable.

nabigo ang mprotect RW para sa %p %u sa %d
(S) Pinagsama mo ang perl gamit ang -DPERL_DEBUG_READONLY_OPS (tingnan ang perlhacktips), ngunit isang read-
tanging op tree ang hindi maaaring gawing mutable bago palayain ang mga ops.

hindi ipinatupad ang msg%s
(F) Wala kang System V message IPC sa iyong system.

Hindi suportado ang multidimensional syntax %s
(W syntax) Ang mga multidimensional na array ay hindi isinulat tulad ng $foo[1,2,3]. Sila ay nakasulat
tulad ng $foo[1][2][3], tulad ng sa C.

Ang '/' ay dapat sumunod sa isang numeric na uri sa unpack
(F) Mayroon kang template na i-unpack na naglalaman ng '/', ngunit hindi ito sumunod sa ilan
i-unpack ang detalye na gumagawa ng numeric na halaga. Tingnan ang "pack" sa perlfunc.

"my sub" hindi pa naipatupad
(F) Hindi pa ipinapatupad ang mga subroutine na sakop ng leksikal. Huwag mo nang subukan iyon.

Ang "aking" subroutine %s ay hindi maaaring nasa isang package
(F) Ang mga subroutine na sakop ng leksikal ay wala sa isang package, kaya hindi makatuwirang subukan
para ideklara ang isa na may package qualifier sa harap.

"aking %s" ang ginamit sa paghahambing ng pag-uuri
(W syntax) Ang mga variable ng package na $a at $b ay ginagamit para sa mga paghahambing ng pag-uuri. Ginamit mo ang $a
o $b in bilang isang operand sa operator na "<=>" o "cmp" sa loob ng bloke ng paghahambing ng pag-uuri,
at ang baryabol ay nauna nang idineklara bilang isang leksikal na baryabol. Maaaring maging kwalipikado ang
uri ng variable na may pangalan ng package, o palitan ang pangalan ng lexical variable.

Ang variable na "aking" %s ay hindi maaaring nasa isang pakete
(F) Wala sa isang pakete ang mga variable na saklaw ng leksikal, kaya hindi makatuwirang subukang
magdeklara ng isa na may package qualifier sa harap. Gamitin lokal() kung gusto mo
i-localize ang isang variable ng package.

Isang beses lang ginamit ang pangalang "%s::%s": posibleng typo
(W minsan) Ang mga typographical na error ay madalas na lumalabas bilang mga natatanging variable na pangalan. Kung mayroon kang isang
magandang dahilan para magkaroon ng kakaibang pangalan, tapos banggitin na lang ulit kahit papaano para masugpo
ang mensahe. Ang "aming" deklarasyon ay ibinigay din para sa layuning ito.

TANDAAN: Nakikita ng babalang ito ang mga simbolo ng pakete na isang beses lang nagamit. Ibig sabihin nito
Ang mga lexical na variable ay hindi kailanman magpapalitaw sa babalang ito. Nangangahulugan din ito na ang lahat ng
mga variable ng package na $c, @c, %c, pati na rin *c, &c, sub c{}, c(), at c (ang filehandle
o format) ay itinuturing na pareho; kung ang isang programa ay gumagamit ng $c isang beses lamang ngunit gumagamit din ng anuman
ng iba ay hindi ito magpapalitaw ng babalang ito. Mga simbolo na nagsisimula sa isang underscore
at mga simbolo na gumagamit ng mga espesyal na identifier (qv perldata) ay hindi kasama sa babalang ito.

Kailangan ng eksaktong 3 octal digit sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Sa loob ng "(?[ ])", lahat ng mga constant na binibigyang kahulugan bilang octal ay kailangang eksaktong 3 digit
mahaba. Nakakatulong ito na mahuli ang ilang mga kalabuan. Kung ang iyong pare-pareho ay masyadong maikli, magdagdag ng nangungunang
mga zero, tulad ng

(?[ [ \078 ] ]) # Syntax error!
(?[ [ \0078 ] ]) # Gumagana
(?[ [ \007 8 ] ]) # Mas malinaw

Ang maximum na bilang na maaaring ipahayag ng construct na ito ay "\777". Kung kailangan mo ng mas malaki,
kailangan mong gamitin ang \o{} sa halip. Kung dalawang magkahiwalay na bagay ang ibig mong sabihin, kailangan mong maghiwalay
sila:

(?[ [ \7776 ] ]) # Syntax error!
(?[ [ \o{7776} ] ]) # Isang kahulugan
(?[ [ \777 6 ] ]) # Isa pang kahulugan
(?[ [ \777 \006 ] ]) # Isa pa

Negatibong '/' na bilang sa i-unpack
(F) Ang bilang ng haba na nakuha mula sa isang haba/code unpack operation ay negatibo. Tingnan mo
"pack" sa perlfunc.

Negatibong haba
(F) Sinubukan mong gumawa ng read/write/send/recv operation na may buffer length na mas kaunti
kaysa sa 0. Ito ay mahirap isipin.

Negatibong offset sa vec sa konteksto ng halaga
(F) Kapag ang "vec" ay tinawag sa isang konteksto ng halaga, ang pangalawang argumento ay dapat na mas malaki
kaysa o katumbas ng zero.

Walang nagagawa ang negatibong bilang ng pag-uulit
(W numeric) Sinubukan mong isagawa ang "x" na operator ng pag-uulit nang mas kaunti sa 0 beses, na
walang saysay.

Mga nested na quantifier sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Hindi mo mabibilang ang isang quantifier nang walang intervening na panaklong. Kaya mga bagay tulad ng
Ang ** o +* o ?* ay labag sa batas. Ang <-- HERE ay nagpapakita ng kinaroroonan sa regular na expression
natuklasan ang problema.

Tandaan na ang minimal na tumutugmang mga quantifier, "*?", "+?", at "??" mukhang nakapugad
mga quantifier, ngunit hindi. Tingnan ang perlre.

Hindi kailanman ipinakilala si %s
(S internal) Ang simbolo na pinag-uusapan ay idineklara ngunit kahit papaano ay nawala sa saklaw noon
ito ay posibleng ginamit.

susunod::paraan/susunod::maaari/maaring::susunod::hindi mahanap ng pamamaraan ang kalakip na paraan
(F) "next::method" ay kailangang tawagin sa loob ng konteksto ng isang tunay na pamamaraan sa isang tunay
package, at hindi nito mahanap ang ganoong konteksto. Tingnan mo si mro.

Ang \N sa isang klase ng character ay dapat na isang pinangalanang character: \N{...} sa regex; minarkahan ng <-- DITO sa
MS/
(F) Ang bagong (bilang ng Perl 5.12) na kahulugan ng "\N" bilang "[^\n]" ay hindi wasto sa isang naka-bracket
klase ng character, para sa parehong dahilan na "." sa isang character class ay nawawala nito
espesyalidad: ito ay tumutugma sa halos lahat, na marahil ay hindi ang gusto mo.

\N{} sa inverted character class o bilang isang range end-point ay pinaghihigpitan sa isang character sa loob
regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang pinangalanang Unicode na character na escapes ("\N{...}") ay maaaring magbalik ng multi-character sequence.
Kahit na ang isang klase ng character ay dapat na tumugma lamang sa isang character ng input, perl
ay tutugma nang tama sa buong bagay, maliban kung ang klase ay baligtad ("[^...]"), o
ang pagtakas ay ang simula o huling punto ng pagtatapos ng isang hanay. Ang mathematically logical
Ang pag-uugali para sa kung ano ang tumutugma kapag ang pagbaligtad ay ibang-iba sa inaasahan ng mga tao, kaya
nagpasya kaming ipagbawal ito. Katulad na hindi malinaw kung ano ang dapat na mabuo kapag ang
Ang "\N{...}" ay ginagamit bilang isa sa mga end point ng range, gaya ng in

[\x{41}-\N{ARABIC SEQUENCE YEH MAY HAMZA SA ITAAS NA MAY AE}]

Ang ibig sabihin dito ay hindi malinaw, dahil ang "\N{...}" na pagtakas ay isang sequence ng mga code point,
kaya ito ay ginawa ng isang error.

Ang \N{NAME} ay dapat lutasin ng lexer sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Kapag nag-compile ng regex pattern, isang hindi nalutas na pinangalanang character o sequence ay
nakatagpo. Ito ay maaaring mangyari sa alinman sa ilang mga paraan na lumalampas sa lexer, gaya ng
gamit ang single-quotish na konteksto, o isang dagdag na backslash sa double-quotish:

$re = '\N{SPACE}'; #Mali!
$re = "\\N{SPACE}"; #Mali!
/$re/;

Sa halip, gumamit ng double-quotes na may isang backslash:

$re = "\N{SPACE}"; # okay
/$re/;

Ang lexer ay maaaring ma-bypass din sa pamamagitan ng paglikha ng pattern mula sa mas maliliit na bahagi:

$re = '\N';
/${re}{SPACE}/; #Mali!

Hindi magandang ideya na hatiin ang isang construct sa gitna ng ganito, at hindi ito gumagana
dito. Sa halip gamitin ang solusyon sa itaas.

Sa wakas, ang mensahe ay maaari ding mangyari sa ilalim ng "/x" regex modifier kapag ang "\N" ay
pinaghihiwalay ng mga puwang mula sa "{", kung saan, alisin ang mga puwang.

/\N {SPACE}/x; #Mali!
/\N{SPACE}/x; # okay

Hindi pinapayagan ang %s habang tumatakbo ang setuid
(F) Ang ilang mga operasyon ay itinuturing na masyadong hindi secure para sa isang setuid o setgid na script na
kahit papayagang subukan. Sa pangkalahatan, magkakaroon ng isa pang paraan upang gawin kung ano
gusto mo na, kung hindi secure, at least secured. Tingnan ang perlsec.

NO-BREAK SPACE sa isang charnames alias na kahulugan ay hindi na ginagamit
(D hindi na ginagamit) Tinukoy mo ang isang pangalan ng character na naglalaman ng no-break space
karakter. Baguhin ito sa isang regular na espasyo. Karaniwan ang mga pangalang ito ay tinukoy sa
":alias" import argument sa "gumamit ng mga charnames", ngunit maaari silang tukuyin ng isang tagasalin
naka-install sa $^H{charnames}. Tingnan ang "CUSTOM ALIASES" sa mga charnames.

Walang tinukoy na code para sa -%c
(F) kay Perl -e at -E Ang mga opsyon sa command-line ay nangangailangan ng argumento. Kung gusto mong magpatakbo ng isang
walang laman na programa, ipasa ang walang laman na string bilang isang hiwalay na argumento o magpatakbo ng isang programa
binubuo ng isang solong 0 o 1:

perl -e ""
perl -e0
perl -e1

Walang comma na pinapayagan pagkatapos ng %s
(F) Ang isang operator ng listahan na mayroong filehandle o "indirect object" ay hindi pinapayagang magkaroon
isang kuwit sa pagitan niyan at ng mga sumusunod na argumento. Kung hindi ay isa na lang
ng mga argumento.

Ang isang posibleng dahilan para dito ay ang inaasahan mong mag-import ng constant sa iyong
name space na may gamitin or angkat habang walang ganoong pag-import na naganap, maaari itong halimbawa
maging ang iyong operating system ay hindi sumusuporta sa partikular na pare-pareho. Sana
gumamit ka nga ng isang tahasang listahan ng pag-import para sa mga constant na inaasahan mong makita; mangyaring tingnan
"gamitin" sa perlfunc at "import" sa perlfunc. Habang ang isang tahasang listahan ng pag-import ay gagawin
malamang na nahuli ang error na ito nang mas maaga ay natural na hindi nito nireresolba ang katotohanang iyon
hindi pa rin sinusuportahan ng iyong operating system ang pare-parehong iyon. Baka may typo ka
ang mga pare-pareho ng listahan ng pag-import ng simbolo ng gamitin or angkat o sa palagiang pangalan sa
ang linya kung saan na-trigger ang error na ito?

Walang utos kung saan ipi-pipe sa command line
(F) Isang error na kakaiba sa VMS. Pinangangasiwaan ng Perl ang sarili nitong pag-redirect ng command line, at
nakahanap ng '|' sa dulo ng command line, kaya hindi nito alam kung saan mo gustong mag-pipe
ang output mula sa utos na ito.

Walang tinukoy na DB::DB routine
(F) Ang kasalukuyang nagsasagawa ng code ay pinagsama-sama sa -d lumipat, ngunit sa ilang kadahilanan
ang kasalukuyang debugger (hal perl5db.pl o isang "Devel::" module) ay hindi tumukoy ng isang routine
na tatawagin sa simula ng bawat pahayag.

Walang dbm sa makinang ito
(P) Ito ay binibilang bilang isang panloob na error, dahil ang bawat makina ay dapat magbigay ng dbm
sa ngayon, dahil kasama si Perl sa SDBM. Tingnan ang SDBM_File.

Walang tinukoy na DB::sub routine
(F) Ang kasalukuyang nagsasagawa ng code ay pinagsama-sama sa -d lumipat, ngunit sa ilang kadahilanan
ang kasalukuyang debugger (hal perl5db.pl o isang "Devel::" module) ay hindi tumukoy ng "DB::sub"
routine na tatawagin sa simula ng bawat ordinaryong subroutine na tawag.

Walang tinukoy na direktoryo para sa -I
(F) Ang -I Ang command-line switch ay nangangailangan ng pangalan ng direktoryo bilang bahagi ng pareho argumento.
paggamit -Ilib, Halimbawa. -I lib hindi gagana.

Walang error na file pagkatapos ng 2> o 2>> sa command line
(F) Isang error na kakaiba sa VMS. Pinangangasiwaan ng Perl ang sarili nitong pag-redirect ng command line, at
nakakita ng '2>' o '2>>' sa command line, ngunit hindi mahanap ang pangalan ng file na
kung saan isusulat ang data na nakalaan para sa stderr.

Walang nakitang pangkat na nagtatapos na character na '%c' sa template
(F) Ang isang pack o unpack na template ay may pambungad na '(' o '[' na walang tugma
katapat. Tingnan ang "pack" sa perlfunc.

Walang input file pagkatapos ng < sa command line
(F) Isang error na kakaiba sa VMS. Pinangangasiwaan ng Perl ang sarili nitong pag-redirect ng command line, at
nakahanap ng '<' sa command line, ngunit hindi mahanap ang pangalan ng file kung saan pupunta
basahin ang data para sa stdin.

Walang nakitang susunod::method '%s' para sa %s
(F) "next::method" ay walang nakitang karagdagang mga pagkakataon ng pangalan ng pamamaraang ito sa natitira
mga pakete ng MRO ng klase na ito. Kung hindi mo nais na ito ay nagtatapon ng isang pagbubukod, gamitin
"siguro::next::method" o "next::can". Tingnan mo si mro.

Walang magagawa ang non-finite repeat count
(W numeric) Sinubukan mong isagawa ang "x" repetition operator na "Inf" (o "-Inf") o
"NaN" beses, na hindi makatwiran.

Non-hex na character sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Sa isang regular na expression, mayroong isang hindi hexadecimal na character kung saan naroon ang isang hex
inaasahan, tulad ng

(?[ [ \xDG ] ])
(?[ [ \x{DEKA} ] ])

Non-octal na character sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Sa isang regular na expression, mayroong isang hindi octal na karakter kung saan ang isang octal ay naroon
inaasahan, tulad ng

(?[ [ \o{1278} ] ])

Hindi-octal na character na '%c'. Nalutas bilang "%s"
(W digit) Sa pag-parse ng octal numeric constant, ang isang character ay hindi inaasahan
nakatagpo na hindi octal. Ang resultang halaga ay tulad ng ipinahiwatig.

"hindi" hindi pinapayagan sa pagpapahayag
(F) Ang keyword na "hindi" ay kinikilala at isinasagawa sa oras ng pag-compile, at hindi nagbabalik ng kapaki-pakinabang
halaga. Tingnan ang perlmod.

Naipasa ang non-string bilang bitmask
(W misc) Isang numero ang naipasa bilang isang bitmask argument sa piliin(). Gamitin ang vec()
function na upang bumuo ng file descriptor bitmasks para piliin. Tingnan ang "piliin" sa
perlfunc.

Walang output file pagkatapos > sa command line
(F) Isang error na kakaiba sa VMS. Pinangangasiwaan ng Perl ang sarili nitong pag-redirect ng command line, at
nakakita ng nag-iisang '>' sa dulo ng command line, kaya hindi nito alam kung saan mo gusto
upang i-redirect ang stdout.

Walang output file pagkatapos ng > o >> sa command line
(F) Isang error na kakaiba sa VMS. Pinangangasiwaan ng Perl ang sarili nitong pag-redirect ng command line, at
nakakita ng '>' o '>>' sa command line, ngunit hindi mahanap ang pangalan ng file kung saan
kung saan isusulat ang data na nakalaan para sa stdout.

Walang pinahihintulutang pangalan ng package para sa variable na %s sa "aming"
(F) Ang ganap na kwalipikadong mga pangalan ng variable ay hindi pinapayagan sa "aming" mga deklarasyon, dahil iyon
walang gaanong kahulugan sa ilalim ng mga umiiral na panuntunan. Ang nasabing syntax ay nakalaan para sa hinaharap
mga extension.

Walang Perl script na nakita sa input
(F) Tinawag mo ang "perl -x", ngunit walang nahanap na linya sa file na nagsisimula sa #! at
naglalaman ng salitang "perl".

Walang available na setregid
(F) Walang nakitang bagay ang Configure na kahawig ng setregid() tumawag para sa iyong sistema.

Walang available na setreuid
(F) Walang nakitang bagay ang Configure na kahawig ng setreuid() tumawag para sa iyong sistema.

Walang ganoong klase %s
(F) Nagbigay ka ng class qualifier sa isang "my", "our" o "state" na deklarasyon, ngunit ito
walang klase sa puntong ito sa iyong programa.

Walang ganoong field ng klase na "%s" sa variable na %s ng uri na %s
(F) Sinubukan mong i-access ang isang susi mula sa isang hash sa pamamagitan ng ipinahiwatig na nai-type na variable ngunit
ang susi na iyon ay hindi pinahihintulutan ng pakete ng parehong uri. Ang nakasaad na pakete ay may
pinaghigpitan ang hanay ng mga pinapayagang key gamit ang mga field na pragma.

Walang ganoong kawit: %s
(F) Tinukoy mo ang isang signal hook na hindi nakilala ni Perl. Sa kasalukuyan, si Perl
tumatanggap ng "__DIE__" at "__WARN__" bilang wastong signal hook.

Walang bukas na tubo
(P) Isang error na kakaiba sa VMS. Ang panloob na gawain my_plose() sinubukang isara ang isang tubo
na hindi pa nabubuksan. Ito ay dapat na nahuli nang mas maaga bilang isang pagtatangka upang isara
isang hindi nabuksang filehandle.

Walang ganoong signal: SIG%s
(W signal) Tinukoy mo ang isang pangalan ng signal bilang isang subscript sa %SIG na hindi nakilala.
Sabihin ang "kill -l" sa iyong shell upang makita ang mga wastong pangalan ng signal sa iyong system.

Hindi isang sanggunian ng CODE
(F) Sinusubukan ni Perl na suriin ang isang sanggunian sa isang halaga ng code (iyon ay, isang subroutine),
ngunit sa halip ay may nakitang reference sa ibang bagay. Maaari mong gamitin ang ref() function sa
alamin kung anong uri talaga ito ng ref. Tingnan din ang perlref.

Hindi isang GLOB reference
(F) Sinusubukan ni Perl na suriin ang isang sanggunian sa isang "typeglob" (iyon ay, isang simbolo na talahanayan
entry na mukhang *foo), ngunit nakakita ng reference sa ibang bagay. Kaya mo
gamitin ang ref() function upang malaman kung anong uri talaga ito ng ref. Tingnan ang perlref.

Hindi isang HASH reference
(F) Sinusubukang suriin ni Perl ang isang reference sa isang hash value, ngunit nakahanap ng reference sa
ibang bagay sa halip. Maaari mong gamitin ang ref() function upang malaman kung anong uri ng ref
noon talaga. Tingnan ang perlref.

Hindi isang ARRAY reference
(F) Sinusubukan ni Perl na suriin ang isang sanggunian sa isang halaga ng array, ngunit nakahanap ng isang sanggunian
sa ibang bagay sa halip. Maaari mong gamitin ang ref() function upang malaman kung anong uri ng
ref ito talaga. Tingnan ang perlref.

Hindi isang unblessed ARRAY reference
(F) Nagpasa ka ng reference sa isang pinagpalang array sa "push", "shift" o ibang array
function. Ang mga ito ay tumatanggap lamang ng mga hindi pinagpalang array reference o array na nagsisimula nang tahasan
na may "@".

Hindi isang SCALAR na sanggunian
(F) Sinusubukan ni Perl na suriin ang isang sanggunian sa isang scalar na halaga, ngunit nakahanap ng isang sanggunian
sa ibang bagay sa halip. Maaari mong gamitin ang ref() function upang malaman kung anong uri ng
ref ito talaga. Tingnan ang perlref.

Hindi isang subroutine na sanggunian
(F) Sinusubukan ni Perl na suriin ang isang sanggunian sa isang halaga ng code (iyon ay, isang subroutine),
ngunit sa halip ay may nakitang reference sa ibang bagay. Maaari mong gamitin ang ref() function sa
alamin kung anong uri talaga ito ng ref. Tingnan din ang perlref.

Hindi isang subroutine na sanggunian sa overload na talahanayan
(F) Isang pagtatangka ay ginawa upang tukuyin ang isang entry sa isang overloading talahanayan na hindi
kahit papaano ay tumuturo sa isang wastong subroutine. Tingnan ang labis na karga.

Hindi sapat ang mga argumento para sa %s
(F) Ang function ay nangangailangan ng higit pang mga argumento kaysa sa iyong tinukoy.

Hindi sapat na mga argumento sa format
(W syntax) Isang format na tinukoy ang higit pang mga field ng larawan kaysa sa susunod na linyang ibinigay. Tingnan mo
perlform.

%s: hindi nahanap
(A) Hindi mo sinasadyang napatakbo ang iyong script sa Bourne shell sa halip na Perl.
Suriin ang #! linya, o manu-manong i-feed ang iyong script sa Perl mismo.

(?[...]) hindi wasto sa lokal sa regex; minarkahan ng <-- DITO sa m/%s/
(F) "(?[...])" ay hindi maaaring gamitin sa loob ng saklaw ng isang "use locale" o may "/l"
regular na expression modifier, dahil mangangailangan iyon ng pagpapaliban sa run-time ang
pagkalkula ng kung saan ito dapat suriin, at ito ay regex compile-time lamang.

walang UTC offset na impormasyon; ipagpalagay na ang lokal na oras ay UTC
(S) Isang babala na kakaiba sa VMS. Hindi mahanap ni Perl ang lokal na timezone offset, kaya
ipinapalagay na ang oras ng lokal na sistema ay katumbas ng UTC. Kung hindi, tukuyin ang
lohikal na pangalan SYS$TIMEZONE_DIFFERENTIAL upang isalin sa bilang ng mga segundo na
kailangang idagdag sa UTC upang makakuha ng lokal na oras.

NULL OP IN RUN
(S debugging) Tinatawag ang ilang panloob na gawain patakbuhin () na may null opcode pointer.

Null na larawan sa formline
(F) Ang unang argumento sa formline ay dapat na wastong format na detalye ng larawan. Ito
ay natagpuang walang laman, na malamang na nangangahulugang binigyan mo ito ng hindi pa nasimulang halaga.
Tingnan ang perlform.

Null realloc
(P) Ang isang pagtatangka ay ginawa sa realloc NULL.

NULL regexp argument
(P) Ang panloob na pattern ng pagtutugma ng mga gawain ay blew ito malaking oras.

NULL regexp parameter
(P) Ang panloob na mga gawain sa pagtutugma ng pattern ay wala sa kanilang lung.

Masyadong mahaba ang numero
(F) Nililimitahan ng Perl ang representasyon ng mga decimal na numero sa mga programa sa humigit-kumulang 250
mga karakter. Nalampasan mo na ang haba na iyon. Ang mga hinaharap na bersyon ng Perl ay malamang na
alisin ang di-makatwirang limitasyong ito. Pansamantala, subukang gumamit ng siyentipikong notasyon
(hal. "1e6" sa halip na "1_000_000").

Numero na walang mga digit
(F) Si Perl ay naghahanap ng isang numero ngunit walang nakitang kamukha ng isang numero. Ito
nangyayari, halimbawa sa "\o{}", na walang numero sa pagitan ng mga brace.

Octal number > 037777777777 non-portable
(W portable) Ang octal number na iyong tinukoy ay mas malaki sa 2**32-1 (4294967295) at
samakatuwid ay hindi portable sa pagitan ng mga system. Tingnan ang perlport para sa higit pa sa portability
alalahanin.

Kakatwang argumento ng pangalan/halaga para sa subroutine
(F) Nakatanggap ng kakaibang numero ang isang subroutine na gumagamit ng slurpy hash parameter sa lagda nito
ng mga argumento para punan ang hash. Ito ay nangangailangan ng mga argumento na ipares, sa
parehong bilang ng mga susi bilang mga halaga. Ang tumatawag sa subroutine ay malamang na may kasalanan.
Hindi maginhawa, ang error na ito ay iuulat sa lokasyon ng subroutine, hindi
yung sa tumatawag.

Kakaibang bilang ng mga argumento para sa overload::constant
(W overload) Ang tawag sa overload::constant ay naglalaman ng kakaibang bilang ng mga argumento. Ang
ang mga argumento ay dapat na magkapares.

Kakaibang bilang ng mga elemento sa anonymous na hash
(W misc) Tinukoy mo ang isang kakaibang bilang ng mga elemento upang simulan ang isang hash, na kakaiba,
dahil ang mga hash ay pumapasok sa key/value pairs.

Kakaibang bilang ng mga elemento sa pagtatalaga ng hash
(W misc) Tinukoy mo ang isang kakaibang bilang ng mga elemento upang simulan ang isang hash, na kakaiba,
dahil ang mga hash ay pumapasok sa key/value pairs.

Offset sa labas ng string
(F)(W layer) Sinubukan mong gumawa ng read/write/send/recv/seek operation na may offset
nakaturo sa labas ng buffer. Ito ay mahirap isipin. Ang tanging pagbubukod sa
ito ay ang zero padding ay magaganap kapag lumampas sa dulo ng string kapag
alinman sa "sysread()" sa isang file, o kapag naghahanap sa dulo ng isang scalar na binuksan para sa I/O
(sa pag-asam ng mga pagbabasa sa hinaharap at upang gayahin ang pag-uugali sa totoong mga file).

%s() sa hindi pa nabubuksang %s
(W hindi nabuksan) Ang isang I/O operation ay sinubukan sa isang filehandle na hindi kailanman
pinasimulan. Kailangan mong gumawa ng isang bukas()Sa sysopen(), O isang socket () tumawag, o tumawag sa a
constructor mula sa FileHandle package.

-%s sa hindi pa nabuksang filehandle %s
(W hindi nabuksan) Sinubukan mong mag-invoke ng file test operator sa isang filehandle na hindi bukas.
Suriin ang iyong daloy ng kontrol. Tingnan din ang "-X" sa perlfunc.

oops: oopsAV
(S panloob) Isang panloob na babala na ang grammar ay screwed up.

oops: oopsHV
(S panloob) Isang panloob na babala na ang grammar ay screwed up.

Binubuksan din ang dirhandle %s bilang isang file
(D io, deprecated) Ginamit mo bukas() upang iugnay ang isang filehandle sa isang simbolo (glob o
scalar) na may hawak nang dirhandle. Bagama't legal, maaaring i-render ng idyoma na ito ang iyong
nakakalito ang code at hindi na ginagamit.

Binubuksan din ang filehandle %s bilang isang direktoryo
(D io, deprecated) Ginamit mo opendir() upang iugnay ang isang dirhandle sa isang simbolo (glob o
scalar) na mayroon nang filehandle. Bagama't legal, maaaring i-render ng idyoma na ito ang iyong
nakakalito ang code at hindi na ginagamit.

Operand na walang naunang operator sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Sumulat ka ng isang katulad

(?[ \p{Digit} \p{Thai} ])

Mayroong dalawang operand, ngunit walang operator na nagbibigay kung paano mo gustong pagsamahin ang mga ito.

Operation "%s": walang nakitang paraan, %s
(F) Isang pagtatangka ay ginawa upang magsagawa ng overloaded na operasyon kung saan walang handler
tinukoy. Bagama't ang ilang mga handler ay maaaring i-autogenerate sa mga tuntunin ng iba pang mga handler, doon
ay walang default na handler para sa anumang operasyon, maliban kung ang "fallback" overloading key ay
tinukoy na totoo. Tingnan ang labis na karga.

Ibinabalik ng Operation "%s" ang argumento nito para sa non-Unicode code point 0x%X
(S non_unicode) Nagsagawa ka ng operasyon na nangangailangan ng mga panuntunan ng Unicode sa isang code point
wala iyon sa Unicode, kaya hindi tinukoy ang dapat nitong gawin. Pinili ni Perl na magkaroon
wala itong ginagawa, at binabalaan ka.

Kung ang ipinapakitang operasyon ay "ToFold", nangangahulugan ito na ang case-insensitive na pagtutugma sa a
ang regular na expression ay ginawa sa code point.

Kung alam mo kung ano ang iyong ginagawa maaari mong i-off ang babalang ito sa pamamagitan ng "walang mga babala
'non_unicode';".

Ibinabalik ng Operation "%s" ang argumento nito para sa UTF-16 surrogate U+%X
(S surrogate) Nagsagawa ka ng operasyon na nangangailangan ng mga panuntunan ng Unicode sa isang Unicode
kahalili. Sumimangot ang Unicode sa paggamit ng mga kahalili para sa anumang bagay maliban sa pag-iimbak ng mga string
sa UTF-16, ngunit ang mga patakaran ay (nag-aatubili) na tinukoy para sa mga kahalili, at dapat nilang gawin
wala para sa operasyong ito. Dahil ang paggamit ng mga kahalili ay maaaring mapanganib, Perl
nagbabala.

Kung ang ipinapakitang operasyon ay "ToFold", nangangahulugan ito na ang case-insensitive na pagtutugma sa a
ang regular na expression ay ginawa sa code point.

Kung alam mo kung ano ang iyong ginagawa maaari mong i-off ang babalang ito sa pamamagitan ng "walang mga babala
'kahalili';".

Nawawala ang operator o semicolon bago ang %s
(S ambiguous) Gumamit ka ng variable o subroutine na tawag kung saan ang parser ay umaasa ng isang
operator. Ipinapalagay ng parser na talagang sinadya mong gumamit ng operator, ngunit ito ay
malamang na hindi tama. Halimbawa, kung sasabihin mo ang "*foo *foo" ito ay magiging
binibigyang kahulugan na parang sinabi mong "*foo * 'foo'".

Walang default na expression ang opsyonal na parameter
(F) Sa isang subroutine na lagda, sumulat ka ng isang bagay tulad ng "$a =", na gumagawa ng isang pinangalanan
opsyonal na parameter na walang default na halaga. Ang isang walang pangalan na opsyonal na parameter ay
pinahihintulutan na walang default na halaga, ngunit ang isang pinangalanan ay dapat magkaroon ng isang partikular na default. Ikaw
malamang na gusto ng "$a = undef".

Muling idineklara ang "aming" variable na %s
(W misc) Tila na-declare mo na ang parehong global minsan sa kasalukuyang
leksikal na saklaw.

Wala sa memorya!
(X) Ang malloc () ibinalik ang function na 0, na nagpapahiwatig na walang sapat na natitira
memorya (o virtual memory) upang matugunan ang kahilingan. Walang pagpipilian si Perl kundi lumabas
kaagad.

Hindi bababa sa sa Unix maaari mong malampasan ito sa pamamagitan ng pagpapataas ng laki ng data ng iyong proseso
mga limitasyon: sa csh/tcsh gumamit ng "limitasyon" at "limitahan ang laki ng n" (kung saan ang "n" ay ang bilang ng
kilobytes) upang suriin ang kasalukuyang mga limitasyon at baguhin ang mga ito, at sa paggamit ng ksh/bash/zsh
"ulimit -a" at "ulimit -dn", ayon sa pagkakabanggit.

Wala sa memorya sa panahon ng %s extend
(X) Isang pagtatangka ay ginawa upang palawigin ang isang array, isang listahan, o isang string na lampas sa pinakamalaki
posibleng paglalaan ng memorya.

Wala sa memorya sa panahon ng "malaking" kahilingan para sa %s
(F) Ang malloc () ibinalik ang function na 0, na nagpapahiwatig na walang sapat na natitira
memorya (o virtual memory) upang matugunan ang kahilingan. Gayunpaman, ang kahilingan ay hinuhusgahan
sapat na malaki (ang default ng compile-time ay 64K), kaya isang posibilidad na i-shut down sa pamamagitan ng pag-trap
ang error na ito ay ipinagkaloob.

Out of memory habang hinihiling ang %s
(X)(F) Ang malloc () ibinalik ang function na 0, na nagpapahiwatig na walang sapat na natitira
memorya (o virtual memory) upang matugunan ang kahilingan.

Ang kahilingan ay hinuhusgahan na maliit, kaya ang posibilidad na ma-trap ito ay depende sa paraan
perl ay pinagsama-sama. Bilang default, hindi ito ma-trap. Gayunpaman, kung pinagsama-sama para dito,
Maaaring gamitin ng Perl ang mga nilalaman ng $^M bilang isang emergency pool pagkatapos mamatay ()na kasama nito
mensahe. Sa kasong ito ang error ay trappable minsan, at ang mensahe ng error ay isasama
ang linya at file kung saan nangyari ang nabigong kahilingan.

Wala sa memorya sa panahon ng napakalaking kahilingan
(F) Hindi ka maaaring maglaan ng higit sa 2^31+ "maliit na halaga" na byte. Ang error na ito ay malamang
na sanhi ng isang typo sa Perl program. hal, $arr[oras] sa halip na $arr[$oras].

Out of memory para sa yacc stack
(F) Gusto ng yacc parser na palakihin ang stack nito para makapagpatuloy ito sa pag-parse, ngunit
realloc() hindi ito magbibigay ng higit pang memorya, virtual o kung hindi man.

'.' labas ng string sa pack
(F) Ang argumento sa isang '.' sa iyong template sinubukang ilipat ang nagtatrabaho posisyon sa
bago magsimula ang packed string na ginagawa.

'@' sa labas ng string sa i-unpack
(F) Mayroon kang template na nagtukoy ng ganap na posisyon sa labas ng string being
na-unpack. Tingnan ang "pack" sa perlfunc.

'@' sa labas ng string na may malformed na UTF-8 sa unpack
(F) Mayroon kang template na nagtukoy ng ganap na posisyon sa labas ng string being
na-unpack. Invalid din ang UTF-8 ang string na na-unpack. Tingnan ang "pack" sa perlfunc.

overload arg '%s' ay hindi wasto
(W overload) Ang overload na pragma ay naipasa sa isang argumentong hindi nito nakilala. ginawa mo ba
maling type ng operator?

Ang overload na dereference ay hindi nagbalik ng reference
(F) Ang isang bagay na may overloaded dereference operator ay na-dereference, ngunit ang
hindi nagbalik ng reference ang overloaded na operasyon. Tingnan ang labis na karga.

Ang overload na qr ay hindi nagbalik ng REGEXP
(F) Ang isang bagay na may "qr" na labis na karga ay ginamit bilang bahagi ng isang tugma, ngunit ang labis na karga
ang operasyon ay hindi nagbalik ng isang pinagsama-samang regexp. Tingnan ang labis na karga.

%s package attribute ay maaaring magkasalungat sa hinaharap na nakalaan na salita: %s
(W reserved) Ginamit ang lowercase na pangalan ng attribute na mayroong handler na partikular sa package.
Maaaring magkaroon ng kahulugan ang pangalang iyon sa Perl mismo balang araw, kahit na hindi pa.
Marahil ay dapat mong gamitin ang isang mixed-case na pangalan ng katangian, sa halip. Tingnan ang mga katangian.

pack/unpack repeat count overflow
(F) Hindi ka maaaring tumukoy ng umuulit na bilang na napakalaki na umaapaw ito sa iyong mga naka-sign na integer.
Tingnan ang "pack" sa perlfunc.

pag-apaw ng pahina
(W io) Isang tawag sa sumulat () gumawa ng mas maraming linya kaysa sa maaaring magkasya sa isang pahina. Tingnan mo
perlform.

pagkasindak: %s
(P) Isang panloob na error.

panic: subukang tawagan ang %s sa %s
(P) Ang isa sa mga file test operator ay nagpasok ng isang code branch na tumatawag sa isang ACL related-
function, ngunit hindi available ang function na iyon sa platform na ito. Ang ibig sabihin ng mga naunang pagsusuri
na hindi dapat makapasok sa sangay na ito sa platform na ito.

panic: hindi nakaiskedyul ang pseudo-process ng bata
(P) Hindi nakaiskedyul ang isang child pseudo-process sa pagpapatupad ng mga ithread sa Windows
sa loob ng panahon na pinapayagan at samakatuwid ay hindi makapagsimula nang maayos.

panic: ck_grep, type=%u
(P) Nabigo ang isang internal consistency check na sinusubukang mag-compile ng grep.

panic: ck_split, type=%u
(P) Nabigo ang isang internal consistency check na sinusubukang mag-compile ng split.

panic: corrupt na naka-save na stack index %ld
(P) Ang savestack ay hiniling na ibalik ang higit pang mga naisalokal na halaga kaysa doon sa
savestack.

gulat: del_backref
(P) Nabigo ang internal consistency check habang sinusubukang i-reset ang mahinang reference.

gulat: mamatay %s
(P) Inilagay namin ang context stack sa isang eval na konteksto, at pagkatapos ay natuklasan namin na hindi ito isang
konteksto ng ebal.

gulat: do_subst
(P) Ang panloob pp_subst() ang routine ay tinawag na may di-wastong data ng pagpapatakbo.

gulat: do_trans_%s
(P) Ang mga panloob na do_trans na gawain ay tinawag na may di-wastong data ng pagpapatakbo.

panic: fold_constants JMPENV_PUSH ibinalik %d
(P) Habang sinusubukang i-fold ang mga constant, isang exception maliban sa isang "eval" na kabiguan ay
nahuli

gulat: frexp: %f
(P) Ang function ng library frexp() nabigo, ginagawang imposible ang printf("%f").

panic: goto, type=%u, ix=%ld
(P) Inilabas namin ang context stack sa isang konteksto na may tinukoy na label, at pagkatapos
natuklasan na hindi ito isang kontekstong alam namin kung paano gumawa ng isang goto in.

panic: Nabigo ang gp_free na palayain ang glob pointer
(P) Ang panloob na gawain na ginamit upang i-clear ang mga entry ng typeglob ay paulit-ulit na sinubukan, ngunit bawat isa
oras na may muling ginawang mga entry sa glob. Malamang ang glob ay naglalaman ng isang
object na may reference pabalik sa glob at isang destructor na nagdaragdag ng bagong object sa
ang glob.

pagkasindak: INTERPCASEMOD, %s
(P) Nagkaroon ng masamang kalagayan ang lexer sa isang case modifier.

pagkasindak: INTERPCONCAT, %s
(P) Masama ang kalagayan ng lexer sa pag-parse ng string na may mga bracket.

gulat: bata popen errno basahin
(F) Isang nagsawang bata ang nagbalik ng hindi maintindihang mensahe tungkol sa pagkakamali nito.

panic: last, type=%u
(P) Inilagay namin ang context stack sa isang block context, at pagkatapos ay natuklasan namin na hindi ito a
harangan ang konteksto.

gulat: leave_scope clearsv
(P) Ang isang naisusulat na lexical variable ay naging read-only kahit papaano sa loob ng saklaw.

panic: leave_scope inconsistency %u
(P) Malamang na hindi naka-sync ang savestack. Hindi bababa sa, nagkaroon ng di-wastong enum sa
tuktok nito.

gulat: magic_killbackrefs
(P) Nabigo ang isang internal consistency check habang sinusubukang i-reset ang lahat ng mahinang reference sa
isang bagay.

gulat: malloc, %s
(P) May humiling ng negatibong bilang ng mga byte ng malloc.

gulat: memory wrap
(P) May sinubukang maglaan ng alinman sa mas maraming memorya kaysa sa posible o isang negatibong halaga.

gulat: pad_alloc, %p!=%p
(P) Nalito ang compiler kung aling scratch pad ang inilalaan at nililibre nito
pansamantala at leksikal mula sa.

gulat: pad_free curpad, %p!=%p
(P) Nalito ang compiler kung aling scratch pad ang inilalaan at nililibre nito
pansamantala at leksikal mula sa.

panic: pad_free po
(P) Isang zero scratch pad offset ang nakita sa loob. Isang pagtatangka na palayain ang a
target na hindi pa inilalaan sa simula.

panic: pad_reset curpad, %p!=%p
(P) Nalito ang compiler kung aling scratch pad ang inilalaan at nililibre nito
pansamantala at leksikal mula sa.

panic: pad_sv po
(P) Isang zero scratch pad offset ang nakita sa loob. Malamang kailangan ng operator
isang target ngunit ang target na iyon ay hindi inilaan para sa anumang dahilan.

panic: pad_swipe curpad, %p!=%p
(P) Nalito ang compiler kung aling scratch pad ang inilalaan at nililibre nito
pansamantala at leksikal mula sa.

panic: pad_swipe po
(P) May nakitang di-wastong scratch pad offset sa loob.

panic: pp_iter, type=%u
(P) Ang foreach iterator ay tinawag sa isang non-loop na konteksto na frame.

pagkasindak: pp_match%s
(P) Ang panloob pp_match() ang routine ay tinawag na may di-wastong data ng pagpapatakbo.

pagkasindak: pp_split, pm=%p, s=%p
(P) May masamang nangyari sa pagse-set up para sa split.

panic: realloc, %s
(P) May humiling ng negatibong bilang ng mga byte ng realloc.

panic: maling bilang ng reference sa nsv in sv_replace() (%d != 1)
(P) Ang panloob sv_replace() Ang function ay binigyan ng bagong SV na may bilang ng sanggunian
maliban sa 1.

panic: restartop sa %s
(P) Ang ilang panloob na gawain ay humiling ng isang goto (o isang katulad nito), at hindi nagbigay
ang patutunguhan

panic: bumalik, type=%u
(P) Inilabas namin ang context stack sa isang subroutine o eval na konteksto, at pagkatapos ay natuklasan
hindi ito isang subroutine o eval na konteksto.

gulat: scan_num, %s
(P) scan_num() tinawagan ang isang bagay na hindi numero.

panic: Sequence (?{...}): walang code block na nakita sa regex m/%s/
(P) Habang nag-iipon ng pattern na may naka-embed na (?{}) o (??{}) na mga bloke ng code, perl
hindi mahanap ang block ng code na dapat ay nakita na at naipon ng perl
bago maipasa ang kontrol sa regex compiler.

gulat: strxfrm() nagiging walang katotohanan - a => %u, ab => %u
(P) Ang pagsusuri sa katinuan ng interpreter sa C function strxfrm() nabigo. Sa iyong
kasalukuyang lokal ang ibinalik na pagbabago ng string na "ab" ay mas maikli kaysa sa
ang string na "a", na walang kahulugan.

pagkasindak: sv_chop %s
(P) Ang sv_chop() naipasa ang routine sa isang posisyon na wala sa string ng scalar
buffer.

panic: sv_insert, midend=%p, bigend=%p
(P) Ang sv_insert() Sinabihan ang routine na mag-alis ng mas maraming string kaysa mayroong string.

gulat: top_env
(P) Sinubukan ng compiler na gumawa ng goto, o isang bagay na kakaiba tulad niyan.

panic: tinawag na hindi naipatupad na op %s (#%d).
(P) Ang compiler ay sira at sinubukang gumamit ng isang op na hindi pinahihintulutan sa pagtakbo
time.

gulat: utf16_to_utf8: kakaibang bytelen
(P) May sumubok na tumawag sa utf16_to_utf8 na may kakaiba (kumpara sa even) byte
haba.

gulat: utf16_to_utf8_reversed: kakaibang bytelen
(P) May sinubukang tawagan ang utf16_to_utf8_reversed na may kakaiba (kumpara sa even)
haba ng byte.

gulat: yylex, %s
(P) Masama ang kalagayan ng lexer habang pinoproseso ang isang case modifier.

Nawawala ang mga panaklong sa paligid ng "%s" na listahan
(W parenthesis) May sinabi ka na parang

aking $foo, $bar = @_;

kapag sinadya mo

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

Tandaan na ang "aking", "atin", "lokal" at "estado" ay nagbibigkis nang mas mahigpit kaysa kuwit.

Panloob na error sa pag-parse ng code (%s)
(F) Ang parsing code na ibinigay ng isang extension ay lumabag sa parser's API sa isang detectable
paraan.

Hindi na ginagamit ang pagpasa ng mali ang pormang UTF-8 sa "%s".
(D hindi na ginagamit, utf8) Ang mensaheng ito ay nagpapahiwatig ng isang bug alinman sa Perl core o sa XS
code. Sinusubukan ng naturang code na alamin kung ang isang character, di-umano'y naka-imbak sa loob
naka-encode bilang UTF-8, ay nasa isang partikular na uri, gaya ng pagiging bantas o isang digit. Ngunit ang
hindi na-encode ang character sa legal na UTF-8. Ang %s ay pinalitan ng isang string na maaaring
ginagamit ng mga taong may kaalaman upang matukoy kung ano ang uri ng sinusuri laban. Kung
Ang mga babala ng "utf8" ay pinagana, isang karagdagang mensahe ang itataas, na nagbibigay ng mga detalye ng
maling anyo

Ang pattern na subroutine nesting nang walang pagbabago sa pos ay lumampas sa limitasyon sa regex
(F) Gumamit ka ng pattern na gumagamit ng masyadong maraming nested subpattern na tawag nang hindi kumukonsumo
anumang text. Ayusin ang pattern upang maubos ang text bago ang limitasyon ng nesting
lumampas.

"-p" na patutunguhan: %s
(F) May naganap na error sa panahon ng implicit na output na na-invoke ng "-p" command-line
lumipat. (Ang output na ito ay mapupunta sa STDOUT maliban kung na-redirect mo ito gamit ang piliin().)

Ang bersyon ng Perl API na %s ng %s ay hindi tumutugma sa %s
(F) Ang XS module na pinag-uusapan ay pinagsama-sama laban sa ibang hindi tugmang bersyon ng
Perl kaysa sa nag-load ng XS module.

Ang mga panuntunan sa pagtitiklop ng Perl ay hindi napapanahon para sa 0x%X; mangyaring gamitin ang perlbug utility upang mag-ulat;
sa regex; minarkahan ng <-- DITO sa m/%s/
(S regexp) Gumamit ka ng regular na expression na may case-insensitive na pagtutugma, at mayroon
isang bug sa Perl kung saan hindi tumpak ang mga naka-built-in na panuntunan sa pag-fold ng regular na expression.
Ito ay maaaring humantong sa mga maling resulta. Mangyaring iulat ito bilang isang bug gamit ang perlbug
kagamitan.

PerlIO layer ':win32' ay eksperimental
(S experimental::win32_perlio) Ang ":win32" PerlIO layer ay experimental. Kung gusto mo
upang kunin ang panganib na gamitin ang layer na ito, huwag paganahin ang babalang ito:

walang babala "experimental::win32_perlio";

Hindi available ang Perl_my_%s().
(F) Ang iyong platform ay may napakabihirang byte-order at laki ng integer, kaya hindi
posibleng i-set up ang ilan o lahat ng fixed-width byte-order na function ng conversion. Ito ay
problema lang kapag ginagamit mo ang mga modifier na '<' o '>' sa (un)pack na mga template. Tingnan mo
"pack" sa perlfunc.

Kinakailangan ang Perl %s (ang ibig mo bang sabihin ay %s?)--ito ay %s lamang, huminto
(F) Ang code na sinusubukan mong patakbuhin ay humingi ng mas bagong bersyon ng Perl kaysa sa iyo
tumatakbo. Marahil ay isinulat ang "use 5.10" sa halip na "use 5.010" o "use v5.10".
Kung wala ang nangungunang "v", ang numero ay binibigyang-kahulugan bilang isang decimal, sa bawat tatlo
mga digit pagkatapos ng decimal point na kumakatawan sa isang bahagi ng numero ng bersyon. Kaya 5.10 ay
katumbas ng v5.100.

Kinakailangan ang Perl %s--ito ay %s lamang, itinigil
(F) Ang module na pinag-uusapan ay gumagamit ng mga feature ng isang bersyon ng Perl na mas bago kaysa sa
kasalukuyang tumatakbong bersyon. Gaano katagal na rin mula noong nag-upgrade ka? Tingnan mo
"nangangailangan" sa perlfunc.

Masyadong mahaba ang PERL_SH_DIR
(F) Isang error na kakaiba sa OS/2. Ang PERL_SH_DIR ay ang direktoryo upang mahanap ang "sh"-shell
sa. Tingnan ang "PERL_SH_DIR" sa perlos2.

PERL_SIGNALS ilegal: "%s"
(X) Tingnan ang "PERL_SIGNALS" sa perlrun para sa mga legal na halaga.

Perls dahil %s masyadong moderno--ito ay %s, tumigil
(F) Ang code na sinusubukan mong patakbuhin ay nagsasabing hindi ito tatakbo sa bersyon ng Perl mo
ay ginagamit dahil ito ay masyadong bago. Marahil ang code ay kailangang i-update, o marahil ito ay
mali lang at dapat tanggalin na lang ang version check.

perl: babala: Hindi hex na character sa '$ENV{PERL_HASH_SEED}', ang seed ay bahagyang nakatakda
(S) Ang PERL_HASH_SEED ay dapat tumugma sa /^\s*(?:0x)?[0-9a-fA-F]+\s*\z/ ngunit naglalaman ito ng hindi
hex na karakter. Ito ay maaaring mangahulugan na hindi mo ginagamit ang hash seed na sa tingin mo ay ikaw.

perl: babala: Nabigo ang pagtatakda ng lokal.
(S) Ang buong mensahe ng babala ay magiging katulad ng:

perl: babala: Nabigo ang pagtatakda ng lokal.
perl: babala: Mangyaring suriin kung ang iyong mga setting ng lokal:
LC_ALL = "En_US",
LANG = (unset)
ay suportado at naka-install sa iyong system.
perl: babala: Bumabalik sa karaniwang lokal ("C").

Eksakto kung ano ang mga nabigong setting ng lokal na nag-iiba. Sa itaas ang mga setting ay
na ang LC_ALL ay "En_US" at ang LANG ay walang halaga. Ang error na ito ay nangangahulugan na ang Perl
nakita na ikaw at/o ang iyong supplier ng operating system at/o system administrator
na-set up ang tinatawag na locale system ngunit hindi magagamit ni Perl ang mga setting na iyon. Ito
was not dead serious, buti na lang: may "default locale" na tinatawag na "C" na Perl
maaari at gagamitin, at tatakbo ang script. Bago mo talaga ayusin ang problema,
gayunpaman, makakakuha ka ng parehong mensahe ng error sa bawat oras na patakbuhin mo ang Perl. Paano ba talaga
ayusin ang problema ay matatagpuan sa perllocale seksyon LOKAL PROBLEMA.

perl: babala: kakaibang setting sa '$ENV{PERL_PERTURB_KEYS}': '%s'
(S) Ang Perl ay pinatakbo gamit ang environment variable na PERL_PERTURB_KEYS na tinukoy ngunit
naglalaman ng hindi inaasahang halaga. Ang mga legal na halaga ng setting na ito ay ang mga sumusunod.

Numeric | String | Resulta
--------------------------------------------------------- ----------------
0 | HINDI | Hindi pinapagana ang key traversal randomization
1 | RANDOM | Pinapagana ang buong key traversal randomization
2 | DETERMINISTIC | Pinapagana ang repeatable key traversal
| | randomization

Parehong tinatanggap ang mga numeric at string na halaga, ngunit tandaan na ang mga halaga ng string ay case
sensitibo. Ang default para sa setting na ito ay "RANDOM" o 1.

pid %x hindi bata
(W exec) Isang babala na kakaiba sa VMS. Waitpid() ay hiniling na maghintay para sa isang proseso kung saan
ay hindi isang subprocess ng kasalukuyang proseso. Bagama't maganda ito sa pananaw ng VMS,
malamang hindi ito ang iyong sinadya.

Ang 'P' ay dapat na may tahasang laki sa pag-unpack
(F) Ang unpack na format na P ay dapat na may tahasang laki, hindi "*".

Ang pop on reference ay pang-eksperimento
(S experimental::autoderef) Ang "pop" na may scalar argument ay eksperimental at maaaring
baguhin o alisin sa hinaharap na bersyon ng Perl. Kung nais mong kunin ang panganib sa paggamit
ang tampok na ito, huwag paganahin ang babalang ito:

walang babala "experimental::autoderef";

POSIX class [:%s:] hindi alam sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang klase sa klase ng character na [: :] syntax ay hindi alam. Ang <-- HERE ay nagpapakita
kung saan sa regular na expression ang problema ay natuklasan. Tandaan na ang POSIX
ginagawa ng mga klase ng karakter hindi magkaroon ng prefix na "ay" ang mga kaukulang C interface ay mayroong: in
sa ibang salita, ito ay "[[:print:]]", hindi "isprint". Tingnan ang perlre.

Ang POSIX getpgrp ay hindi maaaring kumuha ng argumento
(F) Ang iyong system ay may POSIX getpgrp(), na hindi kumukuha ng argumento, hindi katulad ng bersyon ng BSD,
na kumukuha ng pid.

Ang POSIX syntax [%c %c] ay kabilang sa loob ng mga klase ng character sa regex; minarkahan ng <-- DITO sa
MS/
(W regexp) Ang klase ng character ay bumubuo ng [: :], [= =], at [. .] go loob katangian
classes, ang [] ay bahagi ng construct, halimbawa: /[012[:alpha:]345]/. nota
na [= =] at [. .] ay hindi kasalukuyang ipinatupad; sila ay mga placeholder lamang para sa
mga extension sa hinaharap at magdudulot ng mga nakamamatay na error. Ang <-- DITO ay nagpapakita ng kinaroroonan sa
regular expression natuklasan ang problema. Tingnan ang perlre.

POSIX syntax [. .] ay nakalaan para sa hinaharap na mga extension sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Sa loob ng regular na expression ng mga klase ng character ([]) ang syntax na nagsisimula sa "[."
at nagtatapos sa ".]" ay nakalaan para sa mga extension sa hinaharap. Kung kailangan mong kumatawan
ang mga pagkakasunud-sunod ng character na iyon sa loob ng isang regular na expression ng klase ng character, sipiin lamang ang
mga square bracket na may backslash: "\[." at ".\]". Ang <-- HERE ay nagpapakita kung nasaan
sa regular na expression ang problema ay natuklasan. Tingnan ang perlre.

Ang POSIX syntax [= =] ay nakalaan para sa hinaharap na mga extension sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Sa loob ng regular na expression ng mga klase ng character ([]) ang syntax na nagsisimula sa "[="
at nagtatapos sa "=]" ay nakalaan para sa mga extension sa hinaharap. Kung kailangan mong kumatawan
ang mga pagkakasunud-sunod ng character na iyon sa loob ng isang regular na expression ng klase ng character, sipiin lamang ang
mga square bracket na may backslash: "\[=" at "=\]". Ang <-- HERE ay nagpapakita kung nasaan
sa regular na expression ang problema ay natuklasan. Tingnan ang perlre.

Posibleng pagtatangka na maglagay ng mga komento qw() listahan
(W qw) qw() naglalaman ang mga listahan ng mga item na pinaghihiwalay ng whitespace; tulad ng literal na mga string,
ang mga character ng komento ay hindi binabalewala, ngunit sa halip ay itinuturing bilang literal na data. (Maaari kang
gumamit ng iba't ibang delimiter kaysa sa mga panaklong na ipinapakita dito; mga braces din
madalas ginagamit.)

Marahil ay sumulat ka ng ganito:

@list = qw(
isang # isang komento
b # isa pang komento
);

kapag dapat mong isulat ito:

@list = qw(
a
b
);

Kung talagang gusto mo ng mga komento, buuin ang iyong listahan sa makalumang paraan, na may mga quote at
mga kuwit:

@list = (
'a', # isang komento
'b', # isa pang komento
);

Posibleng pagtatangka na paghiwalayin ang mga salita gamit ang mga kuwit
(W qw) qw() naglalaman ang mga listahan ng mga item na pinaghihiwalay ng whitespace; samakatuwid ang mga kuwit ay hindi
kailangan upang paghiwalayin ang mga bagay. (Maaaring gumamit ka ng ibang mga delimiter kaysa sa
mga panaklong ipinapakita dito; Ang mga braces ay madalas ding ginagamit.)

Marahil ay sumulat ka ng ganito:

qw! a, b, c!;

na naglalagay ng literal na mga kuwit sa ilan sa mga item sa listahan. Isulat ito nang walang kuwit kung ikaw
hindi nais na lumitaw ang mga ito sa iyong data:

qw! abc!;

Posibleng pagkasira ng memorya: %s ang umapaw sa 3rd argument
(F) Isang ioctl() or fcntl() nagbalik ng higit pa kaysa sa pinag-uutos ni Perl. Hulaan ni Perl a
makatwirang laki ng buffer, ngunit naglalagay ng sentinel byte sa dulo ng buffer sa loob lang
kaso. Na-clobbered ang sentinel byte na ito, at ipinapalagay ni Perl na ang memorya ay ngayon
corrupted. Tingnan ang "ioctl" sa perlfunc.

Posibleng isyu sa pangunguna sa control flow operator
(W syntax) May posibleng problema sa paghahalo ng isang control flow operator
(hal. "return") at isang low-precedence operator tulad ng "o". Isaalang-alang:

sub { ibalik ang $a o $b; }

Ito ay na-parse bilang:

sub { (ibalik ang $a) o $b; }

Na kung saan ay epektibo lamang:

sub { return $a; }

Gumamit ng mga panaklong o ang high-precedence na variant ng operator.

Tandaan na maaari rin itong ma-trigger para sa mga construct tulad ng:

sub { 1 kung mamatay; }

Posibleng problema sa pag-uuna sa bitwise %s operator
(W precedence) Gumagamit ang iyong program ng bitwise logical operator kasabay ng a
operator ng paghahambing ng numero, tulad nito:

kung ($x at $y == 0) { ... }

Ang expression na ito ay aktwal na katumbas ng "$x & ($y == 0)", dahil sa mas mataas
nangunguna sa "==". Malamang hindi ito ang gusto mo. (Kung talagang sinadya mo
isulat ito, huwag paganahin ang babala, o, mas mabuti, ilagay ang mga panaklong tahasan at isulat
"$x & ($y == 0)").

Posibleng hindi sinasadyang interpolation ng $\ sa regex
(W ambiguous) May sinabi ka tulad ng "m/$\/" sa isang regex. Ang regex na "m/foo$\s+bar/m"
isinasalin sa: tumugma sa salitang 'foo', ang output record separator (tingnan ang "$\" sa perlvar)
at ang letrang 's' (isang beses o higit pa) na sinusundan ng salitang 'bar'.

Kung ito ang iyong nilayon, maaari mong patahimikin ang babala sa pamamagitan ng paggamit ng "m/${\}/" (para sa
halimbawa: "m/foo${\}s+bar/").

Kung sa halip ay nilayon mong itugma ang salitang 'foo' sa dulo ng linya na sinusundan ng
whitespace at ang salitang 'bar' sa susunod na linya pagkatapos ay maaari mong gamitin ang "m/$(?)\/" (para sa
halimbawa: "m/foo$(?)\s+bar/").

Posibleng hindi sinasadyang interpolation ng %s sa string
(W ambiguous) May sinabi kang parang '@foo' sa isang double-quoted string pero meron
walang array @foo sa saklaw sa panahong iyon. Kung gusto mo ng literal na @foo, isulat ito bilang
\@foo; kung hindi, alamin kung ano ang nangyari sa array na tila nawala sa iyo.

Pang-eksperimento ang postfix dereference
(S experimental::postderef) Ang babalang ito ay ipapalabas kung gagamitin mo ang eksperimental
postfix dereference syntax. Pigilan lang ang babala kung gusto mong gamitin ang
feature, ngunit alam mong sa paggawa nito ay nanganganib kang gumamit ng isang eksperimental
tampok na maaaring magbago o maalis sa hinaharap na bersyon ng Perl:

walang babala "experimental::postderef";
gamitin ang tampok na "postderef", "postderef_qq";
$ref->$*;
$aref->@*;
$aref->@[@indices];
... atbp ...

Pangunahing problema: bukas %s dapat na bukas(%s)
(S precedence) Ang lumang hindi regular na konstruksyon

buksan ang FOO || mamatay;

ngayon ay misinterpreted bilang

bukas(FOO || mamatay);

dahil sa mahigpit na regularisasyon ng gramatika ng Perl 5 sa unary at list
mga operator. (Ang lumang bukas ay kaunti sa pareho.) Dapat kang maglagay ng mga panaklong sa paligid ng
filehandle, o gamitin ang bagong "o" operator sa halip na "||".

Napaaga ang pagtatapos ng mga header ng script
Tingnan ang Server error.

printf() sa saradong filehandle %s
(W closed) Ang filehandle na isinusulat mo ay naisara nito minsan bago ngayon.
Suriin ang iyong daloy ng kontrol.

i-print () sa saradong filehandle %s
(W closed) Ang filehandle kung saan ka nagpi-print ay naisara mismo minsan bago ngayon.
Suriin ang iyong daloy ng kontrol.

Tinapos ng SIG%s ang proseso
(W) Ito ay isang karaniwang mensahe na inisyu ng OS/2 application, habang *nix application
mamatay sa katahimikan. Ito ay itinuturing na isang tampok ng OS/2 port. Ang isa ay madaling hindi paganahin
ito sa pamamagitan ng naaangkop na mga sighandler, tingnan ang "Signals" sa perlipc. Tingnan din ang "Proseso
winakasan ng SIGTERM/SIGINT" sa perlos2.

Hindi alam ang property na '%s' sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang pinangalanang property na iyong tinukoy sa pamamagitan ng "\p" o "\P" ay hindi kilala ni Perl.
Baka nagkamali ka ng spelling ng pangalan? Tingnan ang "Mga Property na naa-access sa pamamagitan ng \p{} at \P{}" sa
perluniprops para sa kumpletong listahan ng mga available na opisyal na pag-aari. Kung ito ay isang gumagamit-
tinukoy na ari-arian dapat itong tinukoy sa oras na ang regular na expression ay
pinagsama-sama

Prototype pagkatapos ng '%c' para sa %s : %s
(W illegalproto) Ang isang character ay sumusunod sa % o @ sa isang prototype. Ito ay walang silbi, dahil %
at @ kainin ang iba pang mga subroutine na argumento.

Prototype mismatch: %s vs %s
(S prototype) Ang subroutine na idineklara o tinukoy ay dati nang idineklara o
tinukoy na may ibang function na prototype.

Hindi winakasan ang prototype
(F) Inalis mo ang pagsasara ng panaklong sa isang kahulugan ng prototype ng function.

Prototype na '%s' na na-override ng attribute na 'prototype(%s)' sa %s
(W prototype) Isang prototype ang idineklara sa parehong panaklong pagkatapos ng sub name at
sa pamamagitan ng katangian ng prototype. Ang prototype sa panaklong ay walang silbi, dahil ito ay
ay mapalitan ng prototype mula sa attribute bago pa man ito magamit.

Ang push on reference ay eksperimental
(S experimental::autoderef) Ang "push" na may scalar argument ay eksperimental at maaaring
baguhin o alisin sa hinaharap na bersyon ng Perl. Kung nais mong kunin ang panganib sa paggamit
ang tampok na ito, huwag paganahin ang babalang ito:

walang babala "experimental::autoderef";

Walang sinusunod ang quantifier sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Nagsimula ka ng isang regular na expression na may isang quantifier. I-backslash ito kung sinadya mo ito
literal. Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema
natuklasan. Tingnan ang perlre.

Quantifier sa {,} mas malaki sa %d sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Kasalukuyang may limitasyon sa laki ng min at max na halaga ng {min,max}
bumuo. Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema
natuklasan. Tingnan ang perlre.

Ang Quantifier {n,m} na may n > m ay hindi maaaring tumugma sa regex
Ang Quantifier {n,m} na may n > m ay hindi maaaring tumugma sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) Ang minimum ay dapat na mas mababa sa o katumbas ng maxima. Kung talagang gusto mo ang iyong
regexp upang tumugma sa isang bagay ng 0 beses, ilagay lang ang {0}.

Hindi inaasahang quantifier sa zero-length na expression sa regex m/%s/
(W regexp) Naglapat ka ng isang regular na expression quantifier sa isang lugar kung saan ito ay gumagawa ng no
kahulugan, tulad ng sa isang zero-width assertion. Subukang ilagay ang quantifier sa loob ng
paninindigan sa halip. Halimbawa, ang paraan upang tumugma sa "abc" sa kondisyon na ito ay sinusunod
sa pamamagitan ng tatlong pag-uulit ng "xyz" ay "/abc(?=(?:xyz){3})/", hindi "/abc(?=xyz){3}/".

Range iterator sa labas ng integer range
(F) Isa (o pareho) sa mga numeric na argumento sa range operator na ".." ay nasa labas ng
range na maaaring kinakatawan ng mga integer sa loob. Ang isang posibleng solusyon ay ang
pilitin ang Perl na gumamit ng magical string increment sa pamamagitan ng paglalagay ng "0" sa iyong mga numero.

Ang mga saklaw ng ASCII printable ay dapat na ilang subset ng "0-9", "AZ", o "az" sa regex;
minarkahan ng <-- DITO sa m/%s/
(W regexp) (sa ilalim lamang ng "use re 'strict'" o sa loob ng "(?[...])")

Ang mas mahigpit na mga panuntunan ay nakakatulong upang mahanap ang mga typo at iba pang mga error. Marahil ay hindi mo man lang sinasadya a
range dito, kung ang "-" ay sinadya upang maging ibang karakter, o dapat ay
nakatakas (tulad ng "\-"). Kung nilayon mo nga ang isang saklaw, ang ginamit ay hindi portable
sa pagitan ng mga platform ng ASCII at EBCDIC, at walang malinaw na kahulugan sa isang kaswal
reader.

[3-7] # OK; Obvious at portable
[dg] # OK; Obvious at portable
[AY] # OK; Obvious at portable
[Az] # MALI; Hindi portable; hindi malinaw kung ano ang ibig sabihin
[aZ] # MALI; Hindi portable; hindi malinaw kung ano ang ibig sabihin
[%-.] # MALI; Hindi portable; hindi malinaw kung ano ang ibig sabihin
[\x41-Z] # MALI; Hindi portable; hindi halata sa hindi geek

(Maaari mong pilitin ang portability sa pamamagitan ng pagtukoy ng isang Unicode range, na nangangahulugang ang
ang mga endpoint ay tinukoy ng "\N{...}", ngunit maaaring hindi pa rin halata ang kahulugan.) Ang
Ang mas mahigpit na mga panuntunan ay nangangailangan ng mga saklaw na nagsisimula o huminto sa isang ASCII na character na
hindi isang kontrol ang lahat ng kanilang mga endpoint ay ang literal na karakter, at hindi ang ilang pagtakas
sequence (tulad ng "\x41"), at ang mga hanay ay dapat na lahat ng digit, o lahat ng malalaking titik,
o lahat ng maliliit na titik.

Ang mga hanay ng mga digit ay dapat mula sa parehong pangkat sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) (sa ilalim lamang ng "use re 'strict'" o sa loob ng "(?[...])")

Ang mas mahigpit na mga panuntunan ay nakakatulong upang mahanap ang mga typo at iba pang mga error. Nagsama ka ng range, at sa
kahit isa sa mga end point ay isang decimal digit. Sa ilalim ng mas mahigpit na mga patakaran, kapag ito
mangyayari, ang parehong mga end point ay dapat na mga digit sa parehong pangkat ng 10 magkakasunod na digit.

readdir() sinubukan sa di-wastong dirhandle %s
(W io) Ang dirhandle na iyong binabasa ay maaaring sarado o hindi talaga isang dirhandle.
Suriin ang iyong daloy ng kontrol.

Basahin ang linya() sa saradong filehandle %s
(W closed) Ang filehandle na binabasa mo ay nagsara mismo minsan bago ngayon.
Suriin ang iyong daloy ng kontrol.

basahin () sa saradong filehandle %s
(W sarado) Sinubukan mong magbasa mula sa isang saradong filehandle.

basahin () sa hindi pa nabuksang filehandle %s
(W unopen) Sinubukan mong magbasa mula sa isang filehandle na hindi nabuksan.

Masyadong malaki ang relokasyon: %x
(F) Hindi ka maaaring maglaan ng higit sa 64K sa isang MS-DOS machine.

realloc() ng pinalayang memorya ay hindi pinansin
(S malloc) Isang panloob na gawain na tinatawag realloc() sa isang bagay na dati na
pinalaya.

I-compile muli ang perl gamit ang -DDEBUGGING gamitin -D lumipat
(S debugging) Hindi mo magagamit ang -D opsyon maliban kung ang code upang makagawa ng ninanais
ang output ay pinagsama-sama sa Perl, na nangangailangan ng ilang overhead, kaya naman sa kasalukuyan
naiwan sa iyong kopya.

Paulit-ulit na tawag sa Perl_load_module sa PerlIO_find_layer
(P) Kasalukuyang hindi pinahihintulutan na mag-load ng mga module kapag gumagawa ng filehandle sa loob ng isang
%INC hook. Ito ay maaaring mangyari sa "open my $fh, '<', \$scalar", na tuwirang naglo-load
PerlIO::scalar. Subukan munang i-load ang PerlIO::scalar.

May nakitang recursive inheritance sa package na '%s'
(F) Habang kinakalkula ang method resolution order (MRO) ng isang package, pinaniniwalaan ito ni Perl
nakakita ng walang katapusang loop sa @ISA hierarchy. Isa itong magaspang na tseke na nakapiyansa
pagkatapos ng 100 level ng @ISA depth.

Redundant argument sa %s
(W redundant) Tumawag ka ng isang function na may higit pang mga argumento kaysa sa iba pang mga argumento sa iyo
ang ibinigay na ipinahiwatig ay kakailanganin. Kasalukuyang inilalabas lamang kapag may format na uri ng printf
nangangailangan ng mas kaunting mga argumento kaysa sa ibinigay, ngunit maaaring magamit sa hinaharap para sa hal
"pack" sa perlfunc.

refcnt_dec: fd %d%s
refcnt: fd %d%s
refcnt_inc: fd %d%s
(P) Nabigo ang pagpapatupad ng I/O ng Perl sa isang internal consistency check. Kung nakikita mo ito
mensahe, may mali.

Natagpuan ang sanggunian kung saan inaasahan ang pantay na laki ng listahan
(W misc) Nagbigay ka ng isang sanggunian kung saan inaasahan ni Perl ang isang listahan na may pantay
bilang ng mga elemento (para sa pagtatalaga sa isang hash). Karaniwang nangangahulugan ito na ginamit mo ang
anon hash constructor kapag sinadya mong gumamit ng parens. Sa anumang kaso, nangangailangan ang isang hash
susi/halaga pares.

%hash = { isa => 1, dalawa => 2, }; # MALI
%hash = [ qw/ isang anon array / ]; # MALI
%hash = ( isa => 1, dalawa => 2, ); #tama
%hash = qw( isa 1 dalawa 2 ); #ayos din

Mahina na ang reference
(W misc) Tinangka mong pahinain ang isang reference na mahina na. Ang paggawa nito ay may
walang epekto.

Sanggunian sa di-wastong pangkat 0 sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ginamit mo ang "\g0" o katulad sa isang regular na expression. Maaari kang sumangguni sa pagkuha
panaklong lamang na may mahigpit na positibong integer (normal na mga backreference) o may
mahigpit na mga negatibong integer (relative backreferences). Ang paggamit ng 0 ay hindi makatwiran.

Sanggunian sa hindi umiiral na pangkat sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng isang bagay tulad ng "\7" sa iyong regular na expression, ngunit wala sa
hindi bababa sa pitong set ng pagkuha ng mga panaklong sa expression. Kung gusto mong magkaroon
ang character na may ordinal 7 na ipinasok sa regular na expression, prepend zero sa
gawin itong tatlong digit ang haba: "\007"

Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan.

Sanggunian sa hindi umiiral na pinangalanang pangkat sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng isang bagay tulad ng "\k'NAME'" o "\k "sa iyong regular na ekspresyon, ngunit
walang katumbas na pangalang kumukuha ng mga panaklong gaya ng "(?'NAME'...)" o
"(? ...)". Suriin kung ang pangalan ay nabaybay nang tama pareho sa
backreference at ang deklarasyon.

Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan.

Pagtukoy sa wala o hindi saradong grupo sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng isang bagay tulad ng "\g{-7}" sa iyong regular na expression, ngunit wala sa
hindi bababa sa pitong set ng closed capturing parentheses sa expression bago kung saan ang
"\g{-7}" ay matatagpuan.

Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan.

regexp memory corruption
(P) Ang regular na expression engine ay nalito sa kung ano ang regular na expression compiler
Ibinigay ito.

Ang regexp modifier na "/%c" ay maaaring lumabas ng maximum na dalawang beses
Ang regexp modifier na "%c" ay maaaring lumabas ng maximum na dalawang beses sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang pattern ng regular na expression ay nagkaroon ng masyadong maraming paglitaw ng tinukoy na modifier.
Alisin ang mga extraneous.

Maaaring hindi lumabas ang regexp modifier na "%c" pagkatapos ng "-" sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang pag-off sa ibinigay na modifier ay may side effect ng pag-on sa isa pa.
Kasalukuyang hindi ito pinapayagan ni Perl. Salita muli ang regular na expression upang magamit ang modifier
gusto mong i-on (at ilagay ito bago ang minus), sa halip na ang gusto mo
patayin.

Maaaring hindi lumabas nang dalawang beses ang regexp modifier na "/%c".
Ang regexp modifier na "%c" ay maaaring hindi lumabas nang dalawang beses sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang pattern ng regular na expression ay nagkaroon ng masyadong maraming paglitaw ng tinukoy na modifier.
Alisin ang mga extraneous.

Ang mga regexp modifier na "/%c" at "/%c" ay kapwa eksklusibo
Ang mga regexp modifier na "%c" at "%c" ay kapwa eksklusibo sa regex; minarkahan ng <-- DITO sa
MS/
(F) Ang pattern ng regular na pagpapahayag ay mayroong higit sa isa sa mga ito na magkahiwalay
mga modifier. Panatilihin lamang ang modifier na dapat na naroroon.

Regexp na wala sa espasyo sa regex m/%s/
(P) Isang error na "hindi maaaring mangyari", dahil safemalloc() dapat nahuli ito ng mas maaga.

Ang paulit-ulit na linya ng format ay hindi kailanman magwawakas (~~ at @#)
(F) Ang iyong format ay naglalaman ng ~~ repeat-until-blank sequence at isang numeric field na iyon
ay hindi kailanman magiging blangko upang ang pag-uulit ay hindi kailanman matatapos. Maaari mong gamitin ang ^#
sa halip. Tingnan ang perlform.

Ang listahan ng kapalit ay mas mahaba kaysa sa listahan ng paghahanap
(W misc) Gumamit ka ng kapalit na listahan na mas mahaba kaysa sa listahan ng paghahanap. Kaya ang
Ang mga karagdagang elemento sa listahan ng kapalit ay walang kahulugan.

Nalutas ang '%s' sa '\o{%s}%d'
(W misc, regexp) Sumulat ka ng isang bagay tulad ng "\08", o "\179" sa double-quotish
string. Lahat maliban sa huling digit ay itinuturing bilang isang character, na tinukoy sa octal.
Ang huling digit ay ang susunod na character sa string. Para sabihin kay Perl na ito talaga
kung ano ang gusto mo, maaari mong gamitin ang "\o{ }" syntax, o gumamit ng eksaktong tatlong digit upang tukuyin
ang octal para sa karakter.

Binaligtad ang %s= operator
(W syntax) Isinulat mo nang paatras ang iyong assignment operator. Ang = dapat laging huli,
upang maiwasan ang kalabuan sa mga kasunod na unary operator.

rewinddir() sinubukan sa di-wastong dirhandle %s
(W io) Ang dirhandle na sinubukan mong gawin a rewinddir() on ay sarado o hindi talaga a
dirhandle. Suriin ang iyong daloy ng kontrol.

Tumagas ang mga scaler: %d
(S internal) May nangyaring mali sa internal bookkeeping ng Perl ng mga scalar: hindi lahat
Ang mga scalar variable ay na-deallocate sa oras na lumabas si Perl. Ano ito kadalasan
ay isang memory leak, na siyempre masama, lalo na kung ang Perl program ay
nilayon na maging pangmatagalan.

Ang halaga ng scalar @%s[%s] ay mas mahusay na isinulat bilang $%s[%s]
(W syntax) Gumamit ka ng array slice (ipinahiwatig ng @) upang pumili ng isang elemento ng
isang array. Sa pangkalahatan, mas mainam na humingi ng scalar value (ipinahiwatig ng $). Ang
Ang kaibahan ay ang $foo[&bar] ay palaging kumikilos tulad ng isang scalar, parehong kapag itinalaga dito
at kapag sinusuri ang argumento nito, habang ang @foo[&bar] ay kumikilos tulad ng isang listahan kapag nagtalaga ka
dito, at nagbibigay ng konteksto ng listahan sa subscript nito, na maaaring gumawa ng mga kakaibang bagay kung
isang subscript lang ang inaasahan mo.

Sa kabilang banda, kung talagang umaasa kang ituring ang elemento ng array bilang isang listahan,
kailangan mong tingnan kung paano gumagana ang mga sanggunian, dahil hindi magko-convert si Perl
sa pagitan ng mga scalar at mga listahan para sa iyo. Tingnan ang perlref.

Ang scalar value na @%s{%s} ay mas mahusay na isinulat bilang $%s{%s}
(W syntax) Gumamit ka ng hash slice (ipinahiwatig ng @) upang pumili ng isang elemento ng isang
hash. Sa pangkalahatan, mas mainam na humingi ng scalar value (ipinahiwatig ng $). Ang
Ang pagkakaiba ay ang $foo{&bar} ay palaging kumikilos tulad ng isang scalar, parehong kapag itinalaga dito
at kapag sinusuri ang argumento nito, habang ang @foo{&bar} ay kumikilos tulad ng isang listahan kapag nagtalaga ka
dito, at nagbibigay ng konteksto ng listahan sa subscript nito, na maaaring gumawa ng mga kakaibang bagay kung
isang subscript lang ang inaasahan mo.

Sa kabilang banda, kung talagang umaasa kang ituring ang elemento ng hash bilang isang listahan,
kailangan mong tingnan kung paano gumagana ang mga sanggunian, dahil hindi magko-convert si Perl
sa pagitan ng mga scalar at mga listahan para sa iyo. Tingnan ang perlref.

Hindi winakasan ang pattern ng paghahanap
(F) Hindi mahanap ng lexer ang panghuling delimiter ng isang // o m{} construct. Tandaan
na ang bracketing delimiters ay nagbibilang ng nesting level. Nawawala ang nangungunang "$" mula sa a
variable $m ay maaaring maging sanhi ng error na ito.

Tandaan na dahil ang Perl 5.10.0 a // ay maaari ding maging ang tinukoy-o bumuo, hindi lamang ang
walang laman na pattern ng paghahanap. Samakatuwid ang code na nakasulat sa Perl 5.10.0 o mas bago na gumagamit ng //
bilang tinukoy-o maaaring ma-misparse ng pre-5.10.0 Perls bilang isang hindi natapos na paghahanap
pattern.

seekdir() sinubukan sa di-wastong dirhandle %s
(W io) Ang dirhandle na iyong ginagawa a seekdir() on ay sarado o hindi talaga a
dirhandle. Suriin ang iyong daloy ng kontrol.

%humanap() sa hindi pa nabuksang filehandle
(W unopen) Sinubukan mong gamitin ang Humanap() or sysseek() function sa isang filehandle na
ay hindi kailanman binuksan o mula noon ay sarado na.

piliin ang hindi ipinatupad
(F) Ang makinang ito ay hindi nagpapatupad ng piliin() tawag sa system.

Hindi sinusuportahan ang self-ties ng mga array at hash
(F) Ang mga self-ties ay mga arrays at ang mga hash ay hindi suportado sa kasalukuyang
pagpapatupad.

Parang nawawala ang semicolon
(W semicolon) Ang isang malapit na syntax error ay malamang na sanhi ng isang nawawalang tuldok-kuwit, o
posibleng may iba pang nawawalang operator, gaya ng kuwit.

semi-panic: pagtatangkang dup ng napalaya na string
(S panloob) Ang panloob newSVsv() ang routine ay tinawag upang duplicate ang isang scalar na mayroon
dating minarkahan bilang libre.

hindi ipinatupad ang sem%s
(F) Wala kang System V semaphore IPC sa iyong system.

ipadala () sa saradong socket %s
(Nakasarado ang W) Ang socket na ipinapadala mo sa sarili nitong sarado minsan bago ngayon. Suriin
ang iyong daloy ng kontrol.

Di-wasto ang sequence na "\c{".
(F) Ang tatlong character na ito ay maaaring hindi lumitaw sa pagkakasunud-sunod sa isang double-quotish na konteksto.
Ang mensaheng ito ay itinataas lamang sa mga hindi ASCII na platform (iba ang mensahe ng error
output sa mga ASCII). Kung ikaw ay nagbabalak na tumukoy ng isang control character kasama nito
sequence, kakailanganin mong gumamit ng ibang paraan para tukuyin ito.

Sequence (? hindi kumpleto sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Nagtapos ang isang regular na expression sa isang hindi kumpletong extension (?. Ang <-- HERE ay nagpapakita
kung saan sa regular na expression ang problema ay natuklasan. Tingnan ang perlre.

Sequence (?%c...) hindi ipinatupad sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang isang iminungkahing regular na extension ng expression ay may nakalaan na karakter ngunit wala pa
naisulat. Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema
ay nadiskubre. Tingnan ang perlre.

Sequence (?%s...) hindi nakilala sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng regular na extension ng expression na hindi makatuwiran. Ang <-- DITO
nagpapakita ng kinaroroonan sa regular na ekspresyon ang problema ay natuklasan. Ito ay maaaring
nangyayari kapag ginagamit ang "(?^...)" construct para sabihin kay Perl na gamitin ang default na regular
expression modifier, at kalabisan mong tinukoy ang isang default na modifier. Para sa iba
sanhi, tingnan ang perlre.

Sequence (?#... hindi winakasan sa regex m/%s/
(F) Ang isang regular na expression na komento ay dapat wakasan sa pamamagitan ng isang pansarang panaklong.
Hindi pinapayagan ang mga naka-embed na panaklong. Tingnan ang perlre.

Sequence (?&... hindi winakasan sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang isang pinangalanang sanggunian ng form na "(?&...)" ay nawawala ang panghuling pagsasara ng panaklong
pagkatapos ng pangalan. Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema
ay nadiskubre.

Sequence (?%c... hindi winakasan sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang isang pinangalanang pangkat ng anyong "(?'...')" o "(?<...>)" ay nawawala sa panghuling pagsasara
quote o angle bracket. Ang <-- DITO ay nagpapakita kung nasaan sa regular na expression ang
natuklasan ang problema.

Sequence (?(%c... hindi winakasan sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang isang pinangalanang sanggunian ng form na "(?('...')...)" o "(?(<...>)...)" ay nawawala ang
huling closing quote o angle bracket pagkatapos ng pangalan. Ang <-- HERE ay nagpapakita kung nasaan
sa regular na expression ang problema ay natuklasan.

Sequence (?... hindi winakasan sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Walang katugmang pansarang panaklong para sa '('. Ang <-- HERE ay nagpapakita
kung saan sa regular na expression ang problema ay natuklasan.

Sequence \%s... hindi winakasan sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Inaasahan ng regular na expression ang isang mandatoryong argumento kasunod ng pagkakasunud-sunod ng pagtakas
at ito ay tinanggal o mali ang pagkakasulat.

Sequence (?{...}) hindi tinapos ng ')'
(F) Ang dulo ng perl code na nasa loob ng {...} ay dapat na sundan kaagad
ng isang ')'.

Sequence ?P=... hindi winakasan sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang isang pinangalanang sanggunian ng form na "(?P=...)" ay nawawala ang panghuling pagsasara ng panaklong
pagkatapos ng pangalan. Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema
ay nadiskubre.

Sequence (?R) hindi winakasan sa regex m/%s/
(F) Ang isang "(?R)" o "(?0)" sequence sa isang regular na expression ay nawawala ang pangwakas
panaklong.

Error sa server (aka "500 Server error")
(A) Ito ang mensahe ng error na karaniwang nakikita sa isang browser window kapag sinusubukang magpatakbo ng a
CGI program (kabilang ang SSI) sa web. Ang aktwal na teksto ng error ay malawak na nag-iiba mula sa
server sa server. Ang pinakamadalas na nakikitang mga variant ay "500 Server error", "Paraan
(something) not permitted", "Document contains no data", "Premature end of script
mga header", at "Hindi nakagawa ng wastong header".

ito is a CGI pagkakamali, hindi a Perl mali.

Kailangan mong tiyakin na ang iyong script ay executable, ay naa-access ng user CGI ay
pagpapatakbo ng script sa ilalim (na marahil ay hindi ang user account na sinubukan mo ito sa ilalim),
ay hindi umaasa sa anumang mga variable ng kapaligiran (tulad ng PATH) mula sa user na hindi ito tumatakbo
sa ilalim, at wala sa isang lokasyon kung saan hindi ito mahanap ng CGI server, karaniwang, higit pa o
mas kaunti. Pakitingnan ang sumusunod para sa karagdagang impormasyon:

http://www.perl.org/CGI_MetaFAQ.html
http://www.htmlhelp.org/faq/cgifaq.html
http://www.w3.org/Security/Faq/

Dapat mo ring tingnan ang perlfaq9.

setegid() hindi ipinatupad
(F) Sinubukan mong italaga sa $), at hindi sinusuportahan ng iyong operating system ang setegid()
system call (o katumbas), o hindi bababa sa Configure ay hindi nag-isip.

seteuid() hindi ipinatupad
(F) Sinubukan mong magtalaga sa $>, at hindi sinusuportahan ng iyong operating system ang seteuid()
system call (o katumbas), o hindi bababa sa Configure ay hindi nag-isip.

setpgrp ay hindi maaaring kumuha ng mga argumento
(F) Ang iyong system ay mayroong setpgrp() mula sa BSD 4.2, na hindi kumukuha ng mga argumento, hindi katulad ng POSIX
setpgid(), na kumukuha ng process ID at process group ID.

setrgid() hindi ipinatupad
(F) Sinubukan mong magtalaga sa $(, at hindi sinusuportahan ng iyong operating system ang setrgid()
system call (o katumbas), o hindi bababa sa Configure ay hindi nag-isip.

setruid() hindi ipinatupad
(F) Sinubukan mong magtalaga sa $<, at hindi sinusuportahan ng iyong operating system ang setruid()
system call (o katumbas), o hindi bababa sa Configure ay hindi nag-isip.

setsockopt() sa saradong socket %s
(W closed) Sinubukan mong magtakda ng opsyon sa socket sa closed socket. Nakalimutan mo na ba
suriin ang return value ng iyong socket () tumawag? Tingnan ang "setsoccopt" sa perlfunc.

Ang pagtatakda ng ${^ENCODING} ay hindi na ginagamit
(D hindi na ginagamit) Nagtalaga ka ng value na hindi "undef" sa "${^ENCODING}". Ito ay
hindi na ginagamit; tingnan ang ""${^ENCODING}" sa perlvar" para sa mga detalye.

Ang pagtatakda ng $/ sa isang reference sa %s bilang isang paraan ng slurp ay hindi na ginagamit, na itinuturing bilang undef
(D hindi na ginagamit) Nagtalaga ka ng reference sa isang scalar sa $/ kung saan ang reference na item ay
hindi isang positibong integer. Sa mas lumang perls ito lumitaw upang gumana katulad ng pagtatakda nito
sa "undef" ngunit sa katunayan ay naiiba sa loob, hindi gaanong mahusay at napakalas
maaaring magresulta sa paghahati ng iyong file ng isang stringified form ng reference.

Sa Perl 5.20.0 ito ay binago upang ito ay maging tamang-tama kapareho ng pagtatakda ng $/ sa
undef, maliban na ang babalang ito ay itatapon.

Inirerekomenda mong baguhin ang iyong code upang itakda ang $/ sa "undef" nang tahasan kung gusto mo
slurp ang file. Sa hinaharap na mga bersyon ng Perl na nagtatalaga ng isang reference sa ay magtapon ng isang nakamamatay
error.

Ang pagtatakda ng $/ sa %s na sanggunian ay ipinagbabawal
(F) Sinubukan mong magtalaga ng reference sa isang hindi integer sa $/. Sa mas lumang Perls gagawin ito
ay kumilos nang katulad sa pagtatakda nito sa isang reference sa isang positibong integer, kung saan ang
integer ang address ng reference. Bilang ng Perl 5.20.0 ito ay isang nakamamatay na error, sa
payagan ang mga hinaharap na bersyon ng Perl na gumamit ng mga non-integer ref para sa mas kawili-wiling layunin.

Ang shift sa reference ay eksperimental
(S experimental::autoderef) Ang "shift" na may scalar argument ay eksperimental at maaaring
baguhin o alisin sa hinaharap na bersyon ng Perl. Kung nais mong kunin ang panganib sa paggamit
ang tampok na ito, huwag paganahin ang babalang ito:

walang babala "experimental::autoderef";

hindi ipinatupad ang shm%s
(F) Wala kang System V shared memory IPC sa iyong system.

!=~ dapat!~
(W syntax) Ang hindi tumutugmang operator ay !~, hindi !=~. !=~ ay bibigyang-kahulugan bilang ang
!= (numeric not equal) at ~ (1's complement) operator: malamang na hindi kung ano ang sa iyo
nilayon.

/%s/ ay dapat na isulat bilang "%s"
(W syntax) Gumamit ka ng pattern kung saan inaasahan ni Perl na makahanap ng string, tulad ng sa
unang argumento na "sumali". Ituturing ng Perl ang totoo o maling resulta ng pagtutugma ng
pattern laban sa $_ bilang string, na malamang na hindi ang nasa isip mo.

pag-shutdown () sa saradong socket %s
(W sarado) Sinubukan mong mag-shutdown sa isang saradong socket. Parang medyo kalabisan.

Hindi tinukoy ang handler ng SIG%s na "%s".
(W signal) Ang signal handler na pinangalanan sa %SIG ay hindi, sa katunayan, ay umiiral. Baka nilagay mo
ito sa maling pakete?

Ang slab ay tumagas mula sa cv %p
(S) Kung nakita mo ang mensaheng ito, kung gayon, may malubhang mali sa panloob
bookkeeping ng mga op tree. Kailangang palayain ang isang op tree pagkatapos ng error sa compilation, ngunit
hindi mahanap, kaya ito ay na-leak sa halip.

matulog(%u) masyadong malaki
(W overflow) Tinawag mo ang "sleep" na may numerong mas malaki kaysa sa maaasahan nito
hawakan at "tulog" ay malamang na natulog nang mas kaunting oras kaysa sa hiniling.

Hindi magtatagal ang slurpy parameter
(F) Sa isang subroutine signature, naglalagay ka ng isang bagay pagkatapos ng slurpy (array o hash)
parameter. Kinukuha ng slurpy parameter ang lahat ng magagamit na argumento, kaya hindi maaaring magkaroon
anumang natitira upang punan ang mga parameter sa ibang pagkakataon.

Ang matalinong pagtutugma ng isang bagay na hindi na-overload ay sumisira sa encapsulation
(F) Hindi mo dapat gamitin ang operator na "~~" sa isang bagay na hindi nag-overload dito: Perl
tumangging gamitin ang pinagbabatayan na istraktura ng bagay para sa matalinong tugma.

Ang Smartmatch ay eksperimental
(S experimental::smartmatch) Ipapalabas ang babalang ito kung gagamitin mo ang smartmatch ("~~")
operator. Ito ay kasalukuyang isang pang-eksperimentong tampok, at ang mga detalye nito ay napapailalim sa
pagbabago sa mga hinaharap na release ng Perl. Lalo na, ang kasalukuyang pag-uugali nito ay napansin para sa
pagiging hindi kinakailangang kumplikado at hindi intuitive, at malamang na ma-overhaul.

Ang sort ay isang reserbang salita na ngayon
(F) Isang sinaunang mensahe ng error na halos wala nang nakakasagabal. Pero kanina
Ang sort ay isang keyword, minsan ginagamit ito ng mga tao bilang filehandle.

Ang pag-uuri ng subroutine ay hindi nagbalik ng iisang halaga
(F) Ang subroutine ng paghahambing ng pag-uuri na nakasulat sa XS ay dapat magbalik ng eksaktong isang item. Tingnan mo
"sort" sa perlfunc.

Nalalapat lang ang mga filter ng pinagmulan sa mga byte stream
(F) Sinubukan mong i-activate ang isang source filter (karaniwan ay sa pamamagitan ng pag-load ng source filter module)
sa loob ng isang string na ipinasa sa "eval". Hindi ito pinahihintulutan sa ilalim ng "unicode_eval"
tampok. Pag-isipang gamitin ang "evalbytes" sa halip. Tingnan ang tampok.

splice() i-offset ang nakaraang dulo ng array
(W misc) Sinubukan mong tukuyin ang isang offset na lampas sa dulo ng array na naipasa
sa splice(). Sa halip, magsisimula ang pag-splice sa dulo ng array, sa halip na sa nakaraan
ito. Kung hindi ito ang gusto mo, subukang tahasang paunang palawakin ang array sa pamamagitan ng pagtatalaga
$#array = $offset. Tingnan ang "splice" sa perlfunc.

Ang splice sa sanggunian ay eksperimental
(S experimental::autoderef) Ang "splice" na may scalar argument ay eksperimental at maaaring
baguhin o alisin sa hinaharap na bersyon ng Perl. Kung nais mong kunin ang panganib sa paggamit
ang tampok na ito, huwag paganahin ang babalang ito:

walang babala "experimental::autoderef";

Hatiin ang loop
(P) Ang hati ay umiikot nang walang hanggan. (Malinaw, ang isang split ay hindi dapat umulit nang higit pa
beses kaysa mayroong mga character ng input, na kung ano ang nangyari.) Tingnan ang "split" sa
perlfunc.

Malamang na hindi maabot ang pahayag
(W exec) Ginawa mo ang isang exec() na may ilang pahayag pagkatapos nito maliban sa a mamatay (). Ito ay
halos palaging isang error, dahil exec() hindi na babalik maliban kung may kabiguan. Ikaw
malamang gustong gamitin sistema() sa halip, na bumabalik. Upang sugpuin ang babalang ito,
ilagay ang exec() sa isang bloke mag-isa.

Ang "state" subroutine %s ay hindi maaaring nasa isang package
(F) Ang mga subroutine na sakop ng leksikal ay wala sa isang package, kaya hindi makatuwirang subukan
para ideklara ang isa na may package qualifier sa harap.

"state %s" ang ginamit sa paghahambing ng pag-uuri
(W syntax) Ang mga variable ng package na $a at $b ay ginagamit para sa mga paghahambing ng pag-uuri. Ginamit mo ang $a
o $b in bilang isang operand sa operator na "<=>" o "cmp" sa loob ng bloke ng paghahambing ng pag-uuri,
at ang baryabol ay nauna nang idineklara bilang isang leksikal na baryabol. Maaaring maging kwalipikado ang
uri ng variable na may pangalan ng package, o palitan ang pangalan ng lexical variable.

Ang variable na "estado" %s ay hindi maaaring nasa isang package
(F) Wala sa isang pakete ang mga variable na saklaw ng leksikal, kaya hindi makatuwirang subukang
magdeklara ng isa na may package qualifier sa harap. Gamitin lokal() kung gusto mo
i-localize ang isang variable ng package.

stat () sa hindi pa nabuksang filehandle %s
(W unopen) Sinubukan mong gamitin ang stat () function sa isang filehandle na alinman
hindi pa nabubuksan o sarado na.

Ang mga string na may mga puntos ng code na higit sa 0xFF ay maaaring hindi ma-map sa mga in-memory na file handle
(W utf8) Sinubukan mong magbukas ng reference sa isang scalar para basahin o idugtong kung saan ang scalar
naglalaman ng mga puntos ng code na higit sa 0xFF. Ang mga in-memory na file ay nagmomodelo ng mga on-disk file at maaari lamang
naglalaman ng mga byte.

Natagpuan ang stub habang nireresolba ang paraan na "%s" na nag-overload sa "%s" sa package na "%s"
(P) Ang overloading na resolusyon sa puno ng @ISA ay maaaring masira ng mga stub ng pag-import. Mga stub
hindi dapat gawin nang tahasan, ngunit ang mga tahasang tawag sa "maaari" ay maaaring masira ito.

Hindi available ang subroutine na "&%s".
(W closure) Sa panahon ng compilation, sinusubukan ng isang panloob na pinangalanang subroutine o eval
kumuha ng outer lexical subroutine na kasalukuyang hindi available. Maaaring mangyari ito
para sa isa sa dalawang dahilan. Una, ang lexical subroutine ay maaaring ideklara sa isang panlabas
anonymous subroutine na hindi pa nagagawa. (Tandaan na ang mga pinangalanang sub ay
nilikha sa oras ng pag-compile, habang ang mga hindi kilalang sub ay nilikha sa oras ng pagtakbo.) Halimbawa,

sub { my sub a {...} sub f { \&a } }

Sa oras na nilikha ang f, hindi nito makuha ang kasalukuyang "a" sub, dahil ang
hindi pa nagagawa ang anonymous na subroutine. Sa kabaligtaran, ang mga sumusunod ay hindi magbibigay ng a
babala dahil ang hindi kilalang subroutine ay nagawa na at live na:

sub { my sub a {...} eval 'sub f { \&a }' }->();

Ang pangalawang sitwasyon ay sanhi ng isang eval na nag-access sa isang lexical subroutine na nawala
sa labas ng saklaw, halimbawa,

sub f {
ang aking sub a {...}
sub { eval '\&a' }
}
f()->();

Dito, kapag ang '\&a' sa eval ay kino-compile, f() ay kasalukuyang hindi
naisakatuparan, kaya ang &a nito ay hindi magagamit para sa pagkuha.

"%s" subroutine &%s masks mas naunang deklarasyon sa parehong %s
(W misc) Ang subroutine na "my" o "state" ay muling idineklara sa kasalukuyang saklaw o
pahayag, na epektibong inaalis ang lahat ng access sa nakaraang instance. Ito ay
halos palaging isang typographical error. Tandaan na ang naunang subroutine ay gagana pa rin
umiiral hanggang sa katapusan ng saklaw o hanggang sa masira ang lahat ng pagsasara ng mga sanggunian dito.

Muling tinukoy ang subroutine %s
(W redefine) Muling tinukoy mo ang isang subroutine. Upang sugpuin ang babalang ito, sabihin

{
walang babala 'muling tukuyin';
eval "sub name { ... }";
}

Ang subroutine na "%s" ay hindi mananatiling nakabahagi
(W pagsasara) Isang panloob (nakapugad) pinangalanan ang subroutine ay tumutukoy sa isang "aking" subroutine
tinukoy sa isang panlabas na pinangalanang subroutine.

Kapag tinawag ang panloob na subroutine, makikita nito ang halaga ng panlabas na subroutine
lexical subroutine tulad ng dati at noong *unang* tawag sa panlabas
subroutine; sa kasong ito, pagkatapos makumpleto ang unang tawag sa panlabas na subroutine,
ang panloob at panlabas na mga subroutine ay hindi na magkakaroon ng karaniwang halaga para sa leksikal
subroutine. Sa madaling salita, hindi na ito ibabahagi. Ito ay lalo na gagawa ng isang
pagkakaiba kung ang mga lexical na subroutine ay nag-a-access ng mga lexical na variable na idineklara sa nito
nakapalibot na saklaw.

Ang problemang ito ay kadalasang malulutas sa pamamagitan ng paggawa ng inner subroutine na hindi nakikilala, gamit ang
"sub {}" syntax. Kapag inner anonymous subs na tumutukoy sa lexical subroutines in
ang mga panlabas na subroutine ay nilikha, ang mga ito ay awtomatikong rebound sa kasalukuyang mga halaga ng
naturang lexical subs.

Loop ng pagpapalit
(P) Ang pagpapalit ay umiikot nang walang hanggan. (Malinaw, ang isang pagpapalit ay hindi dapat
umulit ng mas maraming beses kaysa sa mga character ng input, na kung ano ang nangyari.) Tingnan
ang talakayan ng pagpapalit sa "Regexp Quote-Like Operators" sa perlop.

Hindi winakasan ang pattern ng pagpapalit
(F) Hindi mahanap ng lexer ang interior delimiter ng isang s/// o s{}{} construct.
Tandaan na ang bracketing delimiters ay binibilang ang nesting level. Nawawala ang nangungunang "$" mula sa
variable $s ay maaaring maging sanhi ng error na ito.

Hindi winakasan ang pagpapalit
(F) Hindi mahanap ng lexer ang panghuling delimiter ng isang s/// o s{}{} construct.
Tandaan na ang bracketing delimiters ay binibilang ang nesting level. Nawawala ang nangungunang "$" mula sa
variable $s ay maaaring maging sanhi ng error na ito.

substr sa labas ng string
(W substr)(F) Sinubukan mong sumangguni sa a substr() na nakaturo sa labas ng isang string.
Ibig sabihin, ang absolute value ng offset ay mas malaki kaysa sa haba ng string.
Tingnan ang "substr" sa perlfunc. Nakamamatay ang babalang ito kung ginamit ang substr sa isang lvalue
konteksto (bilang kaliwang bahagi ng isang takdang-aralin o bilang isang subroutine na argumento para sa
halimbawa).

sv_upgrade mula sa uri %d pababa sa uri %d
(P) Sinubukan ni Perl na pilitin ang pag-upgrade ng isang SV sa isang uri na talagang mas mababa
ang kasalukuyang uri nito.

Hindi nagbalik ng HV ref ang SWASHNEW
(P) May nangyaring mali sa loob noong sinusubukang hanapin ni Perl ang Unicode
character.

Lumipat (?(kondisyon)... naglalaman ng masyadong maraming sangay sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang isang (?(condition)if-clause|else-clause) construct ay maaaring magkaroon ng hindi hihigit sa dalawang sangay (ang
kung-sugnay at ang ibang-sugnay). Kung gusto mo ang isa o pareho na maglaman ng alternation, ganoon
bilang paggamit ng "ito|na|iba", ilakip ito sa mga clustering parentheses:

(?(kondisyon)(?:ito|iyan|iba pa)|ibang-sugnay)

Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan.
Tingnan ang perlre.

Hindi nakilala ang kundisyon ng switch sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang bahagi ng kondisyon ng isang (?(condition)if-clause|else-clause) construct ay hindi
kilala. Ang kundisyon ay dapat isa sa mga sumusunod:

(1) (2) ... true kung 1st, 2nd, etc., ang capture ay tumugma
( ) ('NAME') true kung tumugma ang pangalang capture
(?=...) (?<=...) true kung tumugma ang subpattern
(?!...) (?
(?{ CODE }) true kung ang code ay nagbabalik ng totoong halaga
(R) true kung sinusuri ang inside recursion
(R1) (R2) ... totoo kung direkta sa loob ng pangkat ng pagkuha 1, 2, atbp.
(R&NAME) true kung direkta sa loob na pinangalanang capture
(DEFINE) palaging mali; para sa pagtukoy ng mga pinangalanang subpattern

Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan.
Tingnan ang perlre.

Lumipat (?(kondisyon)... hindi tinapos sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Inalis mong isara ang isang (?(kondisyon)...) block sa isang lugar sa pattern. Magdagdag ng a
pagsasara ng panaklong sa naaangkop na posisyon. Tingnan ang perlre.

hindi ipinatupad ang paglipat ng epektibong %s
(F) Habang nasa ilalim ng "use filetest" pragma, hindi natin maililipat ang tunay at epektibo
uid o gids.

error sa syntax
(F) Malamang ay nangangahulugang nagkaroon ka ng syntax error. Kasama sa mga karaniwang dahilan ang:

Ang isang keyword ay maling spelling.
Walang tuldok-kuwit.
Walang kuwit.
Walang pambungad o pagsasara ng panaklong.
Nawawala ang opening o closing brace.
Walang pangwakas na quote.

Kadalasan magkakaroon ng isa pang mensahe ng error na nauugnay sa pagbibigay ng error sa syntax ng higit pa
impormasyon. (Minsan nakakatulong na i-on -w.) Madalas ang mismong mensahe ng error
Sinasabi sa iyo kung nasaan ito sa linya noong nagpasya itong sumuko. Minsan ang aktwal
error ay ilang mga token bago ito, dahil Perl ay mahusay sa pag-unawa ng random
input. Paminsan-minsan ang numero ng linya ay maaaring mapanlinlang, at minsan sa isang asul na buwan ang
Ang tanging paraan upang malaman kung ano ang nagti-trigger ng error ay ang tumawag sa "perl -c" nang paulit-ulit,
pinuputol ang kalahati ng programa sa bawat oras upang makita kung nawala ang error. Uri ng
cybernetic na bersyon ng 20 tanong.

syntax error sa linyang %d: '%s' hindi inaasahan
(A) Hindi mo sinasadyang napatakbo ang iyong script sa Bourne shell sa halip na Perl.
Suriin ang #! linya, o manu-manong i-feed ang iyong script sa Perl mismo.

syntax error sa file %s sa linya %d, susunod na 2 token "%s"
(F) Ang error na ito ay malamang na mangyari kung magpapatakbo ka ng perl5 script sa pamamagitan ng perl4
interpreter, lalo na kung ang susunod na 2 token ay "gamitin nang mahigpit" o "my $var" o "aming
$var".

Syntax error sa (?[...]) sa regex m/%s/
(F) Hindi malaman ni Perl kung ano ang ibig mong sabihin sa loob ng construct na ito; inaabisuhan ka nito
na ito ay sumusuko sa pagsubok.

%s syntax OK
(F) Ang huling buod na mensahe kapag nagtagumpay ang isang "perl -c".

sysread() sa saradong filehandle %s
(W sarado) Sinubukan mong magbasa mula sa isang saradong filehandle.

sysread() sa hindi pa nabuksang filehandle %s
(W unopen) Sinubukan mong magbasa mula sa isang filehandle na hindi nabuksan.

Ang System V %s ay hindi ipinatupad sa makinang ito
(F) Sinubukan mong gumawa ng isang bagay na may function na nagsisimula sa "sem", "shm", o "msg"
ngunit ang System V IPC na iyon ay hindi ipinatupad sa iyong makina. Sa ilang mga makina ang
maaaring umiral ang functionality ngunit hindi naka-configure. Kumonsulta sa iyong suporta sa system.

syswrite() sa saradong filehandle %s
(W closed) Ang filehandle na isinusulat mo ay naisara nito minsan bago ngayon.
Suriin ang iyong daloy ng kontrol.

Hindi ipinatupad ang "-T" at "-B" sa mga filehandle
(F) Hindi masilip ni Perl ang stdio buffer ng filehandles kapag hindi nito alam ang tungkol sa iyong
uri ng stdio. Kakailanganin mong gumamit ng filename sa halip.

Masyadong malalim ang nested ng target ng goto
(F) Sinubukan mong gumamit ng "goto" para maabot ang isang label na masyadong malalim ang nested para kay Perl
maabot. Ginagawa ka ni Perl ng pabor sa pamamagitan ng pagtanggi.

telldir() sinubukan sa di-wastong dirhandle %s
(W io) Ang dirhandle na sinubukan mong gawin telldir() sarado man o hindi talaga a
dirhandle. Suriin ang iyong daloy ng kontrol.

sabihin () sa hindi pa nabuksang filehandle
(W unopen) Sinubukan mong gamitin ang sabihin () function sa isang filehandle na alinman
hindi pa nabubuksan o sarado na.

Ang paggamit na iyon ng $[ ay hindi suportado
(F) Ang pagtatalaga sa $[ ay mahigpit na ngayong nililimitahan, at binibigyang-kahulugan bilang isang compiler
direktiba. Maaari mong sabihin isa lamang sa

$[ = 0;
$[ = 1;
...
lokal na $[ = 0;
lokal na $[ = 1;
...

Ito ay upang maiwasan ang problema ng isang module na binabago ang array base mula sa ilalim
isa pang modyul nang hindi sinasadya. Tingnan ang "$[" sa perlvar at arybase.

Ang bitwise na feature ay experimental
(S experimental::bitwise) Ang babalang ito ay inilalabas kung gumagamit ka ng mga bitwise operator ("& | ^
~&. |. ^. ~.") na may naka-enable na feature na "bitwise." Pigilan lang ang babala kung
gusto mong gamitin ang feature, ngunit alam mong sa paggawa nito ay nasa panganib ka ng
gamit ang isang pang-eksperimentong tampok na maaaring magbago o maalis sa hinaharap na bersyon ng Perl:

walang babala "experimental::bitwise";
gamitin ang tampok na "bitwise";
$x |.= $y;

Ang crypt() hindi naipatupad ang function dahil sa sobrang paranoya.
(F) Hindi mahanap ng configure ang crypt() function sa iyong makina, marahil dahil
hindi ito binigay ng iyong vendor, marahil dahil sa tingin nila ay iniisip ng US Government
secret lang yun, or at least tuloy pa rin sila sa pagkukunwari. At kung ikaw
Sipiin mo ako diyan, tatanggihan ko ito.

Ang %s function ay hindi naipatupad
(F) Ang function na ipinahiwatig ay hindi ipinatupad sa arkitektura na ito, ayon sa
probings ng I-configure.

Pang-eksperimento ang feature na lexical_subs
(S experimental::lexical_subs) Ipapalabas ang babalang ito kung magdedeklara ka ng sub na may "my"
o "estado". Pigilan lang ang babala kung gusto mong gamitin ang feature, ngunit alam mo iyon
sa paggawa nito ay nanganganib kang gumamit ng isang pang-eksperimentong tampok na maaaring magbago
o maalis sa hinaharap na bersyon ng Perl:

walang babala "experimental::lexical_subs";
gamitin ang tampok na "lexical_subs";
ang aking sub foo { ... }

Ang tampok na regex_sets ay pang-eksperimento
(S experimental::regex_sets) Ang babalang ito ay inilalabas kung gagamitin mo ang syntax na "(?[ ])"
sa isang regular na expression. Maaaring magbago ang mga detalye ng feature na ito. kung ikaw
gustong gamitin ito, ngunit alamin na sa paggawa nito ay nanganganib kang gumamit ng isang
pang-eksperimentong tampok na maaaring magbago sa hinaharap na bersyon ng Perl, magagawa mo ito
patahimikin ang babala:

walang babala "experimental::regex_sets";

Pang-eksperimento ang tampok na mga lagda
(S experimental::signatures) Ang babalang ito ay ilalabas kung aalisin mo ang isang subroutine
mga argumento gamit ang isang lagda. Pigilan lang ang babala kung gusto mong gamitin ang
feature, ngunit alam mong sa paggawa nito ay nanganganib kang gumamit ng isang eksperimental
tampok na maaaring magbago o maalis sa hinaharap na bersyon ng Perl:

walang babala "experimental::signatures";
gamitin ang tampok na "pirma";
sub foo ($kaliwa, $kanan) { ... }

Ang stat na nauna sa %s ay hindi isang lstat
(F) Walang saysay na subukan ang kasalukuyang buffer ng stat para sa simbolikong linkhood kung ang
ang huling stat na sumulat sa stat buffer ay lumagpas na sa symlink upang makapunta sa
totoong file. Gumamit na lang ng aktwal na filename.

Ang katangiang 'natatangi' ay maaari lamang ilapat sa 'aming' mga variable
(F) Ang katangiang ito ay hindi kailanman suportado sa "my" o "sub" na mga deklarasyon.

Hindi ma-reset ng Perl na ito ang mga elemento ng kapaligiran ng CRTL (%s)
Ang Perl na ito ay hindi makapagtakda ng CRTL na mga elemento ng kapaligiran (%s=%s)
(W internal) Mga babala na kakaiba sa VMS. Sinubukan mong baguhin o tanggalin ang isang elemento ng
ang panloob na environ array ng CRTL, ngunit ang iyong kopya ng Perl ay hindi ginawa gamit ang isang CRTL na
naglalaman ng setenv() function. Kakailanganin mong buuin muli ang Perl gamit ang isang CRTL na nagagawa,
o muling tukuyin PERL_ENV_TABLES (tingnan ang perlvms) upang ang environ array ay hindi ang target
ng pagbabago sa %ENV na nagdulot ng babala.

Ang Perl na ito ay hindi binuo na may suporta para sa randomized na hash key traversal ngunit isang bagay
tinatawag Perl_hv_rand_set().
(F) May nagtangkang gumamit ng panloob na tawag sa API na nakadepende sa pagiging Perl
pinagsama-sama sa default na suporta para sa randomized na hash key traversal, ngunit mayroon itong Perl
na-compile nang wala ito. Dapat mong iulat ang babalang ito sa nauugnay na upstream
party, o muling i-compile ang perl na may mga default na opsyon.

mga panahong hindi ipinatupad
(F) Ang iyong bersyon ng C library ay tila hindi gumagana beses(). Hinala ko hindi ka
tumatakbo sa Unix.

Ang "-T" ay nasa #! linya, dapat din itong gamitin sa command line
(X) Ang #! line (o lokal na katumbas) sa isang Perl script ay naglalaman ng -T opsyon (o ang
-t opsyon), ngunit hindi na-invoke si Perl -T sa command line nito. Ito ay isang error
dahil, sa oras na matuklasan ni Perl ang isang -T sa isang script, huli na para maayos na mantsang
lahat mula sa kapaligiran. Kaya sumuko si Perl.

Kung ang Perl script ay isinasagawa bilang isang command gamit ang #! mekanismo (o nito
lokal na katumbas), kadalasang maaayos ang error na ito sa pamamagitan ng pag-edit ng #! linya upang ang
-%c Ang opsyon ay bahagi ng unang argumento ni Perl: hal. baguhin ang "perl -n -%c" sa "perl -%c
-n".

Kung ang Perl script ay isinasagawa bilang "perl scriptname", kung gayon ang -%c opsyon ay dapat
lalabas sa command line: "perl -%c scriptname".

Sa%s: iligal na pagmamapa '%s'
(F) Sinubukan mong tukuyin ang isang naka-customize na To-mapping para sa lc(), lcfirst, uc(), O ucfirst()
(o ang kanilang mga string-inlined na bersyon), ngunit tinukoy mo ang isang ilegal na pagmamapa. Tingnan ang "User-
Defined Character Properties" sa perlunicode.

Masyadong malalim ang nested ()-groups
(F) Ang iyong template ay naglalaman ng ()-mga pangkat na may katawa-tawa na malalim na antas ng nesting.

Napakakaunting args para sa syscall
(F) Kailangang mayroong kahit isang argumento syscall() para tukuyin ang system call sa
tawag, silly dilly.

Napakakaunting argumento para sa subroutine
(F) Ang isang subroutine na gumagamit ng isang lagda ay nakatanggap ng mas kaunting mga argumento kaysa sa kinakailangan ng
lagda. Ang tumatawag sa subroutine ay malamang na may kasalanan. Hindi maginhawa, ito
iuulat ang error sa lokasyon ng subroutine, hindi doon sa tumatawag.

Masyadong huli para sa "-%s" na opsyon
(X) Ang #! line (o lokal na katumbas) sa isang Perl script ay naglalaman ng -M, -m or -C
pagpipilian.

Sa kaso ng -M at -m, isa itong error dahil hindi nilayon ang mga opsyong iyon
gumamit ng mga script sa loob. Gamitin ang "gamitin" na pragma sa halip.

Ang -C Gumagana lamang ang opsyon kung ito ay tinukoy din sa command line (na may parehong
pagkakasunud-sunod ng mga titik o numero na sumusunod). Alinman ay tukuyin ang opsyong ito sa command
linya, o, kung sinusuportahan ito ng iyong system, gawing executable ang iyong script at direktang patakbuhin ito
sa halip na ipasa ito sa perl.

Huli na para patakbuhin ang %s block
(W void) Ang isang CHECK o INIT block ay tinutukoy sa panahon ng tamang oras ng pagtakbo, kapag ang
ang pagkakataong patakbuhin ang mga ito ay lumipas na. Marahil ikaw ay naglo-load ng isang file na may
"nangangailangan" o "gawin" kapag dapat mong gamitin ang "gamitin" sa halip. O marahil ay dapat mong ilagay
ang "require" o "do" sa loob ng BEGIN block.

Masyadong maraming argumento sa syscall
(F) Sinusuportahan ng Perl ang maximum na 14 na arg lang sa syscall().

Masyadong maraming argumento para sa %s
(F) Ang function ay nangangailangan ng mas kaunting mga argumento kaysa sa iyong tinukoy.

Masyadong maraming argumento para sa subroutine
(F) Ang isang subroutine na gumagamit ng isang lagda ay nakatanggap ng higit pang mga argumento kaysa sa kinakailangan ng
lagda. Ang tumatawag sa subroutine ay malamang na may kasalanan. Hindi maginhawa, ito
iuulat ang error sa lokasyon ng subroutine, hindi doon sa tumatawag.

Masyadong marami).
(A) Hindi mo sinasadyang napatakbo ang iyong script csh sa halip na Perl. Suriin ang #!
linya, o manu-manong i-feed ang iyong script sa Perl mismo.

Masyadong marami ('s
(A) Hindi mo sinasadyang napatakbo ang iyong script csh sa halip na Perl. Suriin ang #!
linya, o manu-manong i-feed ang iyong script sa Perl mismo.

Sinusundan \ sa regex m/%s/
(F) Ang regular na expression ay nagtatapos sa isang unbackslashed backslash. I-backslash ito. Tingnan mo
perlre.

Hindi winakasan ang pattern ng transliterasyon
(F) Hindi mahanap ng lexer ang panloob na delimiter ng isang tr/// o tr[][] o y/// o
y[][] bumuo. Ang pagkawala ng nangungunang "$" mula sa mga variable na $tr o $y ay maaaring magdulot nito
error.

Hindi winakasan ang pagpapalit ng transliterasyon
(F) Hindi mahanap ng lexer ang huling delimiter ng isang tr///, tr[][], y/// o y[][]
bumuo.

Na-trap ng operation mask ang '%s'
(F) Sinubukan mong gumamit ng operator mula sa isang Safe compartment kung saan ito ay hindi pinapayagan.
Tingnan ang Ligtas.

hindi ipinatupad ang truncate
(F) Ang iyong makina ay hindi nagpapatupad ng mekanismo ng pagputol ng file na alam ng Configure
tungkol sa.

Ang uri ng arg %d hanggang &CORE::%s ay dapat na %s
(F) Ang subroutine na pinag-uusapan sa CORE package ay nangangailangan ng argumento nito na maging mahirap
reference sa data ng tinukoy na uri. Ang overloading ay hindi pinapansin, kaya isang reference sa isang
bagay na hindi ang tinukoy na uri, ngunit gayunpaman ay may labis na karga upang mahawakan ito,
hindi pa rin matatanggap.

Ang uri ng arg %d hanggang %s ay dapat na %s (hindi %s)
(F) Ang function na ito ay nangangailangan ng argumento sa posisyong iyon upang maging isang tiyak na uri.
Ang mga array ay dapat na @NAME o "@{EXPR}". Ang mga hash ay dapat na %NAME o "%{EXPR}". Walang implicit
pinapayagan ang dereferencing--gamitin ang mga form na {EXPR} bilang tahasang dereference. Tingnan mo
perlref.

Ang uri ng argumento sa %s ay dapat na hindi pinagpalang hashref o arrayref
(F) Tinawag mo ang "mga susi", "mga halaga" o "bawat isa" na may scalar na argumento na hindi isang
reference sa isang unblessed hash o array.

hindi ipinatupad ang umask
(F) Ang iyong makina ay hindi nagpapatupad ng umask function at sinubukan mong gamitin ito
paghigpitan ang mga pahintulot para sa iyong sarili (EXPR & 0700).

Hindi balanseng konteksto: %d higit pang mga PUSH kaysa sa mga POP
(S internal) Nakakita ang exit code ng internal inconsistency sa kung gaano karaming execution
ipinasok at iniwan ang mga konteksto.

Hindi balanseng pag-save: %d higit pang pag-save kaysa pag-restore
(S internal) Nakatukoy ang exit code ng panloob na hindi pagkakapare-pareho sa kung gaano karaming mga value
pansamantalang naisalokal.

Mga hindi balanseng saklaw: %d higit pang ENTER kaysa sa LEAVE
(S internal) Ang exit code ay nakakita ng panloob na hindi pagkakapare-pareho sa kung gaano karaming mga bloke
pumasok at umalis.

Hindi balanseng string table refcount: (%d) para sa "%s"
(S internal) Sa paglabas, nakita ni Perl ang ilang mga string na natitira sa shared string table
ginagamit para sa pagkopya sa pagsulat at para sa mga hash key. Ang mga entry ay dapat na pinalaya, kaya ito
ay nagpapahiwatig ng isang bug sa isang lugar.

Mga hindi balanseng tmp: %d mas maraming inilalaan kaysa sa libre
(S internal) Nakakita ang exit code ng internal inconsistency sa kung ilang mortal
ang mga scalar ay inilaan at pinalaya.

Ang hindi natukoy na format ay tinatawag na "%s".
(F) Mukhang wala ang format na ipinahiwatig. Baka sa iba talaga
pakete? Tingnan ang perlform.

Ang hindi natukoy na pag-uuri ng subroutine na "%s" ay tinatawag
(F) Ang tinukoy na gawain sa paghahambing ng pag-uuri ay tila hindi umiiral. Marahil ito ay nasa a
ibang package? Tingnan ang "sort" sa perlfunc.

Hindi natukoy na subroutine &%s na tinatawag
(F) Ang subroutine na ipinahiwatig ay hindi natukoy, o kung ito ay, ito ay mula noon
hindi natukoy.

Tinatawag na hindi natukoy na subroutine
(F) Ang hindi kilalang subroutine na sinusubukan mong tawagan ay hindi natukoy, o kung ito ay,
ito ay mula noon ay hindi natukoy.

Hindi natukoy na subroutine sa pag-uuri
(F) Ang tinukoy na gawain sa paghahambing ng pag-uuri ay ipinahayag ngunit mukhang hindi pa
tinukoy pa. Tingnan ang "sort" sa perlfunc.

Tinatawag na "%s" ang hindi natukoy na nangungunang format
(F) Mukhang wala ang format na ipinahiwatig. Baka sa iba talaga
pakete? Tingnan ang perlform.

Hindi natukoy na halaga na itinalaga sa typeglob
(W misc) Isang hindi natukoy na halaga ang itinalaga sa isang typeglob, a la "*foo = undef". Ito
walang ginagawa. Posible na talagang "undef *foo" ang ibig mong sabihin.

%s: Hindi natukoy na variable
(A) Hindi mo sinasadyang napatakbo ang iyong script csh sa halip na Perl. Suriin ang #!
linya, o manu-manong i-feed ang iyong script sa Perl mismo.

Ang hindi na-escape na left brace sa regex ay hindi na ginagamit, ipinasa sa regex; minarkahan ng <-- DITO
sa m/%s/
(D deprecated, regexp) Gumamit ka ng literal na "{" na character sa isang regular na expression
pattern. Dapat mong baguhin upang gamitin ang "\{" sa halip, dahil ang hinaharap na bersyon ng Perl
(pansamantalang v5.26) ay ituturing itong isang syntax error. Kung ang pattern
Ang mga delimiter ay mga brace din, ang anumang tumutugmang kanang brace ("}") ay dapat ding i-escape
iwasang malito ang parser, halimbawa,

qr{abc\{def\}ghi}

nabigo ang unexec ng %s sa %s!
(F) Ang unexec() nabigo ang routine sa ilang kadahilanan. Tingnan ang iyong lokal na kinatawan ng FSF,
sino siguro ang naglagay doon sa unang lugar.

Hindi inaasahang binary operator '%c' na walang naunang operand sa regex; minarkahan ng <-- DITO sa
MS/
(F) Nagkaroon ka ng ganito:

(?[ | \p{Digit} ])

kung saan ang "|" ay isang binary operator na may operand sa kanan, ngunit walang operand sa
naiwan.

Hindi inaasahang karakter sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Nagkaroon ka ng ganito:

(?[ z ])

Sa loob ng "(?[ ])", walang literal na character ang pinapayagan maliban kung nasa loob ang mga ito
pares ng mga square bracket, tulad ng

(?[ [ z ] ])

Ang isa pang posibilidad ay nakalimutan mo ang isang backslash. Si Perl ay hindi sapat na matalino upang malaman
out kung ano talaga ang ibig mong sabihin.

Hindi inaasahang palaging lvalue entersub entry sa pamamagitan ng uri/targ %d:%d
(P) Kapag nag-compile ng subroutine na tawag sa konteksto ng halaga, nabigo si Perl sa isang internal
pagsusuri ng pagkakapare-pareho. Nakatagpo ito ng malformed op tree.

Hindi inaasahang paglabas %u
(S) exit () ay tinawag o ang script ay natapos nang maganda kapag
Ang "PERL_EXIT_WARN" ay itinakda sa "PL_exit_flags".

Hindi inaasahang exit failure %d
(S) Isang hindi nahuli mamatay () ay tinawag noong ang "PERL_EXIT_WARN" ay itinakda sa "PL_exit_flags".

Hindi inaasahang ')' sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Nagkaroon ka ng ganito:

(?[ ( \p{Digit} + ) ])

Ang ")" ay wala sa lugar. Isang bagay na tila ay dapat na pinagsama sa
digit, o ang "+" ay hindi dapat naroroon, o isang bagay na katulad niyan. Hindi mawari ni Perl
kung ano ang sinadya.

Hindi inaasahang '(' na walang naunang operator sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Nagkaroon ka ng ganito:

(?[ \p{Digit} ( \p{Lao} + \p{Thai} ) ])

Dapat mayroong isang operator bago ang "(", dahil walang indikasyon kung paano ang
ang mga digit ay dapat pagsamahin sa mga character sa Lao at Thai script.

Ang Unicode non-character na U+%X ay ilegal para sa open interchange
(S nonchar) Ang ilang partikular na codepoint, gaya ng U+FFFE at U+FFFF, ay tinukoy ng Unicode
pamantayan upang maging mga hindi karakter. Iyon ay mga legal na codepoint, ngunit nakalaan para sa
Panloob na gamit; kaya, hindi dapat subukan ng mga application na palitan ang mga ito. Ang isang aplikasyon ay maaaring
hindi inaasahan ang alinman sa mga character na ito, at ang pagtanggap sa mga ito ay maaaring humantong sa mga bug.
Kung alam mo kung ano ang iyong ginagawa maaari mong i-off ang babalang ito sa pamamagitan ng "walang mga babala
'nonchar';".

Ito ay hindi talaga isang "malubhang" error, ngunit ito ay dapat na itataas bilang default kahit na
kung ang mga babala ay hindi pinagana, at sa kasalukuyan ang tanging paraan upang gawin iyon sa Perl ay markahan
parang seryoso.

Ang Unicode surrogate U+%X ay ilegal sa UTF-8
(S surrogate) Nagkaroon ka ng UTF-16 na kahalili sa isang konteksto kung saan hindi sila isinasaalang-alang
katanggap-tanggap. Ang mga code point na ito, sa pagitan ng U+D800 at U+DFFF (inclusive), ay ginagamit ng
Unicode para lang sa UTF-16. Gayunpaman, panloob na pinapayagan ng Perl ang lahat ng unsigned integer code
mga puntos (hanggang sa limitasyon sa laki na magagamit sa iyong platform), kabilang ang mga kahalili. Pero
ang mga ito ay maaaring magdulot ng mga problema kapag input o output, na malamang kung saan ito
nagmula ang mensahe. Kung talagang alam mo talaga ang iyong ginagawa maaari mong i-off ito
babala sa pamamagitan ng "walang babala 'kapalit';".

Hindi kilalang charname '%s'
(F) Ang pangalang ginamit mo sa loob ng "\N{}" ay hindi alam ni Perl. Suriin ang spelling. Kaya mo
sabihin ang "gumamit ng mga charnames ":loose"" para hindi masyadong tumpak ang tungkol sa mga puwang, gitling, at
capitalization sa mga karaniwang pangalan ng Unicode. (Anumang mga custom na alias na ginawa
dapat na eksaktong tukuyin, hindi alintana kung ang ":loose" ay ginamit o hindi.) Ang error na ito
maaari ding mangyari kung ang "\N{}" ay wala sa saklaw ng katumbas
"gumamit ng mga charname".

Hindi kilalang error
(P) Si Perl ay malapit nang mag-print ng mensahe ng error sa $@, ngunit ang $@ variable ay hindi umiiral,
kahit na matapos ang pagtatangkang likhain ito.

Hindi kilala bukas() mode '%s'
(F) Ang pangalawang argumento ng 3-argumento bukas() ay wala sa listahan ng mga wastong mode:
"<", ">", ">>", "+<", "+>", "+>>", "-|", "|-", "<&", ">&".

Hindi kilalang PerlIO layer na "%s"
(W layer) Isang pagtatangka ay ginawa upang itulak ang isang hindi kilalang layer papunta sa Perl I/O system.
(Ang mga layer ay nangangalaga sa pagbabago ng data sa pagitan ng panlabas at panloob na mga representasyon.)
Tandaan na ang ilang mga layer, gaya ng "mmap", ay hindi sinusuportahan sa lahat ng kapaligiran. Kung ang iyong
Ang programa ay hindi tahasang humiling ng bagsak na operasyon, maaaring ito ay resulta ng
halaga ng environment variable na PERLIO.

Hindi kilalang proseso %x nagpadala ng mensahe sa prime_env_iter: %s
(P) Isang error na kakaiba sa VMS. Binabasa ni Perl ang mga halaga para sa %ENV bago ang pag-ulit
ito, at may ibang naglagay ng mensahe sa stream ng data na inaasahan ni Perl. ng isang tao
napakalito, o marahil ay sinusubukang ibagsak ang populasyon ng Perl na %ENV para sa kasuklam-suklam
mga layunin.

Hindi kilalang regex modifier na "%s"
(F) Mga alphanumeric kaagad kasunod ng pagsasara ng delimiter ng isang regular na expression
Ang pattern ay binibigyang-kahulugan ni Perl bilang mga flag ng modifier para sa regex. Isa sa mga ikaw
ang tinukoy ay hindi wasto. Ang isang paraan na maaaring mangyari ito ay kung hindi ka naglagay ng puting espasyo
sa pagitan ng dulo ng regex at isang sumusunod na alphanumeric operator:

kung ($a =~ /foo/at $bar == 3) { ... }

Ang "a" ay isang wastong flag ng modifier, ngunit ang "n" ay hindi, at pinapataas ang error na ito. Malamang
ang ibig sabihin sa halip ay:

kung ($a =~ /foo/ at $bar == 3) { ... }

Hindi kilalang "re" subpragma '%s' (mga kilala ay: %s)
(W) Sinubukan mong gumamit ng hindi kilalang subpragma ng "re" pragma.

Hindi alam na kundisyon ng switch (?(...)) sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang bahagi ng kondisyon ng isang (?(condition)if-clause|else-clause) construct ay hindi
kilala. Ang kundisyon ay dapat isa sa mga sumusunod:

(1) (2) ... true kung 1st, 2nd, etc., ang capture ay tumugma
( ) ('NAME') true kung tumugma ang pangalang capture
(?=...) (?<=...) true kung tumugma ang subpattern
(?!...) (?
(?{ CODE }) true kung ang code ay nagbabalik ng totoong halaga
(R) true kung sinusuri ang inside recursion
(R1) (R2) ... totoo kung direkta sa loob ng pangkat ng pagkuha 1, 2, atbp.
(R&NAME) true kung direkta sa loob na pinangalanang capture
(DEFINE) palaging mali; para sa pagtukoy ng mga pinangalanang subpattern

Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan.
Tingnan ang perlre.

Hindi kilalang Unicode option letter '%c'
(F) Tinukoy mo ang hindi kilalang opsyon sa Unicode. Tingnan ang perlrun na dokumentasyon ng "-C"
lumipat para sa listahan ng mga kilalang opsyon.

Hindi kilalang halaga ng opsyon sa Unicode %d
(F) Tinukoy mo ang hindi kilalang opsyon sa Unicode. Tingnan ang perlrun na dokumentasyon ng "-C"
lumipat para sa listahan ng mga kilalang opsyon.

Hindi kilalang pattern ng pandiwa '%s' sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Maaaring nagkamali ka o naglagay ng "*" na quantifier pagkatapos ng pagbukas
brace sa iyong pattern. Suriin ang pattern at suriin ang perlre para sa mga detalye sa legal na pandiwa
mga pattern.

Hindi kilalang kategorya ng mga babala '%s'
(F) Isang error na ibinigay ng "mga babala" na pragma. Tinukoy mo ang kategorya ng mga babala na
ay hindi kilala sa perl sa puntong ito.

Tandaan na kung gusto mong paganahin ang kategorya ng mga babala na nakarehistro ng isang module (hal. "use
mga babala na 'File::Find'"), dapat ay na-load mo muna ang modyul na ito.

Walang kaparis na '[' sa klase ng POSIX sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Nagkaroon ka ng ganito:

(?[ [:digit: ])

Iyon ay dapat isulat:

(?[ [:digit:] ])

Walang kaparis na '%c' sa klase ng POSIX sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Nagkaroon ka ng ganito:

(?[ [:alnum] ])

Dapat mayroong pangalawang ":", tulad nito:

(?[ [:alnum:] ])

Walang kaparis [ sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Dapat magkatugma ang mga bracket sa paligid ng klase ng character. Kung nais mong isama ang a
closing bracket sa isang klase ng character, i-backslash ito o unahin. Ang <-- DITO
nagpapakita ng kinaroroonan sa regular na ekspresyon ang problema ay natuklasan. Tingnan ang perlre.

Walang kaparis ( sa regex; minarkahan ng <-- DITO sa m/%s/
Walang kaparis ) sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang mga unbackslash na panaklong ay dapat palaging balanse sa mga regular na expression. Kung
isa kang vi user, ang % key ay mahalaga para sa paghahanap ng katugmang panaklong. Ang
<-- DITO ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan. Tingnan mo
perlre.

Walang katugmang kanang %s bracket
(F) Binibilang ng lexer ang mas maraming closing curly o square bracket kaysa sa mga opening, kaya
malamang na nawawala ka ng katugmang opening bracket. Bilang pangkalahatang tuntunin, mahahanap mo
yung kulang (kumbaga) malapit sa lugar na huli mong inedit.

Ang hindi naka-quote na string na "%s" ay maaaring magkasalungat sa nakalaan na salita sa hinaharap
(W reserved) Gumamit ka ng bareword na maaaring i-claim sa ibang araw bilang reserved na salita.
Pinakamainam na ilagay ang ganoong salita sa mga panipi, o i-capitalize ito kahit papaano, o ipasok ang isang
underbar sa loob nito. Maaari mo ring ideklara ito bilang isang subroutine.

Hindi nakikilalang karakter %s; minarkahan ng <-- HERE pagkatapos ng %s malapit sa column %d
(F) Ang Perl parser ay walang ideya kung ano ang gagawin sa tinukoy na character sa iyong Perl
script (o eval) malapit sa tinukoy na column. Marahil ay sinubukan mong magpatakbo ng isang naka-compress
script, isang binary program, o isang direktoryo bilang isang Perl program.

Hindi nakikilalang pagtakas \%c sa klase ng character sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng kumbinasyon ng backslash-character na hindi kinikilala ng Perl sa loob
mga klase ng karakter. Ito ay isang nakamamatay na error kapag ang klase ng character ay ginamit sa loob ng "(?[
])".

Hindi nakikilalang pagtakas \%c sa klase ng character na ipinasa sa regex; minarkahan ng <-- DITO sa
MS/
(W regexp) Gumamit ka ng kumbinasyon ng backslash-character na hindi kinikilala ng Perl
sa loob ng mga klase ng karakter. Literal na naunawaan ang karakter, ngunit maaaring magbago ito
sa hinaharap na bersyon ng Perl. Ang <-- HERE ay nagpapakita ng kinaroroonan sa regular na expression
ang pagtakas ay natuklasan.

Hindi nakilalang pagtakas \%c ang dumaan
(W misc) Gumamit ka ng kumbinasyon ng backslash-character na hindi kinikilala ng Perl.
Literal na naunawaan ang karakter, ngunit maaaring magbago ito sa hinaharap na bersyon ng
Perl.

Ang hindi nakikilalang pagtakas \%s ay dumaan sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) Gumamit ka ng kumbinasyon ng backslash-character na hindi kinikilala ng Perl.
Literal na naunawaan ang (mga) karakter, ngunit maaaring magbago ito sa hinaharap na bersyon ng
Perl. Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang pagtakas
natuklasan

Hindi nakikilalang pangalan ng signal na "%s"
(F) Tinukoy mo ang isang pangalan ng signal sa pumatay() function na hindi nakilala. Sabihin
"kill -l" sa iyong shell upang makita ang mga wastong pangalan ng signal sa iyong system.

Hindi nakikilalang switch: -%s (-ipapakita ang mga wastong opsyon)
(F) Tinukoy mo ang isang ilegal na opsyon sa Perl. Wag mong gawin yan. (Kung sa tingin mo ay hindi mo ginawa
gawin iyan, suriin ang #! linya upang makita kung ito ay nagbibigay ng masamang switch sa ngalan mo.)

Ang unshift sa sanggunian ay eksperimental
(S experimental::autoderef) Ang "unshift" na may scalar argument ay eksperimental at maaaring
baguhin o alisin sa hinaharap na bersyon ng Perl. Kung nais mong kunin ang panganib sa paggamit
ang tampok na ito, huwag paganahin ang babalang ito:

walang babala "experimental::autoderef";

Hindi matagumpay na %s sa filename na naglalaman ng newline
(W newline) Sinubukan ang operasyon ng file sa isang filename, at nabigo ang operasyong iyon,
MALAMANG dahil may newline ang filename, MALAMANG dahil nakalimutan mo
chomp() off ito. Tingnan ang "chomp" sa perlfunc.

Ang hindi sinusuportahang function ng direktoryo na "%s" ay tinawag
(F) Hindi sinusuportahan ng iyong makina opendir() at readdir().

Hindi sinusuportahang function %s
(F) Ang makinang ito ay hindi nagpapatupad ng ipinahiwatig na function, tila. Kahit na,
Ang pag-configure ay hindi iniisip.

Hindi sinusuportahang function fork
(F) Ang iyong bersyon ng executable ay hindi sumusuporta sa forking.

Tandaan na sa ilalim ng ilang system, tulad ng OS/2, maaaring may iba't ibang lasa ng Perl
mga executable, ang ilan sa mga ito ay maaaring sumusuporta sa tinidor, ang ilan ay hindi. Subukang palitan ang pangalang tinatawag mo
Perl by to "perl_", "perl__", at iba pa.

Hindi suportadong script encoding %s
(F) Ang iyong program file ay nagsisimula sa isang Unicode Byte Order Mark (BOM) na nagdedeklara nito sa
nasa isang Unicode encoding na hindi mabasa ni Perl.

Ang hindi suportadong socket function na "%s" ay tinawag
(F) Hindi sinusuportahan ng iyong makina ang mekanismo ng Berkeley socket, o hindi bababa sa iyon
kung ano ang naisip ni Configure.

Listahan ng mga katangian na hindi natapos
(F) Nakahanap si lexer ng isang bagay maliban sa isang simpleng identifier sa simula ng isang
attribute, at hindi ito semicolon o simula ng isang block. Baka nag-terminate ka
masyadong maaga ang listahan ng parameter ng nakaraang attribute. Tingnan ang mga katangian.

Hindi natapos na parameter ng katangian sa listahan ng katangian
(F) Nakita ng lexer ang isang pambungad (kaliwa) na karakter ng panaklong habang nag-parse ng isang katangian
list, ngunit hindi nakita ang katugmang closing (kanan) parenthesis character. Maaari mong
kailangang magdagdag (o mag-alis) ng backslash na character para balansehin ang iyong mga panaklong. Tingnan mo
mga katangian

Walang katapusang compressed integer
(F) Ang isang argumento upang i-unpack("w",...) ay hindi tugma sa BER compressed integer
format at hindi ma-convert sa isang integer. Tingnan ang "pack" sa perlfunc.

Walang katapusang delimiter para dito na dokumento
(F) Ang mensaheng ito ay nangyayari kapag ang isang here document label ay may panimulang panipi ngunit
nawawala ang panghuling panipi. Marahil ay isinulat mo:

<<"foo

sa halip na:

<<"foo"

Unterminated \g... pattern sa regex; minarkahan ng <-- DITO sa m/%s/
Unterminated \g{...} pattern sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Sa isang regular na expression, mayroon kang "\g" na hindi sinundan ng tamang pangkat
sanggunian. Sa kaso ng "\g{", nawawala ang closing brace; kung hindi ang "\g"
dapat sundan ng integer. Ayusin ang pattern at subukang muli.

Walang tigil na <> operator
(F) Ang lexer ay nakakita ng isang kaliwang angle bracket sa isang lugar kung saan ito ay umaasa ng isang termino, kaya
hinahanap nito ang katumbas na right angle bracket, at hindi ito nahanap. Mga pagkakataon
nag-iwan ka ba ng ilang kinakailangang panaklong kanina sa linya, at talagang sinadya mo a
"mas mababa sa".

Hindi natatapos na argumento ng pattern ng pandiwa sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng pattern ng anyong "(*VERB:ARG)" ngunit hindi tinapos ang pattern
na may ")". Ayusin ang pattern at subukang muli.

Unterminated verb pattern sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng pattern ng anyong "(*PANDIWA)" ngunit hindi tinapos ang pattern na may a
")". Ayusin ang pattern at subukang muli.

sinubukang kalasin habang umiiral pa ang %d na panloob na sanggunian
(W untie) Ang isang kopya ng bagay na ibinalik mula sa "tali" (o "nakatali") ay wasto pa rin noong
"untie" ang tawag.

Paggamit: POSIX::%s(%s)
(F) Tumawag ka ng POSIX function na may mga maling argumento. Tingnan ang "FUNCTIONS" sa POSIX
para sa karagdagang impormasyon.

Paggamit: Win32::%s(%s)
(F) Tumawag ka ng isang function na Win32 na may mga maling argumento. Tingnan ang Win32 para sa higit pa
impormasyon.

$[ ginamit sa %s (ibig mo bang sabihin ay $] ?)
(W syntax) Gumamit ka ng $[ sa isang paghahambing, gaya ng:

kung ($[ > 5.006) {
...
}

Marahil ay sinadya mong gamitin ang $] sa halip. $[ ay ang batayan para sa pag-index ng mga array. $] ay ang
Numero ng bersyon ng Perl sa decimal.

Gamitin ang "%s" sa halip na "%s"
(F) Ang pangalawang nakalistang konstruksyon ay hindi na legal. Gamitin ang una sa halip.

Walang kwentang pagtatalaga sa isang pansamantalang
(W misc) Nagtalaga ka sa isang subroutine ng lvalue, ngunit ang ibinalik ng subroutine ay a
pansamantalang scalar na malapit nang itapon, kaya walang epekto ang pagtatalaga.

Walang silbi (?-%s) - huwag gumamit ng /%s modifier sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) Gumamit ka ng panloob na modifier tulad ng (?-o) na walang kahulugan maliban kung
inalis mula sa buong regexp:

kung ($string =~ /(?-o)$pattern/o) { ... }

dapat isulat bilang

kung ($string =~ /$pattern/) { ... }

Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan.
Tingnan ang perlre.

Walang kwentang lokalisasyon ng %s
(W syntax) Ang lokalisasyon ng mga halaga tulad ng "local($x=10)" ay legal, ngunit sa katunayan
ang lokal() kasalukuyang walang epekto. Ito ay maaaring magbago sa isang punto sa hinaharap, ngunit
samantala ang naturang code ay nasiraan ng loob.

Walang silbi (?%s) - gumamit ng /%s modifier sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) Gumamit ka ng panloob na modifier tulad ng (?o) na walang kahulugan maliban kung
inilapat sa buong regexp:

kung ($string =~ /(?o)$pattern/) { ... }

dapat isulat bilang

kung ($string =~ /$pattern/o) { ... }

Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang problema ay natuklasan.
Tingnan ang perlre.

Walang kwentang paggamit ng attribute na "const"
(W misc) Walang epekto ang attribute na "const" maliban sa mga anonymous na prototype ng pagsasara.
Inilapat mo ito sa isang subroutine sa pamamagitan ng attributes.pm. Ito ay kapaki-pakinabang lamang sa loob ng isang
tagapangasiwa ng katangian para sa isang hindi kilalang subroutine.

Walang silbi ang paggamit ng /d modifier sa transliteration operator
(W misc) Ginamit mo ang /d modifier kung saan ang searchlist ay may kaparehong haba ng
replacelist. Tingnan ang perlop para sa higit pang impormasyon tungkol sa /d modifier.

Walang kwentang paggamit ng \E
(W misc) Mayroon kang \E sa isang double-quotish string na walang "\U", "\L" o "\Q"
nauna dito.

Walang silbi ang paggamit ng grediness modifier '%c' sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) Tinukoy mo ang isang bagay na tulad nito:

qr/a{3}?/
qr/b{1,1}+/

Ang "?" at ang "+" ay walang epekto, dahil binabago ng mga ito kung tutugma ng higit pa o mas kaunti
kapag mayroong isang pagpipilian, at sa pamamagitan ng pagtukoy upang tumugma nang eksakto sa isang ibinigay na numero, walang
silid na natitira para sa isang pagpipilian.

Walang silbi ang paggamit ng %s sa walang bisa na konteksto
(W void) Gumawa ka ng isang bagay na walang side effect sa isang kontekstong walang ginagawa
ang return value, tulad ng isang statement na hindi nagbabalik ng value mula sa isang block, o ang
kaliwang bahagi ng isang scalar comma operator. Kadalasan ito ay tumutukoy sa hindi katangahan sa iyong
bahagi, ngunit isang kabiguan ng Perl na i-parse ang iyong programa sa paraang inaakala mong gagawin nito. Para sa
halimbawa, makukuha mo ito kung pinaghalo mo ang iyong C precedence sa Python precedence at
sinabi

$isa, $dalawa = 1, 2;

kung kailan mo gustong sabihin

($isa, $dalawa) = (1, 2);

Ang isa pang karaniwang error ay ang paggamit ng mga ordinaryong panaklong upang makabuo ng isang sanggunian sa listahan kung kailan
dapat ay gumagamit ka ng square o curly bracket, halimbawa, kung sasabihin mo

$array = (1,2);

kung kailan mo dapat sinabi

$array = [1,2];

Ang mga square bracket ay tahasang ginagawang scalar value ang isang list value, habang
ang mga panaklong ay hindi. Kaya kapag ang isang nakakulong na listahan ay nasuri sa isang scalar na konteksto,
ang kuwit ay tinatrato tulad ng C's comma operator, na nagtatapon sa kaliwang argumento,
na hindi ang gusto mo. Tingnan ang perlref para sa higit pa tungkol dito.

Ang babalang ito ay hindi ibibigay para sa mga numerical constant na katumbas ng 0 o 1 dahil ang mga ito ay
kadalasang ginagamit sa mga pahayag tulad ng

1 habang sub_with_side_effects();

Binabalaan ang mga string constants na karaniwang magiging 0 o 1.

Walang kwentang paggamit ng (?-p) sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) Ang "p" modifier ay hindi maaaring i-off kapag naitakda na. Ang pagsisikap na gawin ito ay walang saysay.

Walang kwentang paggamit ng "re" pragma
(W) "Gumamit ka ng re;" nang walang anumang argumento. Iyan ay hindi masyadong kapaki-pakinabang.

Walang silbi ang paggamit ng uri sa kontekstong scalar
(W void) Gumamit ka ng pag-uuri sa kontekstong scalar, tulad ng sa :

my $x = sort @y;

Hindi ito masyadong kapaki-pakinabang, at kasalukuyang ino-optimize ito ng perl.

Walang silbi ang paggamit ng %s na walang halaga
(W syntax) Ginamit mo ang itulak () or unshift() function na walang mga argumento bukod sa
array, tulad ng "push(@x)" o "unshift(@foo)". Karaniwang hindi iyon magkakaroon ng anumang epekto sa
array, kaya ay ganap na walang silbi. Posible sa prinsipyo na push(@tied_array)
maaaring magkaroon ng ilang epekto kung ang array ay nakatali sa isang klase na nagpapatupad ng isang paraan ng PUSH.
Kung gayon, maaari mo itong isulat bilang "push(@tied_array,())" upang maiwasan ang babalang ito.

"gamitin" hindi pinapayagan sa pagpapahayag
(F) Ang keyword na "gamitin" ay kinikilala at isinasagawa sa oras ng pag-compile, at nagbabalik ng hindi
kapaki-pakinabang na halaga. Tingnan ang perlmod.

Ang paggamit ng pagtatalaga sa $[ ay hindi na ginagamit
(D hindi na ginagamit) Ang $[ variable (index ng unang elemento sa isang array) ay hindi na ginagamit.
Tingnan ang "$[" sa perlvar.

Ang paggamit ng bare << para ibig sabihin ay <<"" ay hindi na ginagamit
(D hindi na ginagamit) Hinihikayat ka na ngayong gamitin ang tahasang sinipi na form kung gusto mo
gumamit ng walang laman na linya bilang terminator ng here-document.

Ang paggamit ng \b{} para sa lokal na hindi UTF-8 ay mali. Ipagpalagay na isang lokal na UTF-8
(W locale) Tinutugma mo ang isang regular na expression gamit ang mga panuntunan sa lokal, at isang Unicode
ang hangganan ay itinutugma, ngunit ang lokal ay hindi isang Unicode. Hindi ito gumagawa
kahulugan. Magpapatuloy ang Perl, sa pag-aakalang isang lokal na Unicode (UTF-8), ngunit maaari ang mga resulta
well maging mali maliban kung ang lokal ay nangyayari na ISO-8859-1 (Latin1) kung saan ito
ang mensahe ay huwad at maaaring balewalain.

Paggamit ng chdir('') o chdir(undef) bilang chdir() hindi na ginagamit
(D hindi na ginagamit) chdir() na walang mga argumento ay nakadokumento upang baguhin sa $ENV{HOME} o
$ENV{LOGDIR}. Ang chdir(undef) at chdir('') ay nagbabahagi ng pag-uugaling ito, ngunit nangyari na
hindi na ginagamit. Sa mga susunod na bersyon ay mabibigo lang sila.

Mag-ingat upang suriin kung ano ang iyong ipapasa chdir() ay tinukoy at hindi blangko, kung hindi, ikaw
maaaring makita ang iyong sarili sa iyong home directory.

Ang paggamit ng /c modifier ay walang kahulugan sa s///
(W regexp) Ginamit mo ang /c modifier sa isang pagpapalit. Ang /c modifier ay hindi
kasalukuyang makabuluhan sa mga pamalit.

Ang paggamit ng /c modifier ay walang kahulugan kung wala ang /g
(W regexp) Ginamit mo ang /c modifier na may regex operand, ngunit hindi ginamit ang /g
modifier. Sa kasalukuyan, makabuluhan lamang ang /c kapag ginamit ang /g. (Maaaring magbago ito sa
hinaharap.)

Ang paggamit ng listahan ng variable na walang kuwit ay hindi na ginagamit
(D hindi na ginagamit) Ang mga halagang ibibigay mo sa isang format ay dapat na pinaghihiwalay ng mga kuwit, hindi lamang
nakahanay sa isang linya.

Paggamit ng bawat() sa hash pagkatapos ng pagpasok nang hindi nire-reset ang hash iterator ay nagreresulta sa hindi natukoy
pag-uugali
(S panloob) Ang pag-uugali ng "bawat ()" pagkatapos ng pagpasok ay hindi natukoy; maaari itong laktawan ang mga item,
o bisitahin ang mga item nang higit sa isang beses. Isaalang-alang ang paggamit ng "keys()" sa halip na "each()".

Ang paggamit ng := para sa isang walang laman na listahan ng katangian ay hindi pinapayagan
(F) Ang konstruksiyon na "my $x := 42" ay ginamit upang i-parse bilang katumbas ng "my $x : = 42"
(paglalapat ng walang laman na listahan ng katangian sa $x). Hindi na ginagamit ang construct na ito noong 5.12.0,
at ngayon ay ginawang isang syntax error, kaya ang ":=" ay maaaring i-reclaim bilang isang bagong operator sa
ang kinabukasan.

Kung kailangan mo ng walang laman na listahan ng attribute, halimbawa sa isang code generator, magdagdag ng espasyo
bago ang "=".

Paggamit ng libreng halaga sa pag-ulit
(F) Marahil ay binago mo ang iterated array sa loob ng loop? Ang error na ito ay karaniwang
sanhi ng code tulad ng sumusunod:

@a = (3,4);
@a = () para sa (1,2,@a);

Hindi mo dapat baguhin ang mga array habang inuulit ang mga ito. Para sa bilis
at mga dahilan ng kahusayan, ang Perl sa loob ay hindi gumagawa ng buong reference-counting ng
mga naulit na item, kaya ang pagtanggal ng naturang item sa gitna ng isang pag-ulit ay nagiging sanhi ng Perl
upang makita ang isang napalayang halaga.

Ang paggamit ng *glob{FILEHANDLE} ay hindi na ginagamit
(D hindi na ginagamit) Hinihikayat ka na ngayong gamitin ang mas maikling *glob{IO} na form upang ma-access ang
filehandle slot sa loob ng isang typeglob.

Ang paggamit ng /g modifier ay walang kahulugan sa split
(W regexp) Ginamit mo ang /g modifier sa pattern para sa isang "split" na operator. Since
Ang "split" ay palaging sinusubukang tumugma sa pattern nang paulit-ulit, ang "/g" ay walang epekto.

Ang paggamit ng "goto" para tumalon sa isang construct ay hindi na ginagamit
(D hindi na ginagamit) Ang paggamit ng "goto" upang tumalon mula sa isang panlabas na saklaw patungo sa isang panloob na saklaw ay
hindi na ginagamit at dapat iwasan.

Ang paggamit ng minanang AUTOLOAD para sa hindi pamamaraang %s() ay hindi na ginagamit
(D hindi na ginagamit) Bilang isang (ahem) hindi sinasadyang feature, hinahanap ang mga subroutine na "AUTOLOAD"
bilang mga pamamaraan (gamit ang @ISA hierarchy) kahit na ang mga subroutine na i-autoload ay
tinatawag bilang plain function (hal. "Foo::bar()"), hindi bilang mga method (eg "Foo->bar()" o
"$obj->bar()").

Ang bug na ito ay aayusin sa hinaharap sa pamamagitan ng paggamit ng paraan ng paghahanap para lamang sa mga pamamaraan'
"AUTOLOAD". Gayunpaman, mayroong isang makabuluhang base ng umiiral na code na maaaring ginagamit
ang lumang pag-uugali. Kaya, bilang pansamantalang hakbang, kasalukuyang naglalabas ng opsyonal na babala si Perl
kapag ang mga hindi pamamaraan ay gumagamit ng mga minanang "AUTOLOAD".

Ang simpleng panuntunan ay: Hindi gagana ang mana kapag nag-autoload ng mga hindi pamamaraan. Ang
Ang simpleng pag-aayos para sa lumang code ay: Sa anumang module na dating nakadepende sa pagmamana
"AUTOLOAD" para sa mga hindi pamamaraan mula sa isang base class na pinangalanang "BaseClass", isagawa ang "*AUTOLOAD =
\&BaseClass::AUTOLOAD" habang nagsisimula.

Sa code na kasalukuyang nagsasabing "use AutoLoader; @ISA = qw(AutoLoader);" dapat mong alisin
AutoLoader mula sa @ISA at baguhin ang "use AutoLoader;" para "gamitin ang AutoLoader 'AUTOLOAD';".

Ang paggamit ng %s sa printf na format ay hindi suportado
(F) Sinubukan mong gumamit ng feature ng printf na naa-access lamang mula sa C. Ito
karaniwang nangangahulugan na mayroong isang mas mahusay na paraan upang gawin ito sa Perl.

Ang paggamit ng %s ay hindi na ginagamit
(D hindi na ginagamit) Ang construct na ipinahiwatig ay hindi na inirerekomenda para sa paggamit, sa pangkalahatan
dahil mayroong isang mas mahusay na paraan upang gawin ito, at dahil din ang lumang paraan ay may masamang panig
effect.

Ang paggamit ng mga literal na control character sa mga variable na pangalan ay hindi na ginagamit
Ang paggamit ng mga literal na hindi graphic na character sa mga variable na pangalan ay hindi na ginagamit
(D hindi na ginagamit) Paggamit ng literal na hindi graphic (kabilang ang kontrol) na mga character sa pinagmulan
upang sumangguni sa ^FOO variable, tulad ng $^X at "${^GLOBAL_PHASE}" ay hindi na ginagamit.
(Ginagamit namin ang "^X" at "^G" dito para sa pagiging madaling mabasa. Talagang kinakatawan nila ang hindi napi-print
control character, code point 0x18 at 0x07, ayon sa pagkakabanggit; Ang ibig sabihin ng "^A" ay ang
control character na ang code point ay 0x01.) Nakakaapekto lang ito sa code tulad ng "$\cT", kung saan
Ang "\cT" ay isang kontrol sa source code; Ang "${"\cT"}" at $^T ay nananatiling wasto. Mga bagay na
ay mga non-control at hindi rin graphic ang NO-BREAK SPACE at SOFT HYPHEN, which were
dati ay pinapayagan lamang para sa makasaysayang mga kadahilanan.

Paggamit ng -l sa filehandle%s
(W io) Ang filehandle ay kumakatawan sa isang nakabukas na file, at kapag binuksan mo ang file ito na
dumaan sa anumang symlink na malamang na sinusubukan mong hanapin. Bumalik ang operasyon
"undef". Gumamit na lang ng filename.

Ang paggamit ng aking $_ ay eksperimental
(S experimental::lexical_topic) Ang Lexical $_ ay isang pang-eksperimentong tampok at ang pag-uugali nito
maaaring magbago o maalis pa sa anumang paglabas ng perl sa hinaharap. Tingnan ang paliwanag
sa ilalim ng "$_" sa perlvar.

Ang paggamit ng %s sa isang handle na walang * ay hindi na ginagamit
(D hindi na ginagamit) Gumamit ka ng "tie", "tied" o "untie" sa isang scalar ngunit nangyayari ang scalar na iyon
na humawak ng isang typeglob, na nangangahulugan na ang filehandle nito ay matatali. Kung ibig mong itali a
hawakan, gumamit ng tahasang * tulad ng sa "tie *$handle".

Ito ay isang matagal nang bug na inalis sa Perl 5.16, dahil walang paraan upang itali
ang scalar mismo kapag may hawak itong typeglob, at walang paraan para makalas ang isang scalar na nagkaroon ng
typeglob na nakatalaga dito. Kung nakikita mo ang mensaheng ito, dapat ay gumagamit ka ng mas lumang bersyon.

Paggamit ng reference na "%s" bilang array index
(W misc) Sinubukan mong gumamit ng reference bilang array index; malamang na hindi ito ang sa iyo
ibig sabihin, dahil ang mga sanggunian sa numerical na konteksto ay may posibilidad na napakalaking numero, at kadalasan
ay nagpapahiwatig ng error sa programmer.

Kung talagang sinadya mo ito, tahasang i-numify ang iyong reference, tulad nito: $array[0+$ref].
Ang babalang ito ay hindi ibinigay para sa mga overload na bagay, gayunpaman, dahil maaari kang mag-overload
ang numification at stringification operator at pagkatapos ay malamang na alam mo kung ano ang iyong
ay ginagawa.

Ang paggamit ng estado na $_ ay eksperimental
(S experimental::lexical_topic) Ang Lexical $_ ay isang pang-eksperimentong tampok at ang pag-uugali nito
maaaring magbago o maalis pa sa anumang paglabas ng perl sa hinaharap. Tingnan ang paliwanag
sa ilalim ng "$_" sa perlvar.

Ang paggamit ng mga bahid na argumento sa %s ay hindi na ginagamit
(W taint, deprecated) Nagbigay ka ng "system()" o "exec()" na may maraming argumento
at least may bahid ng isa sa kanila. Dati ito ay pinapayagan ngunit magiging isang nakamamatay
error sa isang hinaharap na bersyon ng perl. Alisin ang iyong mga argumento. Tingnan ang perlsec.

Paggamit ng uninitialized value%s
(W uninitialized) Isang hindi natukoy na halaga ang ginamit na parang tinukoy na ito. Ito ay
binibigyang kahulugan bilang isang "" o isang 0, ngunit marahil ito ay isang pagkakamali. Upang sugpuin ang babalang ito
magtalaga ng tinukoy na halaga sa iyong mga variable.

Upang matulungan kang malaman kung ano ang hindi natukoy, susubukan ni perl na sabihin sa iyo ang pangalan ng
variable (kung mayroon man) na hindi natukoy. Sa ilang mga kaso hindi nito magagawa ito, gayundin
nagsasabi sa iyo kung saang operasyon mo ginamit ang hindi natukoy na halaga. Tandaan, gayunpaman, ang perl na iyon
ino-optimize ang iyong programa at ang pagpapatakbo na ipinapakita sa babala ay maaaring hindi kinakailangan
literal na lumilitaw sa iyong programa. Halimbawa, ang "na $foo" ay karaniwang na-optimize sa
""na " . $foo", at ang babala ay magre-refer sa "concatenation (.)" operator, kahit na
kahit walang "." sa iyong programa.

Ang "use re 'strict'" ay experimental
(S experimental::re_strict) Ang mga bagay na naiiba kapag regular na expression
pattern ay pinagsama-sama sa ilalim ng 'mahigpit' ay napapailalim sa pagbabago sa hinaharap Perl release sa
hindi magkatugmang mga paraan. Nangangahulugan ito na ang isang pattern na pinagsama-sama ngayon ay maaaring hindi sa hinaharap
Paglabas ng Perl. Ang babalang ito ay para alertuhan ka sa panganib na iyon.

Gamitin ang \x{...} para sa higit sa dalawang hex na character sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Sa isang regular na expression, sinabi mo ang isang bagay tulad ng

(?[ [ \xBEEF ] ])

Hindi sigurado si Perl kung sinadya mo ito

(?[ [ \x{BEEF} ] ])

o kung ito ang sinadya mo

(?[ [ \x{BE} EF ] ])

Kailangan mong magdagdag ng alinman sa mga brace o mga blangko upang i-disambiguate.

Gamit lamang ang unang character na ibinalik ng \N{} sa klase ng character sa regex; minarkahan ng
<-- DITO sa m/%s/
(W regexp) Ang pinangalanang Unicode na character na "(\N{...})" ay maaaring magbalik ng isang multi-character
pagkakasunod-sunod. Kahit na ang isang klase ng character ay dapat na tumugma sa isang character lang ng
input, ang perl ay tutugma sa buong bagay nang tama, maliban kung ang klase ay baligtad
("[^...]"), o ang pagtakas ay ang simula o huling punto ng pagtatapos ng isang hanay. Para dito,
kung ano ang dapat mangyari ay hindi malinaw sa lahat. Sa mga sitwasyong ito, itinatapon ni Perl ang lahat maliban
ang unang character ng ibinalik na pagkakasunud-sunod, na malamang na hindi kung ano ang gusto mo.

Paggamit ng /u para sa '%s' sa halip na /%s sa regex; minarkahan ng <-- DITO sa m/%s/
(W regexp) Gumamit ka ng hangganan ng Unicode ("\b{...}" o "\B{...}") sa isang bahagi ng isang
regular na expression kung saan ang mga character set modifier na "/a" o "/aa" ay may bisa.
Ang dalawang modifier na ito ay nagpapahiwatig ng interpretasyon ng ASCII, at hindi ito makatuwiran
isang kahulugan ng Unicode. Ang nabuong regular na expression ay mag-iipon upang ang
boundary ay gumagamit ng lahat ng Unicode. Walang ibang bahagi ng regular na expression ang apektado.

Ang paggamit ng !~ sa %s ay hindi makatwiran
(F) Ang paggamit ng "!~" operator na may "s///r", "tr///r" o "y///r" ay kasalukuyang nakalaan
para sa hinaharap na paggamit, dahil ang eksaktong pag-uugali ay hindi pa napagpasyahan. (Ibinabalik lamang ang
Ang boolean na kabaligtaran ng binagong string ay karaniwang hindi partikular na kapaki-pakinabang.)

UTF-16 surrogate U+%X
(S surrogate) Nagkaroon ka ng UTF-16 na kahalili sa isang konteksto kung saan hindi sila isinasaalang-alang
katanggap-tanggap. Ang mga code point na ito, sa pagitan ng U+D800 at U+DFFF (inclusive), ay ginagamit ng
Unicode para lang sa UTF-16. Gayunpaman, panloob na pinapayagan ng Perl ang lahat ng unsigned integer code
mga puntos (hanggang sa limitasyon sa laki na magagamit sa iyong platform), kabilang ang mga kahalili. Pero
ang mga ito ay maaaring magdulot ng mga problema kapag input o output, na malamang kung saan ito
nagmula ang mensahe. Kung talagang alam mo talaga ang iyong ginagawa maaari mong i-off ito
babala sa pamamagitan ng "walang babala 'kapalit';".

Ang halaga ng %s ay maaaring "0"; pagsubok na may tinukoy()
(W misc) Sa isang conditional expression, ginamit mo , <*> (glob), "bawat()", o
"readdir()" bilang isang boolean na halaga. Ang bawat isa sa mga construct na ito ay maaaring magbalik ng halaga na "0";
na gagawing mali ang conditional expression, na malamang na hindi kung ano ang sa iyo
sinadya. Kapag ginagamit ang mga construct na ito sa mga conditional na expression, subukan ang kanilang mga halaga
gamit ang "tinukoy" na operator.

Masyadong mahaba ang value ng simbolo ng CLI na "%s".
(W misc) Isang babala na kakaiba sa VMS. Sinubukan ni Perl na basahin ang halaga ng isang %ENV na elemento
mula sa isang talahanayan ng simbolo ng CLI, at nakakita ng resultang string na mas mahaba sa 1024 na character.
Ang return value ay pinutol sa 1024 na character.

Ang mga halaga sa sanggunian ay pang-eksperimento
(S experimental::autoderef) "mga halaga" na may scalar argument ay eksperimental at maaaring
baguhin o alisin sa hinaharap na bersyon ng Perl. Kung nais mong kunin ang panganib sa paggamit
ang tampok na ito, huwag paganahin ang babalang ito:

walang babala "experimental::autoderef";

Ang variable na "%s" ay hindi magagamit
(W closure) Sa panahon ng compilation, sinusubukan ng isang panloob na pinangalanang subroutine o eval
kumuha ng panlabas na leksikal na kasalukuyang hindi magagamit. Ito ay maaaring mangyari para sa isa sa
dalawang dahilan. Una, ang panlabas na leksikal ay maaaring ideklara sa isang panlabas na anonymous
subroutine na hindi pa nagagawa. (Tandaan na ang mga pinangalanang sub ay nilikha sa
oras ng pag-compile, habang ang mga hindi kilalang sub ay nilikha sa oras ng pagtakbo.) Halimbawa,

sub { my $a; sub f { $a } }

Sa oras na nilikha ang f, hindi nito makuha ang kasalukuyang halaga ng $a, dahil ang
hindi pa nagagawa ang anonymous na subroutine. Sa kabaligtaran, ang mga sumusunod ay hindi magbibigay ng a
babala dahil ang hindi kilalang subroutine ay nagawa na at live na:

sub { my $a; eval 'sub f { $a }' }->();

Ang pangalawang sitwasyon ay sanhi ng pag-access ng isang eval sa isang variable na nawala
saklaw, halimbawa,

sub f {
aking $a;
sub { eval '$a' }
}
f()->();

Dito, kapag ang '$a' sa eval ay pinagsama-sama, ang f() ay hindi kasalukuyang
naisakatuparan, kaya ang $a nito ay hindi magagamit para makuha.

Ang variable na "%s" ay hindi na-import%s
(S misc) Sa epekto ng "paggamit ng mahigpit", tinukoy mo ang isang pandaigdigang variable na ikaw
tila naisip ay na-import mula sa isa pang module, dahil iba ang
parehong pangalan (karaniwang isang subroutine) ay na-export ng module na iyon. Ito ay karaniwang nangangahulugan na ikaw ay ilagay
ang maling nakakatawang karakter sa harap ng iyong variable.

Hindi ipinatupad sa regex m/%s/ ang haba ng variable na hitsura sa likod
(F) Ang Lookbehind ay pinapayagan lamang para sa mga subexpression na ang haba ay naayos at kilala sa
oras ng pag-compile. Para sa positibong pagtingin sa likod, maaari mong gamitin ang "\K" regex construct bilang isang paraan
para makuha ang katumbas na functionality. Tingnan ang "(?<=pattern) \K" sa perlre.

May mga hindi halatang panuntunan sa Unicode sa ilalim ng "/i" na maaaring tumugma sa iba't ibang paraan, ngunit alin sa iyo
maaaring hindi isipin na maaari. Halimbawa, ang substring na "ss" ay maaaring tumugma sa iisang character
LATIN MALIIT NA LETRA SHARP S. May iba pang pagkakasunod-sunod ng mga karakter ng ASCII na maaari
tumugma sa mga solong ligature na character, gaya ng LATIN SMALL LIGATURE FFI na pagtutugma
"qr/ffi/i". Simula sa Perl v5.16, kung nagmamalasakit ka lang sa mga tugma ng ASCII, idagdag ang
Ang "/aa" modifier sa regex ay ibubukod ang lahat ng mga hindi halatang tugmang ito, kaya nakukuha
tanggalin ang mensaheng ito. Maaari mo ring sabihin ang "use re qw(/aa)" para ilapat ang "/aa" sa lahat ng regular
mga ekspresyong pinagsama-sama sa loob ng saklaw nito. Tingnan muli.

"%s" variable %s masks mas naunang deklarasyon sa parehong %s
(W misc) Ang variable na "my", "our" o "state" ay muling idineklara sa kasalukuyang saklaw o
pahayag, na epektibong inaalis ang lahat ng access sa nakaraang instance. Ito ay
halos palaging isang typographical error. Tandaan na ang naunang variable ay mananatili pa rin
hanggang sa katapusan ng saklaw o hanggang sa masira ang lahat ng pagsasara ng mga sanggunian dito.

Variable syntax
(A) Hindi mo sinasadyang napatakbo ang iyong script csh sa halip na Perl. Suriin ang #!
linya, o manu-manong i-feed ang iyong script sa Perl mismo.

Ang variable na "%s" ay hindi mananatiling nakabahagi
(W pagsasara) Isang panloob (nakapugad) pinangalanan ang subroutine ay tumutukoy sa isang leksikal na variable
tinukoy sa isang panlabas na pinangalanang subroutine.

Kapag tinawag ang panloob na subroutine, makikita nito ang halaga ng panlabas na subroutine
variable tulad ng dati at sa panahon ng *unang* tawag sa panlabas na subroutine; dito sa
kaso, pagkatapos makumpleto ang unang tawag sa panlabas na subroutine, ang panloob at panlabas
ang mga subroutine ay hindi na magbabahagi ng karaniwang halaga para sa variable. Sa madaling salita, ang
hindi na ibabahagi ang variable.

Ang problemang ito ay kadalasang malulutas sa pamamagitan ng paggawa ng inner subroutine na hindi nakikilala, gamit ang
"sub {}" syntax. Kapag inner anonymous subs na tumutukoy sa mga variable sa panlabas
ang mga subroutine ay nilikha, sila ay awtomatikong rebound sa kasalukuyang mga halaga ng mga ito
mga variable.

hindi suportado ang vector argument sa mga bersyon ng alpha
(S printf) Hindi sinusuportahan ng %vd (s)printf na format ang mga object na bersyon na may mga alpha parts.

Ang pattern ng pandiwa na '%s' ay may mandatoryong argumento sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng pattern ng pandiwa na nangangailangan ng argumento. Magbigay ng argumento o tseke
na ginagamit mo ang tamang pandiwa.

Ang pattern ng pandiwa na '%s' ay maaaring walang argumento sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Gumamit ka ng pattern ng pandiwa na hindi pinapayagan ang argumento. Alisin ang argumento o
suriin kung gumagamit ka ng tamang pandiwa.

Ang numero ng bersyon ay dapat na isang pare-parehong numero
(P) Ang pagtatangkang isalin ang isang "use Module nn LIST" na pahayag sa katumbas nito
Ang "BEGIN" block ay nakakita ng panloob na hindi pagkakatugma sa numero ng bersyon.

Ang string ng bersyon na '%s' ay naglalaman ng di-wastong data; hindi pinapansin: '%s'
(W misc) Ang string ng bersyon ay naglalaman ng mga di-wastong character sa dulo, na nagiging
hindi pinansin

Babala: may mali
(W) Pumasa ka balaan() isang walang laman na string (ang katumbas ng "babala """) o tinawag mo ito
na walang args at $@ ay walang laman.

Babala: hindi maisara nang maayos ang filehandle %s
(S) Ang implicit isara () ginawa ng isang bukas() nakakuha ng indikasyon ng error sa isara ().
Ito ay karaniwang nagpapahiwatig na ang iyong file system ay naubusan ng espasyo sa disk.

Babala: hindi maisara nang maayos ang filehandle: %s
Babala: hindi maisara nang maayos ang filehandle %s: %s
(S io) May naganap na error nang tahasang isinara ni Perl ang isang filehandle. Kadalasan ito
ay nagpapahiwatig na ang iyong file system ay naubusan ng espasyo sa disk.

Babala: Ang paggamit ng "%s" na walang panaklong ay malabo
(S ambiguous) Sumulat ka ng unary operator na sinusundan ng isang bagay na parang a
binary operator na maaari ding bigyang-kahulugan bilang termino o unary operator.
Halimbawa, kung alam mo na ang rand function ay may default na argumento na 1.0, at
sumulat ka

rand + 5;

maaari mong INIISIP na isinulat mo ang parehong bagay bilang

rand() + 5;

ngunit sa katunayan, nakuha mo

rand(+5);

Kaya maglagay ng panaklong para sabihin kung ano talaga ang ibig mong sabihin.

kailan experimental
(S experimental::smartmatch) Ang "kailan" ay nakasalalay sa smartmatch, na pang-eksperimento.
Bukod pa rito, mayroon itong ilang mga espesyal na kaso na maaaring hindi agad halata, at
maaaring magbago o maalis ang kanilang pag-uugali sa anumang paglabas ng perl sa hinaharap. Tingnan ang
paliwanag sa ilalim ng "Mga Detalye ng Eksperimento sa ibinigay at kailan" sa perlsyn.

Malawak na character sa %s
(S utf8) Nakilala ni Perl ang isang malawak na karakter (>255) nang hindi nito inaasahan ang isa. Ang babalang ito
ay naka-on bilang default para sa I/O (tulad ng pag-print). Ang pinakamadaling paraan upang patahimikin ang babalang ito ay
para lang idagdag ang ":utf8" na layer sa output, hal. "binmode STDOUT, ':utf8'".
Ang isa pang paraan upang i-off ang babala ay ang magdagdag ng "walang babala 'utf8';" pero madalas yun
mas malapit sa dayaan. Sa pangkalahatan, dapat mong tahasang markahan ang filehandle
na may encoding, tingnan ang open at "binmode" sa perlfunc.

Malapad na character (U+%X) sa %s
(W locale) Habang nasa isang single-byte locale (ibig sabihin, isang hindi UTF-8), isang multi-byte
character ay nakatagpo. Itinuturing ni Perl na ang character na ito ay ang tinukoy na Unicode
code point. Ang pagsasama-sama ng mga lokal na hindi UTF-8 at Unicode ay mapanganib. Halos tiyak
ang ilang mga character ay magkakaroon ng dalawang magkaibang representasyon. Halimbawa, sa ISO
8859-7 (Greek) na lokal, ang code point na 0xC3 ay kumakatawan sa isang Capital Gamma. Ngunit gayon din
ay 0x393. Gagawin nitong hindi mapagkakatiwalaan ang mga paghahambing ng string.

Malamang na kailangan mong malaman kung paano nahalo ang multi-byte na character na ito sa iyong
single-byte locale (o marahil naisip mo na mayroon kang lokal na UTF-8, ngunit ang Perl
hindi sumasang-ayon).

Sa loob ng []-length '%c' ay hindi pinapayagan
(F) Ang bilang sa template ng (un)pack ay maaaring palitan ng "[TEMPLATE]" kung
Palaging tumutugma ang "TEMPLATE" sa parehong dami ng mga naka-pack na byte na maaaring matukoy mula sa
ang template lamang. Hindi ito posible kung naglalaman ito ng alinman sa mga code @, /, U, u,
w o isang *-haba. Muling idisenyo ang template.

sumulat () sa saradong filehandle %s
(W closed) Ang filehandle na isinusulat mo ay naisara nito minsan bago ngayon.
Suriin ang iyong daloy ng kontrol.

%s "\x%X" ay hindi mapa sa Unicode
(S utf8) Kapag nagbabasa sa iba't ibang pag-encode, sinusubukan ni Perl na imapa ang lahat
Mga character na Unicode. Ang mga byte na nabasa mo ay hindi legal sa encoding na ito. Para sa
halimbawa

utf8 "\xE4" ay hindi mapa sa Unicode

kung susubukan mong basahin sa a-diaereses Latin-1 bilang UTF-8.

'X' sa labas ng string
(F) Mayroon kang (un)pack na template na tumukoy ng relatibong posisyon bago ang
simula ng string na (hindi) naka-pack. Tingnan ang "pack" sa perlfunc.

'x' sa labas ng string sa i-unpack
(F) Mayroon kang template ng pack na nagtukoy ng kamag-anak na posisyon pagkatapos ng pagtatapos ng
na-unpack ang string. Tingnan ang "pack" sa perlfunc.

HINDI MO PA PINAGANASAN ANG SET-ID SCRIPTS SA KERNEL!
(F) At malamang na hindi mo magagawa ito, dahil malamang na wala kang mga mapagkukunan para sa iyo
kernel, at ang iyong vendor ay malamang na hindi nagbibigay ng isang rip tungkol sa kung ano ang gusto mo. Ang iyong pinakamahusay
ang taya ay maglagay ng setuid C wrapper sa paligid ng iyong script.

Kailangan mong i-quote ang "%s"
(W syntax) Nagtalaga ka ng bareword bilang pangalan ng signal handler. Sa kasamaang palad, ikaw
mayroon nang subroutine ng pangalang iyon na ipinahayag, na nangangahulugang susubukan ng Perl 5
tawagan ang subroutine kapag naisakatuparan ang takdang-aralin, na malamang na hindi ito sa iyo
gusto. (Kung ito ang gusto mo, maglagay ng & sa harap.)

Ang iyong mga random na numero ay hindi ganoon ka random
(F) Kapag sinusubukang simulan ang random na binhi para sa mga hash, walang makuha si Perl
randomness sa labas ng iyong system. Ito ay kadalasang nagpapahiwatig ng Something Very Mali.

Zero haba \N{} sa regex; minarkahan ng <-- DITO sa m/%s/
(F) Ang pinangalanang Unicode na character na escapes ("\N{...}") ay maaaring magbalik ng zero-length na sequence.
Ang ganitong pagtakas ay ginamit sa isang pinahabang klase ng character, ibig sabihin, "(?[...])", na hindi
pinahihintulutan. Suriin kung ang tamang pagtakas ay ginamit, at ang mga tamang charname
nasa saklaw ang handler. Ang <-- HERE ay nagpapakita kung nasaan sa regular na expression ang
natuklasan ang problema.

Gamitin ang perldiag online gamit ang mga serbisyo ng onworks.net