perldiag - Online in de cloud

PROGRAMMA:

NAAM

perldiag - verschillende Perl-diagnostiek

PRODUCTBESCHRIJVING

Deze berichten zijn als volgt geclassificeerd (in oplopende volgorde van wanhoop):

(W) Een waarschuwing (optioneel).
(D) Een afschrijving (standaard ingeschakeld).
(S) Een ernstige waarschuwing (standaard ingeschakeld).
(F) Een fatale fout (trappeerbaar).
(P) Een interne fout die u nooit zou mogen zien (trappable).
(X) Een zeer fatale fout (niet te vangen).
(A) Een buitenaards foutbericht (niet gegenereerd door Perl).

Het merendeel van de berichten uit de eerste drie classificaties hierboven (W, D & S) kan dat zijn
gecontroleerd met behulp van het ‘waarschuwingen’-pragma.

Als een bericht kan worden gecontroleerd door het "waarschuwingen"-pragma, wordt de waarschuwingscategorie ervan opgenomen
met de classificatieletter in de onderstaande beschrijving. Bv. "(W gesloten)" betekent a
waarschuwing in de categorie "gesloten".

Optionele waarschuwingen worden ingeschakeld door gebruik te maken van het "waarschuwingen"-pragma of de -w en -W schakelaars.
Waarschuwingen kunnen worden opgevangen door $SIG{__WARN__} in te stellen op een verwijzing naar een routine die dat wel doet
bij elke waarschuwing worden opgeroepen in plaats van deze af te drukken. Zie perlvar.

Ernstige waarschuwingen zijn altijd ingeschakeld, tenzij ze expliciet zijn uitgeschakeld met de
"waarschuwingen" pragma of de -X schakelaar.

Op te vangen fouten kunnen worden opgevangen met behulp van de eval-operator. Zie "eval" in perlfunc. In
In bijna alle gevallen kunnen waarschuwingen selectief worden uitgeschakeld of tot fatale fouten worden gepromoveerd
het ‘waarschuwingen’-pragma. Zie waarschuwingen.

De berichten staan ​​in alfabetische volgorde, zonder rekening te houden met hoofdletters of kleine letters. Enkele van
deze berichten zijn algemeen. Vlekken die variëren, worden aangegeven met een %s of een andere printf-stijl
ontsnappen. Deze ontsnappingen worden in alfabetische volgorde genegeerd, net als alle andere tekens
dan brieven. Om uw bericht op te zoeken, negeert u gewoon alles dat geen letter is.

aanvaarden() op gesloten socket %s
(W gesloten) U heeft geprobeerd een acceptatie uit te voeren op een gesloten stopcontact. Ben je vergeten de
retourwaarde van uw stopcontact () telefoongesprek? Zie "accepteren" in perlfunc.

Aliasing via referentie is experimenteel
(S experimenteel::refaliasing) Deze waarschuwing wordt gegeven als u een referentie gebruikt
constructor aan de linkerkant van een toewijzing om de ene variabele naar de andere te aliasen.
Onderdruk eenvoudig de waarschuwing als u de functie wilt gebruiken, maar weet dat daarbij
u loopt het risico een experimentele functie te gebruiken die mogelijk verandert of wordt
verwijderd in een toekomstige Perl-versie:

geen waarschuwingen "experimenteel::refaliasing";
gebruik de functie "refaliasing";
\$x = \$y;

Toewijzing te groot: %x
(X) U kunt niet meer dan 64 KB toewijzen op een MS-DOS-machine.

'%c' alleen toegestaan ​​na typen %s in %s
(F) De modifiers '!', '<' en '>' zijn toegestaan pak() or uitpakken() alleen na
bepaalde types. Zie "pack" in perlfunc.

Dubbelzinnige oproep opgelost als CORE::%s(), kwalificeer als zodanig of gebruik &
(W dubbelzinnig) Een subroutine die u hebt gedeclareerd heeft dezelfde naam als een Perl-trefwoord, en
je hebt de naam zonder enige kwalificatie gebruikt om de een of de ander te bellen. Perl
besloten om de ingebouwde versie aan te roepen omdat de subroutine niet geïmporteerd is.

Om interpretatie als een subroutine-oproep te forceren, plaatst u een ampersand vóór de
subroutinenaam, of kwalificeer de naam met het bijbehorende pakket. Als alternatief kunt u importeren
de subroutine (of doe alsof deze is geïmporteerd met het pragma "use subs").

Om het stilletjes te interpreteren als de Perl-operator, gebruikt u het voorvoegsel "CORE::" voor de operator
(bijv. "CORE::log($x)") of declareer de subroutine als een objectmethode (zie
"Subroutine-attributen" in perlsub of attributen).

Dubbelzinnig bereik in transliteratie-operator
(F) Je schreef iets als "tr/az-0//", wat helemaal niets betekent. Naar
neem een ​​"-" teken op in een transliteratie, plaats dit als eerste of als laatste. (In de
Vroeger was "tr/az-0//" synoniem met "tr/ay//", wat je waarschijnlijk niet bedoelde
had verwacht.)

Dubbelzinnig gebruik van %s opgelost als %s
(S dubbelzinnig) Je zei iets dat misschien niet geïnterpreteerd wordt zoals je dacht.
Normaal gesproken is het vrij eenvoudig om dit ondubbelzinnig te maken door een ontbrekend citaat, operator,
haakjespaar of declaratie.

Dubbelzinnig gebruik van -%s opgelost als -&%s()
(S dubbelzinnig) Je schreef iets als "-foo", wat de string "-foo" zou kunnen zijn, of a
oproep naar de functie "foo", ontkend. Als je de string bedoelde, schrijf dan gewoon "-foo". Als
je bedoelde de functieaanroep, schrijf "-foo()".

Dubbelzinnig gebruik van %c opgelost als operator %c
(S dubbelzinnig) "%", "&" en "*" zijn beide infix-operatoren (modulus, bitwise en, en
vermenigvuldiging) en initiële speciale tekens (die hashes, subroutines en
typeglobs), en je zei iets als "*foo * foo" dat geïnterpreteerd zou kunnen worden als
een van beide. We gingen ervan uit dat je de infix-operator bedoelde, maar probeer het alsjeblieft te maken
duidelijker -- in het gegeven voorbeeld zou je "*foo * foo()" kunnen schrijven als je het echt meende
een glob vermenigvuldigen met het resultaat van het aanroepen van een functie.

Dubbelzinnig gebruik van %c{%s} opgelost in %c%s
(W dubbelzinnig) Je hebt iets geschreven als "@{foo}", wat mogelijk om de
variabele @foo, of het roept mogelijk een functie aan met de naam foo, en herrefereert deze als een
array-referentie. Als je de variabele wilt, kun je gewoon @foo schrijven. Als je wilt
om de functie aan te roepen, schrijf je "@{foo()}" ... anders heb je gewoon geen variabele en a
functie met dezelfde naam, en bespaar jezelf een hoop moeite.

Dubbelzinnig gebruik van %c{%s[...]} opgelost in %c%s[...]
Dubbelzinnig gebruik van %c{%s{...}} opgelost in %c%s{...}
(W dubbelzinnig) Je hebt zoiets geschreven als "${foo[2]}" (waarbij foo de naam van een
Perl-trefwoord), dat mogelijk zoekt naar element nummer 2 van de array met de naam @foo, in
schrijf in dat geval $foo[2], anders had je misschien een anonieme arrayref willen doorgeven
naar de functie met de naam foo, en voer vervolgens een scalaire deref uit op de waarde die deze retourneert. als jij
bedoelde dat, schrijf "${foo([2])}".

In reguliere expressies is de syntaxis "${foo[2]}" soms nodig om het ondubbelzinnig te maken
tussen array-subscripts en tekenklassen. "/$length[2345]/", bijvoorbeeld
worden geïnterpreteerd als $length gevolgd door de tekenklasse "[2345]". Als een array
subscript is wat je wilt, je kunt de waarschuwing vermijden door "/${length[2345]}/" te wijzigen
naar het lelijke "/${\$length[2345]}/", door uw array te hernoemen naar iets dat dat wel doet
niet samenvallen met een ingebouwd trefwoord, of door simpelweg waarschuwingen uit te schakelen met "nee
waarschuwingen 'dubbelzinnig';".

'|' en '<' mogen niet allebei op de opdrachtregel worden opgegeven
(F) Een fout die eigen is aan VMS. Perl voert zijn eigen opdrachtregelomleiding uit en vond
dat STDIN een pipe was, en dat je ook geprobeerd hebt STDIN om te leiden met '<'. Maar een
STDIN-stream naar een klant, alstublieft.

'|' en '>' mogen niet allebei op de opdrachtregel worden opgegeven
(F) Een fout die eigen is aan VMS. Perl voert zijn eigen opdrachtregelomleiding uit en denkt na
je hebt geprobeerd stdout zowel naar een bestand als naar een pipe naar een ander commando om te leiden. Jij
je moet het een of het ander kiezen, hoewel niets je ervan weerhoudt om in een te duiken
programma of Perl-script dat de uitvoer in twee stromen 'splitst', zoals

open(OUT,">$ARGV[0]") of die "Kan niet schrijven naar $ARGV[0]: $!";
terwijl ( ) {
afdrukken;
afdrukken;
}
sluit UIT;

Het toepassen van %s op %s zal inwerken op scalair(%s)
(W misc) De patroonovereenkomst ("//"), vervanging ("s///") en transliteratie
("tr///") operators werken met scalaire waarden. Als u een van deze toepast op een array of a
hash, het converteert de array of hash naar een scalaire waarde (de lengte van een array, of
de populatie-informatie van een hash) en werk vervolgens aan die scalaire waarde. Dit is waarschijnlijk
niet wat je wilde doen. Zie "grep" in perlfunc en "map" in perlfunc voor
alternatieven.

Arg te kort voor msgsnd
(F) msgsnd() vereist een string die minstens zo lang is als sizeof(long).

Argument '%s' is niet numeriek%s
(W numeriek) De aangegeven string werd als argument ingevoerd aan een operator die a verwachtte
numerieke waarde. Als u geluk heeft, wordt in het bericht aangegeven welke operator
was zo ongelukkig.

Merk op dat voor de "Inf" en "NaN" (oneindigheid en niet-een-getal) de definitie van
"numeriek" is enigszins ongebruikelijk: er wordt rekening gehouden met de strings zelf (zoals "Inf")
numeriek, en alles wat daarop volgt, wordt als niet-numeriek beschouwd.

Argumentenlijst niet gesloten voor PerlIO-laag "%s"
(W-laag) Bij het pushen van een laag met argumenten naar het Perl I/O-systeem vergat u de
) waarmee de argumentenlijst wordt gesloten. (Lagen zorgen voor het transformeren van gegevens tussen
externe en interne representaties.) Perl stopte hier met het ontleden van de lagenlijst
punt en probeerde niet deze laag te pushen. Als uw programma dat niet expliciet deed
Als de mislukte operatie wordt aangevraagd, kan dit het gevolg zijn van de waarde van het milieu
variabele PERLIO.

Argument "%s" behandeld als 0 in stappen (++)
(W numeriek) De aangegeven tekenreeks werd als argument aan de operator "++" ingevoerd
verwacht een getal of een tekenreeks die overeenkomt met "/^[a-zA-Z]*[0-9]*\z/". Zie "Auto-
verhogen en automatisch verlagen" in perlop voor details.

bewering mislukt: %s
(X) Het malloc-pakket dat bij Perl wordt geleverd, had een interne fout.

Bewering %s mislukt: bestand "%s", regel %d
(X) Een algemene bewering is mislukt. Het betrokken dossier moet worden onderzocht.

Toegewezen waarde is geen referentie
(F) Je hebt geprobeerd iets toe te wijzen dat geen verwijzing was naar een lvalue-referentie
(bijvoorbeeld "\$x = $y"). Als je van $x een alias voor $y wilt maken, gebruik dan "\$x = \$y".

Toegewezen waarde is niet %s referentie
(F) U hebt geprobeerd een verwijzing toe te wijzen aan een referentieconstructor, maar de twee verwijzingen
waren niet van hetzelfde type. U kunt geen scalair een alias geven aan een array, of een array aan a
hasj; de twee typen moeten overeenkomen.

\$x = \@y; # fout
\@x = \%y; # fout
$y = [];
\$x = $y; # fout; Bedoelde je \$y?

Het is niet langer mogelijk om een ​​waarde die niet nul is toe te wijzen aan $[
(F) Wanneer de functie "array_base" is uitgeschakeld (bijvoorbeeld onder "use v5.16;") wordt de speciale
variabele $[, die verouderd is, heeft nu een vaste nulwaarde.

Toewijzing aan zowel een lijst als een scalair
(F) Als u een voorwaardelijke operator toewijst, moeten de tweede en derde argumenten een van beide zijn
beide zijn scalairen of beide zijn lijsten. Anders weet Perl niet welke context hij moet leveren
naar de rechterkant.

<> bij vereiste-verklaring moeten aanhalingstekens zijn
(F) U schreef "vereiste" " terwijl u "require 'file'" had moeten schrijven.

Probeer toegang te krijgen tot de niet-toegestane sleutel '%s' in een beperkte hash
(F) De foutieve code heeft geprobeerd een sleutel te verkrijgen of in te stellen die niet in de huidige set zit
van toegestane sleutels van een beperkte hash.

Probeer te zegenen in een bevrijd pakket
(F) Je schreef "bless $foo" met één argument nadat je op een of andere manier het huidige pakket veroorzaakte
bevrijd worden. Perl kan niet bedenken wat hij moet doen, dus geeft hij wanhopig in zijn handen over.

Probeer te zegenen in een referentie
(F) Het CLASSNAME-argument voor de zegenen() operator wordt verwacht dat dit de naam is van de
pakket om het resulterende object in te zegenen. U heeft in plaats daarvan een verwijzing opgegeven naar
iets: misschien schreef je

zegen $self, $proto;

wanneer je het bedoelde

zegen $self, ref($proto) || $proto;

Als je daadwerkelijk wilt zegenen in de stringente versie van de meegeleverde referentie,
je moet het zelf stringificeren, bijvoorbeeld door:

zegen $self, "$proto";

Probeer de verwijderde array te wissen
(S-foutopsporing) Er is een array toegewezen toen deze werd vrijgegeven. Bevrijde waarden zijn dat niet
zou zichtbaar moeten zijn voor Perl-code. Dit kan ook gebeuren als XS-code "av_clear" aanroept
van een aangepaste magische callback op de array.

Probeer de niet-toegestane sleutel '%s' uit een beperkte hash te verwijderen
(F) De falende code heeft geprobeerd een sleutel te verwijderen uit een beperkte hash die er niet in zit
zijn sleutelset.

Probeer de alleen-lezen sleutel '%s' uit een beperkte hash te verwijderen
(F) De falende code heeft geprobeerd een sleutel te verwijderen waarvan de waarde alleen-lezen is verklaard
van een beperkte hash.

Poging om niet-arena-SV te bevrijden: 0x%x
(S intern) Het is de bedoeling dat alle SV-objecten worden toegewezen vanuit de toekomstige arena's
afval verzameld bij de uitgang. Er werd ontdekt dat een SV zich buiten een van deze arena's bevond.

Probeer de niet-bestaande gedeelde tekenreeks '%s'%s vrij te geven
(S intern) Perl onderhoudt een naar referentie getelde interne tabel met tekenreeksen die geoptimaliseerd kunnen worden
de opslag en toegang tot hash-sleutels en andere strings. Dit geeft aan dat iemand het heeft geprobeerd
om het referentieaantal te verlagen van een string die niet langer in de tabel kan worden gevonden.

Poging om de temperatuur voortijdig te verlagen: SV 0x%x
(S-foutopsporing) Gesteriliseerde waarden worden verondersteld te worden vrijgegeven door de free_tmps() routine.
Dit geeft aan dat iets anders de SV bevrijdt vóór de free_tmps() routine
krijgt een kans, wat betekent dat de free_tmps() routine zal het bevrijden van een
scalair zonder referentie wanneer het probeert het te bevrijden.

Probeer glob-aanwijzers zonder referentie vrij te maken
(S intern) De referentietellingen zijn verprutst bij symboolaliassen.

Poging om scalair zonder referentie vrij te maken: SV 0x%x
(S intern) Perl ging het referentieaantal van een scalair verlagen om te zien of dit het geval was
ga naar 0, en ontdekte dat het al eerder naar 0 was gegaan, en dat had ook moeten zijn
vrijgelaten, en werd waarschijnlijk ook vrijgelaten. Dit zou erop kunnen wijzen SvREFCNT_dec() was
te vaak gebeld, of zo SvREFCNT_inc() te weinig werd gebeld, of dat de SV
werd gedood terwijl dat niet had moeten gebeuren, of dat geheugen is beschadigd.

Probeer de pointer naar een tijdelijke waarde te verpakken
(W pack) U heeft geprobeerd een tijdelijke waarde door te geven (zoals het resultaat van een functie, of een
berekende uitdrukking) naar de "p" pak() sjabloon. Dit betekent dat het resultaat een bevat
verwijzing naar een locatie die op elk moment ongeldig kan worden, zelfs vóór het einde van de
huidige verklaring. Gebruik letterlijke of globale waarden als argumenten voor de 'p' pak()
sjabloon om deze waarschuwing te vermijden.

Poging om %s opnieuw te laden is afgebroken.
(F) U heeft geprobeerd een bestand te laden met "use" of "require" dat één keer niet kon worden gecompileerd
al. Perl zal niet proberen dit bestand opnieuw te compileren, tenzij u de vermelding ervan verwijdert
vanaf %INC. Zie "vereist" in perlfunc en "%INC" in perlvar.

Poging om de lengte van de vrijgemaakte array in te stellen
(W misc) U heeft geprobeerd de lengte in te stellen van een array die is vrijgegeven. Je kunt het doen
dit door een verwijzing op te slaan naar de scalaire waarde die de laatste index van een array vertegenwoordigt en
later toewijzen via die referentie. Bijvoorbeeld

$r = doe {mijn @a; \$#a};
$$r = 503

Probeer referentie te gebruiken als lvalue in substr
(W substr) Je hebt als eerste argument een verwijzing opgegeven substr() gebruikt als een
Waarde, wat behoorlijk vreemd is. Misschien ben je vergeten het eerst te derefereren. Zien
"substr" in perlfunc.

Het attribuut 'vergrendeld' is verouderd
(D verouderd) U hebt de attributen pragma gebruikt om het "locked" attribuut aan te passen
een codereferentie. Het kenmerk :locked is verouderd en heeft sinds 5005 geen effect meer
threads zijn verwijderd en zullen in een toekomstige release van Perl 5 worden verwijderd.

Attribuut prototype(%s) verwijdert eerder prototype attribuut in dezelfde sub
(W misc) Een sub werd bijvoorbeeld gedeclareerd als sub foo : prototype(A) : prototype(B) {}.
Omdat elke sub slechts één prototype kan hebben, worden de eerdere aangifte(n) weggegooid
terwijl de laatste wordt toegepast.

Het kenmerk 'uniek' is verouderd
(D verouderd) U hebt de attributen pragma gebruikt om het attribuut "uniek" aan te passen
een array-, hash- of scalaire referentie. Het kenmerk :unique heeft sindsdien geen effect meer gehad
Perl 5.8.8, en zal worden verwijderd in een toekomstige release van Perl 5.

av_reify heeft een gebonden array aangeroepen
(S-foutopsporing) Dit geeft aan dat er iets mis is gegaan en Perl heeft gekregen zeer verward
over @_ of @DB::args die gebonden zijn.

Slechte arglengte voor %s, is %u, zou %d moeten zijn
(F) Je hebt een buffer van de verkeerde grootte doorgegeven aan een van msgctl(), semctl() or shmctl().
In C-taalgebruik zijn de juiste maten respectievelijk sizeof(struct msqid_ds *),
sizeof(struct semid_ds *), en sizeof(struct shmid_ds *).

Slecht beoordeeld vervangingspatroon
(F) Je hebt de schakelaar "/e" gebruikt om de vervanging voor een vervanging te evalueren, maar
perl heeft een syntaxisfout gevonden in de te evalueren code, hoogstwaarschijnlijk een onverwacht recht
beugel '}'.

Slechte bestandshandle: %s
(F) Er is een symbool doorgegeven aan iets dat een bestandshandle nodig heeft, maar het symbool heeft er geen
filehandle die eraan is gekoppeld. Misschien heb je geen Open(), of deed het in een andere
pakket.

slecht vrij() genegeerd
(S malloc) Een interne routine gebeld vrij() op iets dat nooit was geweest
malloc ()in de eerste plaats ed. Verplicht, maar kan worden uitgeschakeld door de omgeving in te stellen
variabele "PERL_BADFREE" op 0.

Dit bericht kan vrij vaak worden gezien met DB_File op systemen met "harde" dynamiek
koppelingen, zoals "AIX" en "OS/2". Het is een bug van "Berkeley DB" die onopgemerkt blijft
als "DB" gebruikt vergevensgezind system malloc ().

Slechte hasj
(P) Aan een van de interne hash-routines is een nul-HV-pointer doorgegeven.

Slecht geplaatste ()'s
(A) Je hebt per ongeluk je script doorlopen csh in plaats van Perl. Controleer de #!
regel, of voer uw script zelf handmatig in Perl in.

Slechte naam na %s
(F) U begon een symbool een naam te geven door een pakketvoorvoegsel te gebruiken, maar maakte het vervolgens niet af
symbool. Je kunt met name niet buiten aanhalingstekens interpoleren, dus

$var = 'mijnvar';
$sym = mijnpack::$var;

is niet hetzelfde als

$var = 'mijnvar';
$sym = "mijnpakket::$var";

Slechte plug-in die het zoekwoord '%s' beïnvloedt
(F) Een extensie die het trefwoordplug-inmechanisme gebruikt, heeft de plug-in-API geschonden.

slecht realloc() genegeerd
(S malloc) Een interne routine gebeld realloc() op iets dat nooit was geweest
malloc ()in de eerste plaats ed. Verplicht, maar kan worden uitgeschakeld door de
omgevingsvariabele "PERL_BADFREE" op 1.

Slecht symbool voor array
(P) Een intern verzoek om een ​​array-item toe te voegen aan iets dat geen symbool was
tabel binnenkomst.

Slecht symbool voor dirhandle
(P) Een intern verzoek om een ​​dirhandle-invoer toe te voegen aan iets dat geen
symbool tabelinvoer.

Slecht symbool voor filehandle
(P) Een intern verzoek vroeg om een ​​filehandle-invoer toe te voegen aan iets dat geen
symbool tabelinvoer.

Slecht symbool voor hasj
(P) Een intern verzoek om een ​​hash-invoer toe te voegen aan iets dat geen symbool was
tabel binnenkomst.

Slecht symbool voor scalair
(P) Een intern verzoek om een ​​scalair item toe te voegen aan iets dat geen symbool was
tabel binnenkomst.

Barwoord gevonden in voorwaardelijk
(W bareword) De compiler vond een bareword waar het een voorwaarde verwachtte, wat:
geeft vaak aan dat een || of && is geparseerd als onderdeel van het laatste argument van de
vorige constructie, bijvoorbeeld:

open FOO || dood gaan;

Het kan ook duiden op een verkeerd gespelde constante die is geïnterpreteerd als een onbeduidend woord:

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

Het "strikte" pragma is nuttig om dergelijke fouten te vermijden.

Bareword "%s" niet toegestaan ​​terwijl "strict subs" in gebruik is
(F) Als er "strikte subs" worden gebruikt, is een kaal woord alleen toegestaan ​​als subroutine-ID,
tussen accolades of links van het symbool "=>". Misschien moet u vooraf een
subroutine?

Bareword "%s" verwijst naar een niet-bestaand pakket
(W bareword) Je gebruikte een gekwalificeerd bareword van de vorm "Foo::", maar de compiler zag het
vóór dat punt geen ander gebruik van die naamruimte. Misschien moet u vooraf een
pakket?

BEGIN mislukt - compilatie afgebroken
(F) Er is een niet-opgevangen uitzondering opgetreden tijdens het uitvoeren van een BEGIN-subroutine. Compilatie
stopt onmiddellijk en de tolk wordt verlaten.

BEGIN niet veilig na fouten - compilatie afgebroken
(F) Perl heeft een "BEGIN {}"-subroutine gevonden (of een "use"-richtlijn, wat een "BEGIN
{}") nadat er al een of meer compilatiefouten waren opgetreden. Sinds het beoogde
omgeving voor "BEGIN {}" kon niet worden gegarandeerd (vanwege de fouten), en sindsdien
de daaropvolgende code hangt waarschijnlijk af van de juiste werking ervan, Perl gaf het gewoon op.

\%d beter geschreven als $%d
(W-syntaxis) Buiten patronen leven terugverwijzingen voort als variabelen. Het gebruik van
backslashes krijgen een uitzonderingsregel aan de rechterkant van een wissel, maar
stilistisch gezien is het beter om de variabele vorm te gebruiken, omdat andere Perl-programmeurs dat zullen doen
verwacht het, en het werkt beter als er meer dan 9 terugverwijzingen zijn.

Binair getal > 0b11111111111111111111111111111111 niet-draagbaar
(W draagbaar) Het door u opgegeven binaire getal is groter dan 2**32-1 (4294967295) en
daarom niet overdraagbaar tussen systemen. Zie perlport voor meer informatie over draagbaarheid
zorgen.

binden() op gesloten socket %s
(W gesloten) U hebt geprobeerd een binding uit te voeren op een gesloten socket. Ben je vergeten de
retourwaarde van uw stopcontact () telefoongesprek? Zie "binden" in perlfunc.

binmode() op gesloten bestandshandle %s
(W ongeopend) Je hebt het geprobeerd binmode() op een filehandle die nooit is geopend. Controleer je
controlestroom en aantal argumenten.

Bitvectorgrootte > 32 niet-draagbaar
(W portable) Het gebruik van bitvectorgroottes groter dan 32 is niet-draagbaar.

Bizarre kopie van %s
(P) Perl heeft een poging gedetecteerd om een ​​interne waarde te kopiëren die niet kan worden gekopieerd.

Bizar SvTYPE [%d]
(P) Bij het starten van een nieuwe thread of het retourneren van waarden uit een thread kwam Perl een
ongeldig gegevenstype.

Beide of geen van beide bereikuiteinden moeten Unicode in regex zijn; gemarkeerd door <-- HIER in m/%s/
(W regexp) (alleen onder "use re 'strict'" of binnen "(?[...])")

In een tekenklasse tussen haakjes in een reguliere-expressiepatroon had je een bereik dat
heeft precies één uiteinde ervan gespecificeerd met "\N{}", en het andere uiteinde is gespecificeerd met behulp van
een niet-draagbaar mechanisme. Perl behandelt het bereik als een Unicode-bereik, dat wil zeggen: alle
tekens erin worden beschouwd als Unicode-tekens, en dat kan ook zo zijn
verschillende codepunten op sommige platforms waarop Perl draait. Bijvoorbeeld: "[\N{U+06}-\x08]"
wordt behandeld alsof u in plaats daarvan "[\N{U+06}-\N{U+08}]" had gezegd, dat wil zeggen dat het overeenkomt met de
tekens waarvan de codepunten in Unicode 6, 7 en 8 zijn. Maar dat "\x08" zou kunnen
geef aan dat je iets anders bedoelde, zodat de waarschuwing wordt gegeven.

Bufferoverloop in prime_env_iter: %s
(W intern) Een waarschuwing eigen aan VMS. Terwijl Perl zich aan het voorbereiden was om te herhalen
%ENV, het kwam een ​​logische naam of symbooldefinitie tegen die te lang was, dus het was
afgekapt tot de getoonde string.

Terugbellen genaamd exit
(F) Een subroutine aangeroepen vanuit een extern pakket via bel_sv() verlaten door te bellen
Uitgang.

%s() belde te vroeg om prototype te controleren
(W prototype) Je hebt een functie aangeroepen die een prototype heeft voordat de parser een zag
definitie of verklaring ervoor, en Perl kon niet controleren of de aanroep voldoet aan
het prototype. U moet ofwel een vroege prototypeverklaring toevoegen voor de:
subroutine in kwestie, of verplaats de subroutinedefinitie vóór de aanroep om te krijgen
correcte prototypecontrole. Als alternatief, als u zeker weet dat u de
goed werkt, kunt u een ampersand voor de naam plaatsen om de waarschuwing te vermijden.
Zie perlsub.

Het aanroepen van POSIX::%s() is verouderd
(D verouderd) U hebt een functie aangeroepen waarvan het gebruik is verouderd. Zie de naam van de functie
in POSIX voor details.

Kan %f niet chr
(F) Je hebt een ongeldig getal (zoals een oneindig of niet-een-getal) doorgegeven aan "chr".

Kan %f in pakket niet comprimeren
(F) Je hebt geprobeerd een oneindig getal of een niet-getal te comprimeren als een geheel getal zonder teken met BER,
wat geen zin heeft.

Kan geheel getal in pakket niet comprimeren
(F) Een argument om in te pakken("w",...) was te groot om te comprimeren. De BER is gecomprimeerd
de integer-indeling kan alleen worden gebruikt met positieve gehele getallen en u hebt geprobeerd te comprimeren
een zeer groot aantal (> 1e308). Zie "pack" in perlfunc.

Kan negatieve getallen in het pakket niet comprimeren
(F) Een argument voor pack("w",...) was negatief. Het BER-gecomprimeerde integer-formaat kan
alleen worden gebruikt met positieve gehele getallen. Zie "pack" in perlfunc.

Kan een verwijzing naar %s niet naar typeglob converteren
(F) Je hebt de symbooltabel van Perl rechtstreeks gemanipuleerd, er een verwijzing in opgeslagen en het vervolgens geprobeerd
om toegang te krijgen tot dat symbool via de conventionele Perl-syntaxis. De toegang activeert Perl
autovivify dat typeglob, maar er is geen legale conversie van dat type
verwijzing naar een typeglob.

Kan niet kopiëren naar %s
(P) Perl heeft een poging gedetecteerd om een ​​waarde te kopiëren naar een intern type dat dat niet kan zijn
direct toegewezen aan.

Kan codering "%s" niet vinden
(S io) Je hebt ook geprobeerd een codering toe te passen die niet bestond op een bestandshandle
Open() or binmode().

Kan %f niet inpakken met '%c'
(F) Je hebt geprobeerd een oneindig of niet-een getal om te zetten in een geheel getal, wat nee oplevert
zin.

Kan f %f niet afdrukken met '%c'
(F) U hebt geprobeerd een oneindig of niet-getal als teken (%c) af te drukken, wat 'nee' oplevert
gevoel. Misschien bedoelde je '%s', of gewoon een tekenreeks?

Kan geen gekoppelde @DB::args instellen
(F) "beller" probeerde @DB::args in te stellen, maar vond dat dit niet het geval was. Het koppelen van @DB::args is dat niet
ondersteund. (Voordat deze fout werd toegevoegd, crashte deze.)

Kan niet-reifieerbare array niet binden
(P) Het is je op de een of andere manier gelukt om "tie" aan te roepen op een array die geen referentietelling bijhoudt
op haar argumenten en kan hiertoe niet worden gedwongen. Dergelijke arrays zouden dat niet eens moeten zijn
toegankelijk voor Perl-code, maar worden alleen intern gebruikt.

Kan alleen gehele getallen zonder teken in het pakket comprimeren
(F) Een argument voor pack("w",...) was geen geheel getal. Het BER-gecomprimeerde gehele getal
-indeling kan alleen worden gebruikt met positieve gehele getallen en u hebt geprobeerd te comprimeren
iets anders. Zie "pack" in perlfunc.

Kan niet-referentiewaarde niet zegenen
(F) Alleen harde referenties kunnen gezegend worden. Dit is hoe Perl de inkapseling van
voorwerpen. Zie perlobj.

Kan een lus-topicalizer niet "breken".
(F) Je hebt "break" genoemd, maar je bevindt je in een "foreach"-blok in plaats van in een "gegeven" blok.
Je bedoelde waarschijnlijk 'volgende' of 'laatste'.

Kan niet "breken" buiten een bepaald blok
(F) Je hebt "break" genoemd, maar je bevindt je niet in een "gegeven" blok.

Kan methode "%s" niet aanroepen op een ongedefinieerde waarde
(F) U gebruikte de syntaxis van een methodeaanroep, maar het slot werd gevuld door de objectreferentie
of pakketnaam bevat een ongedefinieerde waarde. Zoiets zal de
fout:

$BADREF = ondef;
proces $BADREF 1,2,3;
$BADREF->proces(1,2,3);

Kan methode "%s" niet aanroepen op een niet-gezegende referentie
(F) Een methodeaanroep moet weten in welk pakket deze moet worden uitgevoerd. Normaal gesproken wordt er gevonden
dit uit de objectreferentie die u heeft opgegeven, maar u heeft geen object opgegeven
referentie in dit geval. Een referentie is pas een objectreferentie als dat het geval is
gezegend. Zie perlobj.

Kan methode "%s" niet aanroepen zonder een pakket- of objectreferentie
(F) U gebruikte de syntaxis van een methodeaanroep, maar het slot werd gevuld door de objectreferentie
of pakketnaam bevat een expressie die een gedefinieerde waarde retourneert die geen van beide is
een objectreferentie of een pakketnaam. Iets als dit zal de fout reproduceren:

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

Kan niet bellen mro_isa_changed_in() op een anonieme symbolentafel
(P) Perl raakte in de war over de vraag of een hash een gewone hash of een symbooltabelhash was
wanneer u probeert @ISA-caches bij te werken.

Kan niet bellen mro_method_changed_in() op een anonieme symbolentafel
(F) Een XS-module probeerde "mro_method_changed_in" aan te roepen op een hash die niet was bijgevoegd
naar de symbolentabel.

Kan niet chdiren naar %s
(F) Je hebt "perl -x/foo/bar" genoemd, maar /foe/bar is geen map die u kunt chdir
mogelijk omdat het niet bestaat.

Kan het bestandssysteem van script "%s" niet controleren op nosuid
(P) Om de een of andere reden kun je het bestandssysteem van het script niet controleren op nosuid.

Kan %s niet dwingen tot %s in %s
(F) Bepaalde soorten SV's, in het bijzonder echte symbooltabelitems (typeglobs), kunnen dit niet
gedwongen worden om niet meer te zijn wie ze zijn. Je kunt dus geen dingen zeggen als:

*foe += 1;

Je kunt zeggen

$foe = *foe;
$foe += 1;

maar dan bevat $foo niet langer een klodder.

Kan niet "doorgaan" buiten een wanneer-blok
(F) Je hebt "doorgaan" genoemd, maar je bevindt je niet in een "wanneer"- of "standaard"-blok.

Kan pipe-mailbox niet maken
(P) Een fout die eigen is aan VMS. Het proces heeft te lijden onder uitgeputte quota of andere zaken
problemen met sanitair.

Kan %s niet declareren in "%s"
(F) Alleen scalaire variabelen, array- en hash-variabelen mogen worden gedeclareerd als 'mijn', 'onze' of 'staat'
variabelen. Ze moeten gewone identificatiegegevens als naam hebben.

Kan niet "standaard" zijn buiten een topicalizer
(F) Je hebt een "standaard" blok gebruikt dat zich niet in een "foreach" lus bevindt, noch in een
"gegeven" blok. (Merk op dat deze fout wordt weergegeven bij het verlaten van het "standaard" -blok, dus
u krijgt de foutmelding niet als u expliciet "doorgaan" gebruikt.)

Kan geen interne bewerking uitvoeren: %s is geen gewoon bestand
(S inplace) Je hebt geprobeerd de -i schakel een speciaal bestand in, zoals een bestand in / dev,
een FIFO of een niet-bewerkbare map. Het bestand werd genegeerd.

Kan geen interne bewerking uitvoeren op %s: %s
(S inplace) Het aanmaken van het nieuwe bestand is om de aangegeven reden mislukt.

Kan geen interne bewerking uitvoeren zonder back-up
(F) U gebruikt een systeem zoals MS-DOS dat in de war raakt als u probeert te lezen van een
verwijderd (maar nog steeds geopend) bestand. Je moet "-i.bak" zeggen, of iets dergelijks.

Kan geen interne bewerking uitvoeren: %s zou niet uniek zijn
(S inplace) Uw bestandssysteem ondersteunt geen bestandsnamen die langer zijn dan 14 tekens en
Perl kon geen unieke bestandsnaam maken tijdens inplace-bewerking met de -i schakelaar.
Het bestand werd genegeerd.

Kan %s("%s") niet uitvoeren in een niet-UTF-8 landinstelling; opgelost naar "%s".
(W-landinstelling) U werkt 1) onder ""gebruik landinstelling""; 2) de huidige landinstelling is niet a
UTF-8 één; 3) u hebt geprobeerd de aangegeven case-change-bewerking uit te voeren op het opgegeven
Unicode-teken; en 4) het resultaat van deze operatie zou Unicode en locale combineren
regels die waarschijnlijk in strijd zijn. Het combineren van verschillende regeltypen is verboden, dus de
operatie is niet uitgevoerd; in plaats daarvan is het resultaat de aangegeven waarde, wat de beste is
beschikbaar dat volledig gebruik maakt van Unicode-regels. Dat blijkt vrijwel altijd het geval te zijn
origineel karakter, onveranderd.

Het is over het algemeen een slecht idee om niet-UTF-8-landinstellingen en Unicode te combineren, en dit probleem is er één
van de redenen waarom. Deze waarschuwing wordt gegeven wanneer Unicode-regels dit normaal gesproken zouden veroorzaken
het resultaat van deze bewerking moet een teken bevatten dat zich in het bereik bevindt dat is opgegeven door
de landinstelling, 0..255, en valt daarom onder de regels van de landinstelling, niet die van Unicode.

Als u de locale puur gebruikt vanwege de kenmerken die verband houden met zaken als de
numerieke en tijdnotatie (en niet "LC_CTYPE"), overweeg dan om een ​​beperkte vorm van te gebruiken
het locale pragma (zie "Het "gebruik locale" pragma" in perllocale) zoals
""gebruik locale ':not_characters'"".

Houd er rekening mee dat mislukte bewerkingen voor het wijzigen van hoofdletters zijn uitgevoerd als gevolg van hoofdletterongevoelig "/i"
Het matchen van reguliere expressies zal in deze waarschuwing verschijnen als de bewerking "fc".
(zoals dat is wat de reguliere expressie-engine achter de schermen noemt.)

Kan geen waitpid doen met vlaggen
(F) Deze machine heeft geen van beide wachtend() or wacht4(), dus alleen wachtend() zonder
vlaggen wordt geëmuleerd.

Kan -%s op # niet emuleren! lijn
(F) De #! line specificeert een schakelaar die op dit moment geen zin heeft. Voor
Het zou bijvoorbeeld een beetje dom zijn om a -x op de #! lijn.

Kan %s %s-endian %ss niet op dit platform
(F) De bytevolgorde van uw platform is noch big-endian, noch little-endian, of heeft een
zeer vreemde wijzergrootte. In- en uitpakken van grote of kleine endian drijvende komma
waarden en aanwijzingen zijn mogelijk niet mogelijk. Zie "pack" in perlfunc.

Kan "%s" niet uitvoeren: %s
(W-directeur) A systeem(), exec (), of via een piped open call kan het genoemde programma niet worden uitgevoerd
om de aangegeven reden. Typische redenen zijn onder meer: ​​de machtigingen waren verkeerd op het
bestand, het bestand is niet gevonden in $ENV{PATH}, waarvoor het betreffende uitvoerbare bestand is gecompileerd
een andere architectuur, of de #! regel in een script verwijst naar een tolk die dat niet kan
om soortgelijke redenen worden uitgevoerd. (Of misschien ondersteunt uw systeem #! helemaal niet.)

Kan %s niet uitvoeren
(F) Perl probeerde het aangegeven programma voor je uit te voeren, want dat is wat de
#! lijn gezegd. Als dat niet is wat je wilde, moet je misschien "perl" vermelden op de #!
ergens een lijn.

Kan %s niet uitvoeren
(F) Je hebt de gebruikt -S switch, maar de kopieën van het uit te voeren script zijn te vinden in het PATH
beschikte niet over de juiste machtigingen.

Kan geen opnummer vinden voor "%s"
(F) Er is een string van de vorm "CORE::word" opgegeven voorlopig ontwerp(), maar er is geen ingebouwd
met de naam "woord".

Kan %s karaktereigenschap "%s" niet vinden
(F) U heeft "\p{}" of "\P{}" gebruikt, maar de karaktereigenschap met die naam kan niet
gevonden. Misschien heeft u de naam van het pand verkeerd gespeld? Zie "Eigenschappen toegankelijk
via \p{} en \P{}" in perluniprops voor een volledige lijst van beschikbare functionarissen
eigenschappen.

Kan label %s niet vinden
(F) Je zei dat we naar een label moesten gaan waarvan nergens wordt vermeld dat het voor ons mogelijk is
gaan naar. Zie "ga naar" in perlfunc.

Kan %s niet vinden op PATH
(F) Je hebt de gebruikt -S switch, maar het uit te voeren script kon niet worden gevonden in het PATH.

Kan %s niet vinden op PATH, '.' niet in PAD
(F) Je hebt de gebruikt -S switch, maar het uit te voeren script kon niet worden gevonden in het PATH,
of in ieder geval niet met de juiste rechten. Het script bestaat in de huidige
directory, maar PATH verbiedt het uitvoeren ervan.

Kan stringterminator %s nergens vóór EOF vinden
(F) Perl-tekenreeksen kunnen zich over meerdere regels uitstrekken. Dit bericht betekent dat de sluiting
scheidingsteken is weggelaten. Omdat aanhalingstekens tussen haakjes de nestniveaus tellen, geldt het volgende
mist het laatste haakje:

print q(Het teken '(' begint een commentaar aan de zijkant.);

Als u deze foutmelding krijgt uit een here-document, heeft u mogelijk unseen
witruimte voor of na uw afsluitende tag of er staat mogelijk geen regeleinde erna.
Een goede programmeurseditor zal een manier hebben om je te helpen deze karakters (of het ontbreken ervan) te vinden
van karakters). Zie perlop voor de volledige details over hier-documenten.

Kan Unicode-eigenschapsdefinitie "%s" niet vinden
(F) Mogelijk hebt u geprobeerd "\p" te gebruiken, wat een Unicode-eigenschap betekent (bijvoorbeeld
"\p{Lu}" komt overeen met alle hoofdletters). Als u inderdaad een Unicode-eigenschap wilde gebruiken,
zie "Eigenschappen toegankelijk via \p{} en \P{}" in perluniprops voor een volledige lijst
van beschikbare eigendommen. Als het niet de bedoeling was een Unicode-eigenschap te gebruiken, ontsnap dan aan de
"\p", ofwel door "\\p" (alleen de "\p") of door "\Q\p" (de rest van de string, of totdat
"\E").

Kan niet splitsen: %s
(F) Er is een fatale fout opgetreden tijdens een poging om te splitsen tijdens het openen van een pijpleiding.

Kan niet splitsen. Probeer het over 5 seconden opnieuw
(W-pijp) Een vork in een open pijp mislukte met EAGAIN en zal na vijf uur opnieuw worden geprobeerd
seconden.

Kan filespec niet verkrijgen - verouderde statbuffer?
(S) Een waarschuwing die specifiek is voor VMS. Dit komt door het verschil tussen toegang
controles onder VMS en onder het Unix-model dat Perl aanneemt. Onder VMS zijn er toegangscontroles
gedaan op bestandsnaam, in plaats van op bits in de stat-buffer, zodat ACL's en andere
beschermingsmaatregelen in aanmerking kunnen worden genomen. Helaas gaat Perl ervan uit dat de stat
buffer bevat alle benodigde informatie en geeft deze door, in plaats van de bestandsspecificatie,
aan de toegangscontroleroutine. Er wordt geprobeerd de bestandsspecificatie op te halen met behulp van het apparaat
naam en FID aanwezig in de statbuffer, maar dit werkt alleen als je geen
daaropvolgende oproep aan de CRTL stat () routine, omdat de apparaatnaam wordt overschreven
bij elke oproep. Als deze waarschuwing verschijnt, is het opzoeken van de naam mislukt en is de toegang
de controleroutine gaf het op en keerde FALSE terug, gewoon om conservatief te zijn. (Merk op
toegangscontrole-routine kent de Perl "stat"-operator en bestandstests, dus jij
zou deze waarschuwing nooit moeten zien als reactie op een Perl-commando; het ontstaat alleen als sommige
interne code gaat licht om met stat-buffers.)

Kan de apparaatnaam van het pipe-postvak niet ophalen
(P) Een fout die eigen is aan VMS. Na het maken van een mailbox die als pijp fungeert, kan Perl dat niet meer
haal de naam op voor later gebruik.

Kan de SYSGEN-parameterwaarde voor MAXBUF niet ophalen
(P) Een fout die eigen is aan VMS. Perl vroeg $GETSYI hoe groot je mailbox wilde zijn
buffers te zijn, en kreeg geen antwoord.

Kan niet naar het midden van een foreach-lus gaan
(F) Er werd een "goto"-instructie uitgevoerd om in het midden van een foreach-lus te springen. Jij
kan er vanaf hier niet komen. Zie "ga naar" in perlfunc.

Kan niet uit een pseudoblok "gaan".
(F) Er werd een "goto"-instructie uitgevoerd om uit wat op een blok leek te springen,
behalve dat het geen echt blok is. Dit gebeurt meestal als u probeert eruit te springen
a soort() blok of subroutine, wat een nee-nee is. Zie "ga naar" in perlfunc.

Kan niet naar de subroutine van een eval-%s
(F) De oproep "ga naar subroutine" kan niet worden gebruikt om uit een eval "string" of blok te springen.

Kan niet naar de subroutine gaan vanuit een sorteersub (of soortgelijke callback)
(F) De oproep "goto subroutine" kan niet worden gebruikt om uit de vergelijkingssub voor a te springen
soort(), of van een soortgelijke callback (zoals de verminderen() functie in Lijst::Util).

Kan niet naar een subroutine buiten een subroutine
(F) De zeer magische "ga naar subroutine"-oproep kan slechts één subroutine-oproep vervangen
een andere. Het kan er niet één uit hele stof vervaardigen. Over het algemeen zou dat zo moeten zijn
het toch alleen uit een AUTOLOAD-routine halen. Zie "ga naar" in perlfunc.

Kan signaal CHLD niet negeren, waardoor standaard wordt geforceerd
(W-signaal) Perl heeft gedetecteerd dat het wordt uitgevoerd met het SIGCHLD-signaal (soms
bekend als SIGCLD) uitgeschakeld. Aangezien het uitschakelen van dit signaal de juiste
bepaling van exit-status van onderliggende processen, Perl heeft het signaal teruggezet naar zijn
standaardwaarde. Deze situatie geeft meestal aan dat het bovenliggende programma waaronder:
Perl is mogelijk actief (bijvoorbeeld cron) en is erg onzorgvuldig.

Kan een niet-numerieke proces-ID niet beëindigen
(F) Proces-ID's moeten gehele getallen (met teken) zijn. Het is een fatale fout om dit te proberen
doden() een ongedefinieerde, lege string of anderszins niet-numerieke procesidentificatie.

Kan niet "blijven" buiten een lusblok
(F) Er is een "laatste" instructie uitgevoerd om uit het huidige blok te breken, behalve dat
er is een klein probleem genaamd: er is geen actueel blok. Merk op dat een "als"
of 'else'-blok telt niet als een 'loopish'-blok, net zoals een blok dat niet wordt gegeven
soort(), kaart() or grep(). Meestal kun je de curlies verdubbelen om hetzelfde effect te krijgen
hoewel, omdat de binnenste curlies worden beschouwd als een blok dat één keer doorloopt. Zien
"laatste" in perlfunc.

Kan de anonieme symbooltabel niet lineariseren
(F) Perl probeerde de methoderesolutievolgorde (MRO) van een pakket te berekenen, maar faalde
omdat de pakketopslag geen naam heeft.

Kan '%s' voor module %s niet laden
(F) De module die u probeerde te laden, kon geen dynamische extensie laden. Dit mag ook
betekent dat u uw versie van perl hebt geüpgraded naar een versie die niet compatibel is met uw oude
dynamische extensies (waarvan bekend is dat dit gebeurt tussen de belangrijkste versies van perl), of (meer
waarschijnlijk) dat uw dynamische extensie is gebouwd tegen een oudere versie van de bibliotheek
dat op uw systeem is geïnstalleerd. Mogelijk moet u uw oude dynamiek opnieuw opbouwen
extensies.

Kan lexicale variabele %s niet lokaliseren
(F) U hebt lokaal gebruikt voor een variabelenaam die eerder als lexicaal was gedeclareerd
variabele met behulp van "my" of "state". Dit is niet toegestaan. Als u een
pakketvariabele met dezelfde naam, kwalificeert u deze met de pakketnaam.

Kan niet lokaliseren via een referentie
(F) Je zei zoiets als "local $$ref", wat Perl momenteel niet aankan, omdat
wanneer het de oude waarde gaat herstellen van datgene waarnaar $ref verwijst na de reikwijdte van
the lokaal() klaar is, kan het niet zeker zijn dat $ref nog steeds een referentie zal zijn.

Kan %s niet vinden
(F) U zei dat u een bestand moest "doen" (of "vereisen" of "gebruiken") dat niet kon worden gevonden. Perl
zoekt naar het bestand op alle locaties vermeld in @INC, behalve de bestandsnaam
inclusief het volledige pad naar het bestand. Misschien moet u PERL5LIB of PERL5OPT instellen
omgevingsvariabele om aan te geven waar de extra bibliotheek is, of misschien moet het script dat doen
voeg de bibliotheeknaam toe aan @INC. Of misschien heb je gewoon de naam van het bestand verkeerd gespeld. Zien
"vereisen" in perlfunc en lib.

Kan auto/%s.al niet vinden in @INC
(F) Er is een functie (of methode) aangeroepen in een pakket dat automatisch laden toestaat, maar dat is zo
geen functie om automatisch te laden. De meest waarschijnlijke oorzaken zijn een drukfout in een functie/methode
naam of een fout bij het "AutoSplit" van het bestand, bijvoorbeeld door "make install" uit te voeren.

Kan het laadbare object voor module %s niet vinden in @INC
(F) De module die u hebt geladen, probeert een externe bibliotheek te laden, zoals bijvoorbeeld
foo.zo or bar.dll, maar de DynaLoader-module kon deze bibliotheek niet vinden. Zien
DynaLoader.

Kan objectmethode "%s" niet vinden via pakket "%s"
(F) U heeft een methode correct aangeroepen en deze heeft correct een pakket aangegeven dat functioneert als
een klasse, maar dat pakket definieert die specifieke methode niet, en ook geen enkele daarvan
basisklassen. Zie perlobj.

Kan objectmethode "%s" niet vinden via pakket "%s" (misschien bent u vergeten "%s" te laden?)
(F) Je hebt een methode aangeroepen voor een klasse die niet bestond, en de methode kon dat niet zijn
gevonden in UNIVERSEEL. Dit betekent vaak dat een methode een pakket vereist dat dat niet heeft
geladen.

Kan pakket %s voor @%s::ISA niet vinden
(W-syntaxis) De @ISA-array bevatte de naam van een ander pakket dat dat niet lijkt te zijn
bestaan.

Kan PerlIO%s niet vinden
(F) Je probeerde het te gebruiken Open() een PerlIO-laag die niet bestaat, bijvoorbeeld open(FH,
">:nosuchlayer", "eenbestand").

Kan geen lijsttoewijzing maken aan %ENV op dit systeem
(F) Lijsttoewijzing aan %ENV wordt op sommige systemen, met name VMS, niet ondersteund.

Kan geladen symbolen niet globaal maken op dit platform tijdens het laden van %s
(S) Een module heeft de vlag 0x01 doorgegeven DynaLoader::dl_load_file() om dat aan te vragen
symbolen uit het genoemde bestand worden binnen het proces globaal beschikbaar gesteld, maar dat
functionaliteit is niet beschikbaar op dit platform. Hoewel de module dat waarschijnlijk nog steeds zal doen
werkt, kan dit voorkomen dat de perl-interpreter andere op XS gebaseerde extensies laadt
die rechtstreeks moeten linken naar functies die zijn gedefinieerd in de C- of XS-code in de genoemde
bestand.

Kan %s in %s niet wijzigen
(F) Het is u niet toegestaan ​​om het aangegeven item toe te wijzen, of op een andere manier te proberen het te wijzigen,
zoals bij een automatische verhoging.

Kan niet-bestaande subtekenreeks niet wijzigen
(P) De interne routine die toewijzing doet aan a substr() kreeg een NULL.

Kan subroutine-aanroep zonder waarde niet wijzigen
(F) Subroutines die bedoeld zijn om in de lvalue-context te worden gebruikt, moeten als zodanig worden gedeclareerd. Zien
"Lvalue subroutines" in perlsub.

Kan de verwijzing naar %s in %s toewijzing niet wijzigen
(F) Slechts een beperkt aantal constructies kan worden gebruikt als argument voor een verwijzing
constructor aan de linkerkant van een opdracht, en wat je gebruikte was er niet een van
hen. Zie "Toewijzen aan referenties" in perlref.

Kan de verwijzing naar de gelokaliseerde array tussen haakjes in de lijsttoewijzing niet wijzigen
(F) Toewijzen aan "\local(@array)" of "\(local @array)" wordt niet ondersteund, aangezien dit niet het geval is
duidelijk wat het precies moet doen. Als je @array naar een ander wilt laten verwijzen
array, gebruik dan "\@array = \@other_array". Als je de elementen van @array
aliassen van de scalairen waarnaar aan de rechterkant wordt verwezen, gebruikt u "\(@array) =
@scalaire_refs".

Kan de verwijzing naar de hash tussen haakjes in de lijsttoewijzing niet wijzigen
(F) Toewijzen aan "\(%hash)" wordt niet ondersteund. Als je %hash wilde laten verwijzen naar
een andere hash, gebruik "\%hash = \%other_hash". Als je de elementen wilt maken
%hash in aliassen van de scalairen waarnaar aan de rechterkant wordt verwezen, gebruik een hash-segment:
"\@hash{@keys} = @die_scalar_refs".

Kan niet msgrcv naar alleen-lezen var
(F) Het doel van een msgrcv moet aanpasbaar zijn om als ontvangstbuffer te kunnen worden gebruikt.

Kan niet "volgende" buiten een lusblok
(F) Er is een "next"-instructie uitgevoerd om het huidige blok te herhalen, maar er is geen
huidig ​​blok. Houd er rekening mee dat een "if"- of "else"-blok niet telt als een "loopish"-blok.
net als een blok dat niet wordt gegeven soort(), kaart() or grep(). Meestal kun je het bedrag verdubbelen
curlies om hetzelfde effect te krijgen, omdat de binnenste curlies als een
blok dat één keer wordt herhaald. Zie "volgende" in perlfunc.

Kan %s niet openen: %s
(S inplace) Het impliciet openen van een bestand door gebruik te maken van de "<>" bestandshandle
impliciet onder de opdrachtregelopties "-n" of "-p", of expliciet mislukt voor de
aangegeven reden. Meestal komt dit doordat u geen leesrechten voor een bestand heeft
die u op de opdrachtregel hebt genoemd.

(F) Je hebt geprobeerd perl te bellen met de -e schakelen, maar / Dev / null (of uw operationele
systeemequivalent) kon niet worden geopend.

Kan een referentie niet openen
(W io) U hebt geprobeerd een scalaire referentie te openen voor lezen of schrijven met behulp van de 3-arg
Open() syntaxis:

open FH, '>', $ref;

maar jouw versie van perl is gecompileerd zonder perlio, en deze vorm van open is dat niet
ondersteund.

Kan bidirectionele pijp niet openen
(W pipe) Je hebt geprobeerd "open(CMD, "|cmd|")" te zeggen, wat niet wordt ondersteund. Je kan het proberen
een van de verschillende modules in de Perl-bibliotheek om dit te doen, zoals IPC::Open2.
Als alternatief kunt u de uitvoer van de pipe naar een bestand leiden met behulp van ">", en deze vervolgens inlezen onder a
ander bestandshandvat.

Kan foutbestand %s niet openen als stderr
(F) Een fout die eigen is aan VMS. Perl voert zijn eigen opdrachtregelomleiding uit, en
Kan het bestand dat is opgegeven na '2>' of '2>>' op de opdrachtregel niet openen om te schrijven.

Kan invoerbestand %s niet openen als stdin
(F) Een fout die eigen is aan VMS. Perl voert zijn eigen opdrachtregelomleiding uit, en
Kan het bestand na '<' op de opdrachtregel niet openen om te lezen.

Kan uitvoerbestand %s niet openen als stdout
(F) Een fout die eigen is aan VMS. Perl voert zijn eigen opdrachtregelomleiding uit, en
Kan het bestand dat is opgegeven na '>' of '>>' op de opdrachtregel niet openen om te schrijven.

Kan uitvoerpijp niet openen (naam: %s)
(P) Een fout die eigen is aan VMS. Perl voert zijn eigen opdrachtregelomleiding uit, en
kon de pijp niet openen waarnaar gegevens moesten worden verzonden die bestemd waren voor stdout.

Kan perl-script "%s" niet openen: %s
(F) Het door u opgegeven script kan om de aangegeven reden niet worden geopend.

Als je fouten oplost in een script dat #! gebruikt en normaal gesproken afhankelijk is van $PATH
search zorgt de optie -S ervoor dat perl die zoekopdracht uitvoert, zodat u de
pad of "`welke $scriptnaam`".

Kan CRTL-omgeving niet lezen
(S) Een waarschuwing die eigen is aan VMS. Perl probeerde een element van %ENV uit de CRTL's te lezen
interne omgevingsarray en ontdekte dat de array ontbrak. Je moet bedenken
uit waar uw CRTL zijn omgeving misplaatst of definieert PERL_ENV_TABLES (zie perlvms) dus
die omgeving wordt niet doorzocht.

Kan niet "opnieuw uitvoeren" buiten een lusblok
(F) Er is een "redo"-instructie uitgevoerd om het huidige blok opnieuw te starten, maar er is geen
huidig ​​blok. Houd er rekening mee dat een "if"- of "else"-blok niet telt als een "loopish"-blok.
net als een blok dat niet wordt gegeven soort(), kaart() or grep(). Meestal kun je het bedrag verdubbelen
curlies om hetzelfde effect te krijgen, omdat de binnenste curlies als een
blok dat één keer wordt herhaald. Zie "opnieuw uitvoeren" in perlfunc.

Kan %s niet verwijderen: %s, bestand overslaan
(S inplace) U hebt een inplace-bewerking aangevraagd zonder een back-upbestand te maken. Perl was
kan het originele bestand niet verwijderen om het te vervangen door het gewijzigde bestand. Het bestand was
ongewijzigd gelaten.

Kan %s niet hernoemen naar %s: %s, bestand overslaan
(S inplace) De hernoeming uitgevoerd door de -i De schakelaar is om de een of andere reden mislukt, waarschijnlijk omdat
u heeft geen schrijfrechten voor de map.

Kan invoerpijp (naam: %s) niet heropenen in binaire modus
(P) Een fout die eigen is aan VMS. Perl dacht dat stdin een pijp was en probeerde deze opnieuw te openen
binaire gegevens accepteren. Helaas, het is mislukt.

Kan geen karakter vertegenwoordigen voor Ox%X op dit platform
(F) Er is een harde limiet voor hoe groot een tekencodepunt kan zijn vanwege de
fundamentele eigenschappen van UTF-8, vooral op EBCDIC-platforms. Het opgegeven codepunt
overtreft dat. De enige oplossing is om zo'n groot codepunt niet te gebruiken.

Kan %ENV niet resetten op dit systeem
(F) U riep "reset('E')" of iets dergelijks aan, waarmee werd geprobeerd alle variabelen in het
huidige pakket dat begint met "E". In het hoofdpakket omvat dat %ENV.
Het resetten van %ENV wordt op sommige systemen, met name VMS, niet ondersteund.

Kan methode "%s" niet oplossen, waardoor "%s" in pakket "%s" wordt overbelast
(F)(P) Fout bij het oplossen van overbelasting gespecificeerd door een methodenaam (in tegenstelling tot a
subroutinereferentie): een dergelijke methode kan niet via het pakket worden aangeroepen. Als de naam van de methode
"???", dit is een interne fout.

Kan %s niet teruggeven van lvalu subroutine
(F) Perl heeft een poging gedetecteerd om illegale l-waarden te retourneren (zoals tijdelijk of alleen-lezen)
waarden) uit een subroutine die als lwaarde wordt gebruikt. Dit is niet toegestaan.

Kan niet terugkeren buiten een subroutine
(F) De return-instructie werd uitgevoerd in hoofdlijncode, dat wil zeggen, waar er geen was
subroutine-aanroep om uit terug te keren. Zie perlsub.

Kan %s niet retourneren naar de scalaire context van lvalue
(F) Je hebt geprobeerd een volledige array of hash van een lvalue-subroutine terug te geven, maar jij
riep de subroutine aan op een manier waardoor Perl dacht dat je er maar één wilde retourneren
waarde. Het was waarschijnlijk uw bedoeling om haakjes rond de oproep naar de subroutine te schrijven,
die Perl vertellen dat de aanroep in lijstcontext moet plaatsvinden.

Kan script "%s" niet gebruiken
(P) Om de een of andere reden kan dat niet fstat () het script, ook al heb je het al geopend.
Bizarre.

Kan log van %g niet vastleggen
(F) Voor gewone reële getallen kun je niet de logaritme van een negatief getal nemen of
nul. Er is echter een Math::Complex-pakket dat standaard bij Perl wordt geleverd, als u dat wilt
Ik wil dat echt doen voor de negatieve getallen.

Kan geen sqrt van %g verwerken
(F) Voor gewone reële getallen kun je niet de wortel nemen van een negatief getal.
Er is echter een Math::Complex-pakket dat standaard bij Perl wordt geleverd, als je dat echt wilt
wil dat doen.

Kan actieve subroutine niet ongedaan maken
(F) U kunt de definitie van een routine die momenteel wordt uitgevoerd niet ongedaan maken. Je kunt echter opnieuw definiëren
terwijl deze actief is, en u kunt zelfs de opnieuw gedefinieerde subroutine ongedaan maken terwijl deze nog actief is
routine loopt. Ga figuur.

Kan %s (%d) niet upgraden naar %d
(P) De interne sv_upgrade routine voegt "leden" toe aan een SV, waardoor het een more wordt
gespecialiseerd soort SV. De top verschillende SV-types zijn echter zo gespecialiseerd
ze kunnen niet onderling worden omgezet. Dit bericht geeft aan dat een dergelijke conversie heeft plaatsgevonden
geprobeerd.

Kan '%c' niet gebruiken na -mname
(F) Je hebt geprobeerd perl te bellen met de -m schakel over, maar je typt iets anders dan "=
achter de modulenaam.

Kan geen hash als referentie gebruiken
(F) Je hebt geprobeerd een hash als referentie te gebruiken, zoals in "%foo->{"bar"}" of
"%$ref->{"hallo"}". Versies van perl <= 5.22.0 stonden deze syntaxis toe, maar
niet zou moeten hebben. Dit werd verouderd in perl 5.6.1.

Kan een array niet als referentie gebruiken
(F) U heeft geprobeerd een array als referentie te gebruiken, zoals in "@foo->[23]" of "@$ref->[99]".
Versies van perl <= 5.22.0 stonden deze syntaxis toe, maar zouden dat niet moeten hebben. Dit was
verouderd in perl 5.6.1.

Kan de anonieme symbooltabel niet gebruiken voor het opzoeken van methoden
(F) De interne routine die de methode opzoekt, kreeg een symbooltabel overhandigd
heeft geen naam. Symbooltabellen kunnen bijvoorbeeld anoniem worden door het ongedaan maken van de definitie
stashes: "undef %Sommige::Pakket::".

Kan geen ongedefinieerde waarde gebruiken als %s referentie
(F) Een waarde die als harde referentie of als symbolische referentie wordt gebruikt, moet gedefinieerd zijn
waarde. Dit helpt om enkele verraderlijke fouten te ontmaskeren.

Kan bareword ("%s") niet gebruiken als %s ref terwijl "strikte refs" in gebruik zijn
(F) Alleen harde referenties zijn toegestaan ​​door "strikte refs". Symbolische verwijzingen zijn dat wel
niet toegestaan. Zie perlref.

Kan % niet gebruiken! omdat Errno.pm niet beschikbaar is
(F) De eerste keer dat de "%!" hash wordt gebruikt, laadt perl automatisch de Errno.pm
module. Er wordt verwacht dat de Errno-module de %! hash om symbolische namen voor te geven
$! errno-waarden.

Kan niet zowel '<' als '>' gebruiken na het typen van '%c' in %s
(F) Een type kan niet worden gedwongen om zowel big-endian als little-endian bytevolgorde te hebben
tegelijkertijd, dus deze combinatie van modificatoren is niet toegestaan. Zie "pak" in
perfunc.

Kan 'gedefinieerde(@array)' niet gebruiken (Misschien moet je gewoon de bepaald()?)
(F) bepaald() is niet nuttig voor arrays omdat er wordt gecontroleerd op een ongedefinieerd bestand scalair waarde.
Als je wilt zien of de array leeg is, gebruik dan gewoon "if (@array) { # not empty }" voor
voorbeeld.

Kan 'gedefinieerde(%hash)' niet gebruiken (Misschien moet je gewoon de bepaald()?)
(F) "Defined()" klopt meestal niet met hashes.

Hoewel "gedefinieerde %hash" onwaar is op een gewone, nog niet gebruikte hash, wordt het waar in
verschillende niet voor de hand liggende omstandigheden, waaronder iterators, zwakke referenties, stash-namen,
blijft zelfs waar na "undef %hash". Deze dingen maken "gedefinieerde %hash" eerlijk
in de praktijk nutteloos, dus het genereert nu een fatale fout.

Als u een controle op niet-leeg wilt, plaats deze dan gewoon in de Booleaanse context (zie
"Scalaire waarden" in perldata):

als (%hash) {
# niet leeg
}

Als u "%Foo::Bar::QUUX" had gedefinieerd om te controleren of een dergelijke pakketvariabele bestaat
dan is dat nooit echt betrouwbaar geweest, en is het geen goede manier om naar de
kenmerken van een pakket, of het geladen is, etc.

Kan %s niet gebruiken voor lusvariabele
(P) De parser raakte in de war bij het parseren van een "foreach"-lus.

Kan globale %s niet gebruiken in "%s"
(F) Je hebt geprobeerd een magische variabele als lexicale variabele te declareren. Dit is niet
toegestaan, omdat de magie slechts aan één locatie kan worden gekoppeld (namelijk de global
variabele) en het zou ongelooflijk verwarrend zijn om variabelen in je programma te hebben die dat doen
Het leken magische variabelen, maar waren dat niet.

Kan '%c' niet gebruiken in een groep met een andere bytevolgorde in %s
(F) U heeft geprobeerd een andere bytevolgorde te forceren voor een type dat zich al in a bevindt
groep met een byte-order modifier. Je kunt bijvoorbeeld geen little-endianness opdringen aan a
type dat zich binnen een big-endian-groep bevindt.

Kan "mijn %s" niet gebruiken in sorteervergelijking
(F) De globale variabelen $a en $b zijn gereserveerd voor sorteervergelijkingen. Je noemde
$a of $b in dezelfde regel als de operator <=> of cmp, en de variabele had dat eerder
gedeclareerd als een lexicale variabele. Kwalificeer de sort-variabele met de
pakketnaam, of hernoem de lexicale variabele.

Kan %s ref niet gebruiken als %s ref
(F) U heeft uw referentietypen door elkaar gehaald. U moet een verwijzing naar de referentie verwijderen
soort nodig. U kunt gebruik maken van de referentie() functie om het type referentie te testen, indien
hoeft te zijn.

Kan string ("%s") niet gebruiken als %s ref terwijl "strikte refs" in gebruik zijn
Kan string ("%s"...) niet gebruiken als %s ref terwijl "strict refs" in gebruik is
(F) Je hebt Perl verteld dat hij een string moet derefereren, iets waarvoor "strikte" blokken worden gebruikt
voorkomen dat dit per ongeluk gebeurt. Zie "Symbolische verwijzingen" in perlref. Dit kan zijn
geactiveerd door een "@" of "$" in een tekenreeks met dubbele aanhalingstekens onmiddellijk vóór interpolatie
een variabele, bijvoorbeeld in "user @$twitter_id", die zegt dat de inhoud van moet worden behandeld
$twitter_id als arrayreferentie; gebruik een "\" om een ​​letterlijk "@"-symbool te hebben, gevolgd door
de inhoud van $twitter_id: "gebruiker \@$twitter_id".

Kan subscript niet gebruiken op %s
(F) De compiler probeerde een expressie tussen haakjes te interpreteren als een subscript. Maar naar de
Links van de haakjes stond een uitdrukking die er niet uitzag als een hash of array
referentie, of iets anders dat subscripteerbaar is.

Kan \%c niet gebruiken om $%c in de expressie aan te duiden
(W-syntaxis) In een gewone expressie is backslash een unaire operator die a creëert
verwijzing naar zijn betoog. Het gebruik van een backslash om een ​​terugverwijzing naar a aan te geven
De overeenkomende subtekenreeks is alleen geldig als onderdeel van een reguliere-expressiepatroon. Proberen te doen
dit levert in gewone Perl-code een waarde op die er zo uitziet
SCALAIR(0xdecafé). Gebruik in plaats daarvan het $1-formulier.

Kan een niet-referentie niet verzwakken
(F) Je hebt geprobeerd iets te verzwakken dat geen referentie was. Alleen referenties kunnen
verzwakt zijn.

Kan niet "wanneer" buiten een topicalizer
(F) Je hebt een gebruikt wanneer() blok dat zich niet in een "foreach"-lus noch in een "gegeven" bevindt
blok. (Merk op dat deze fout wordt weergegeven bij het verlaten van het "wanneer"-blok, dus dat gebeurt niet
krijg de foutmelding als de match mislukt, of als je expliciet "doorgaan" gebruikt.)

Kan x= niet naar alleen-lezen waarde
(F) Je hebt geprobeerd een constante waarde (vaak de ongedefinieerde waarde) te herhalen met een
toewijzingsoperator, wat inhoudt dat de waarde zelf wordt gewijzigd. Misschien is dat nodig
kopieer de waarde naar een tijdelijke waarde en herhaal dat.

Teken na "\c" moet afdrukbaar ASCII zijn
(F) In "\cX", X moet een afdrukbaar (niet-controle) ASCII-teken zijn.

Houd er rekening mee dat ASCII-tekens die niet aan controletekens zijn toegewezen, worden afgeraden, en
zal de waarschuwing genereren (indien ingeschakeld) ""\c%c" is duidelijker geschreven als
"%S"".

Karakter in 'C'-formaat verpakt in verpakking
(W-pakket) Je zei

pak("C", $x)

waarbij $x kleiner dan 0 of groter dan 255 is; het "C"-formaat is alleen voor codering
eigen besturingssysteemtekens (ASCII, EBCDIC, enzovoort) en niet voor Unicode
karakters, dus gedroeg Perl zich alsof je het meende

pack("C", $x & 255)

Als u daadwerkelijk Unicode-codepunten wilt inpakken, gebruikt u in plaats daarvan het "U"-formaat.

Karakter in 'c'-formaat verpakt in een verpakking
(W-pakket) Je zei

pak("c", $x)

waarbij $x kleiner is dan -128 of groter dan 127; het "c"-formaat is alleen voor
het coderen van native besturingssysteemtekens (ASCII, EBCDIC, enzovoort) en niet voor
Unicode-tekens, dus Perl gedroeg zich alsof je het meende

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

Als u daadwerkelijk Unicode-codepunten wilt inpakken, gebruikt u in plaats daarvan het "U"-formaat.

Teken in '%c'-formaat verpakt in uitpakken
(W uitpakken) Je hebt zoiets geprobeerd

uitpakken("H", "\x{2a1}")

waarbij het formaat verwacht een byte te verwerken (een teken met een waarde lager dan 256), maar a
In plaats daarvan werd een hogere waarde verstrekt. Perl gebruikt in plaats daarvan de waardemodulus 256, alsof u
hadden verstrekt:

uitpakken("H", "\x{a1}")

Karakter in 'W'-formaat verpakt in verpakking
(W-pakket) Je zei

pack("U0W", $x)

waarbij $x kleiner dan 0 of groter dan 255 is. De "U0"-modus verwacht echter alle
waarden binnen het interval [0, 255] vallen, dus gedroeg Perl zich alsof je bedoelde:

pakket("U0W", $x & 255)

Teken(s) in '%c'-formaat verpakt in pakket
(W-pakket) Je hebt zoiets geprobeerd

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

waarbij het formaat verwacht een reeks bytes te verwerken (teken met een waarde eronder
256), maar sommige karakters hadden een hogere waarde. Perl gebruikt de tekenwaarden
modulus 256 in plaats daarvan, alsof u het volgende had opgegeven:

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

Teken(s) in '%c'-formaat verpakt in uitpakken
(W uitpakken) Je hebt zoiets geprobeerd

uitpakken("s", "\x{1f3}b")

waarbij het formaat verwacht een reeks bytes te verwerken (teken met een waarde eronder
256), maar sommige karakters hadden een hogere waarde. Perl gebruikt de tekenwaarden
modulus 256 in plaats daarvan, alsof u het volgende had opgegeven:

uitpakken("s", "\x{f3}b")

aliasdefinities van charnames mogen geen reeks van meerdere spaties bevatten
(F) U hebt een tekennaam gedefinieerd met meerdere spaties achter elkaar. Wijziging
ze naar enkele ruimtes. Meestal worden deze namen gedefinieerd in de import ":alias".
argument om "charnames te gebruiken", maar deze kunnen worden gedefinieerd door een vertaler die is geïnstalleerd in
$^H{tekennamen}. Zie "AANGEPASTE ALIASES" in charnames.

aliasdefinities van charnames mogen geen witruimte bevatten
(F) U hebt een tekennaam gedefinieerd die eindigde op een spatie. Verwijder de
volgspatie(s). Meestal worden deze namen gedefinieerd in het importargument ":alias".
"gebruik charnames", maar deze kunnen worden gedefinieerd door een vertaler die is geïnstalleerd in
$^H{tekennamen}. Zie "AANGEPASTE ALIASES" in charnames.

\C is verouderd in regex; gemarkeerd door <-- HIER in m/%s/
(D verouderd, regexp) De karakterklasse \C is verouderd en wordt a
compileerfout in een toekomstige release van perl (voorlopig v5.24). Deze constructie
stelt u in staat om een ​​enkele byte te matchen van wat een multi-byte enkel UTF8-teken vormt,
en verbreekt de inkapseling. Momenteel is het ook erg buggy. Als het echt nodig is
de individuele bytes verwerkt, wilt u waarschijnlijk uw string converteren naar één waar
elke onderliggende byte wordt opgeslagen als een teken, met utf8::coderen().

"\c%c" is duidelijker geschreven als "%s"
(W-syntaxis) De "\cX" construct is bedoeld als een manier om niet-afdrukbaar te specificeren
karakters. Je hebt het gebruikt voor een afdrukbaar exemplaar, dat beter eenvoudig is geschreven
zelf, misschien voorafgegaan door een backslash voor niet-woordtekens. Door het te doen zoals jij
did is niet overdraagbaar tussen ASCII- en EBCDIC-platforms.

De context voor het klonen van substitutie is niet geïmplementeerd
(F) Het maken van een nieuwe thread binnen de operator "s///" wordt niet ondersteund.

geslotenir() geprobeerd op ongeldige dirhandle %s
(W io) De dirhandle die je probeerde te sluiten is gesloten of niet echt een dirhandle.
Controleer uw controlestroom.

dichtbij() op ongeopende bestandshandle %s
(W ongeopend) U hebt geprobeerd een bestandshandle te sluiten die nooit is geopend.

Sluitingsprototype gebeld
(F) Als een afsluiting attributen heeft, is de subroutine die aan een attribuuthandler wordt doorgegeven de
prototype dat wordt gekloond wanneer een nieuwe sluiting wordt gemaakt. Deze subroutine kan dat niet zijn
gebeld.

Code ontbreekt na '/'
(F) Je had een (sub-)sjabloon dat eindigt op een '/'. Er moet een ander sjabloon zijn
code na de schuine streep. Zie "pack" in perlfunc.

Codepunt 0x%X is geen Unicode en is mogelijk niet draagbaar
(S non_unicode) U had een codepunt boven het Unicode-maximum van U+10FFFF.

Perl staat toe dat tekenreeksen een superset van Unicode-codepunten bevatten, tot de limiet van
wat kan worden opgeslagen in een geheel getal zonder teken op uw systeem, maar deze worden mogelijk niet geaccepteerd
door andere talen/systemen. Ooit was het in sommige standaarden legaal om code te hebben
wijst tot 0x7FFF_FFFF, maar niet hoger. Codepunten boven 0xFFFF_FFFF vereisen
groter dan een 32-bits woord.

%s: Commando niet gevonden
(A) Je hebt per ongeluk je script doorlopen csh of een andere shell in plaats van Perl.
Controleer de #! regel, of voer uw script zelf handmatig in Perl in. De #! lijn bij
de bovenkant van uw bestand zou er zo uit kunnen zien

#!/usr/bin/perl -w

Compilatie mislukt in require
(F) Perl kan een bestand dat is opgegeven in een "require"-instructie niet compileren. Perl maakt hier gebruik van
generiek bericht wanneer geen van de fouten die werden aangetroffen ernstig genoeg waren om te stoppen
onmiddellijk compileren.

Recursielimiet voor complexe reguliere subexpressies (%d) overschreden
(W regexp) De reguliere expressie-engine gebruikt recursie in complexe situaties waarin
back-tracking is vereist. De recursiediepte is beperkt tot 32766, of misschien minder
architecturen waar de stapel niet willekeurig kan groeien. ("Eenvoudig" en "gemiddeld"
situaties worden afgehandeld zonder recursie en zijn niet aan een limiet onderworpen.) Probeer het
het inkorten van de onderzochte snaar; looping in Perl-code (bijvoorbeeld met "while")
in plaats van in de reguliere expressie-engine; of de reguliere expressie zo herschrijven
dat het eenvoudiger is of minder terugloopt. (Zie perlfaq2 voor informatie over het beheersen van
Normaal Uitdrukkingen.)

aansluiten() op gesloten socket %s
(W gesloten) U heeft geprobeerd verbinding te maken op een gesloten stopcontact. Ben je vergeten de
retourwaarde van uw stopcontact () telefoongesprek? Zie "verbinden" in perlfunc.

Constant(%s): Aanroep van &{$^H{%s}} heeft geen gedefinieerde waarde geretourneerd
(F) De subroutine die is geregistreerd om constante overbelasting af te handelen (zie overbelasting) of a
aangepaste charnames-handler (zie "CUSTOM TRANSLATORS" in charnames) retourneerde een ongedefinieerde
waarde.

Constante(%s): $^H{%s} is niet gedefinieerd
(F) De parser heeft inconsistenties aangetroffen bij een poging een overbelast bestand te definiëren
constante. Misschien bent u vergeten het bijbehorende overbelastingspragma te laden?

Constante is geen %s referentie
(F) Een constante waarde (misschien gedeclareerd met behulp van het pragma 'constante gebruiken') wordt
verwijderd, maar het komt neer op het verkeerde type verwijzing. Het bericht geeft aan:
het type referentie dat werd verwacht. Dit duidt meestal op een syntaxisfout in
dereferentie van de constante waarde. Zie "Constante functies" in perlsub en constant.

Constanten van lexicale variabelen die mogelijk elders zijn gewijzigd, zijn verouderd
(D verouderd) Je schreef zoiets als

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

maar naar $var wordt elders verwezen en kan worden gewijzigd nadat de "sub"-expressie is
geëvalueerd. Ofwel wordt het elders expliciet gewijzigd ("$var = 3") ofwel wordt het doorgegeven
een subroutine of een operator zoals "printf" of "map", die de
variabel.

Traditioneel heeft Perl de waarde van de variabele op dat punt vastgelegd en omgedraaid
de subroutine in een constante die in aanmerking komt voor inlining. In die gevallen waarin de
variabele elders kan worden gewijzigd, verbreekt dit het gedrag van sluitingen, waarbij de
subroutine vangt de variabele zelf op, in plaats van de waarde ervan, zodat toekomstige wijzigingen kunnen optreden
de variabele worden weerspiegeld in de retourwaarde van de subroutine.

Dit gebruik is verouderd, omdat het gedrag waarschijnlijk zal veranderen in een toekomstige versie
van Perl.

Als het de bedoeling was dat de subroutine in aanmerking zou komen voor inlining, zorg er dan voor dat de
naar de variabele wordt nergens anders verwezen, mogelijk door deze te kopiëren:

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

Als u wilt dat deze subroutine een afsluiting is die toekomstige wijzigingen in de
variabele die wordt afgesloten, voeg een expliciete "return" toe:

mijn $var;
$sub = sub () { retourneer $var };

Constante subroutine %s opnieuw gedefinieerd
(W redefine)(S) Je hebt een subroutine opnieuw gedefinieerd waarvoor je eerder in aanmerking kwam
inlining. Zie "Constante functies" in perlsub voor commentaar en oplossingen.

Constante subroutine %s ongedefinieerd
(W overige) U heeft een subroutine gededefinieerd die voorheen in aanmerking kwam voor inlining.
Zie "Constante functies" in perlsub voor commentaar en oplossingen.

Constante(%s) onbekend
(F) De parser heeft inconsistenties gevonden tijdens een poging om een ​​overbelaste . te definiëren
constante, of wanneer u de tekennaam probeert te vinden die is opgegeven in de escape "\N{...}".
Misschien bent u vergeten het bijbehorende overbelastingspragma te laden?

:const is experimenteel
(S experimenteel::const_attr) Het attribuut "const" is experimenteel. Als je wilt
gebruik de functie, schakel de waarschuwing uit met "geen waarschuwingen 'experimenteel::const_attr'",
maar weet dat u daarmee het risico loopt dat uw code in de toekomst kapot gaat
Perl-versie.

:const is niet toegestaan ​​op benoemde subroutines
(F) Het attribuut "const" zorgt ervoor dat een anonieme subroutine wordt uitgevoerd en de waarde ervan
vastgelegd op het moment dat het wordt gekloond. Benoemde subroutines worden niet op deze manier gekloond,
dus het attribuut is voor hen niet logisch.

De kopieermethode heeft geen referentie geretourneerd
(F) De methode die "=" overbelast, bevat fouten. Zie "Copy Constructor" bij overbelasting.

&CORE::%s kan niet rechtstreeks worden aangeroepen
(F) U heeft geprobeerd een subroutine aan te roepen in de naamruimte "CORE::" met de syntaxis &foo of
via een verwijzing. Sommige subroutines in dit pakket kunnen nog niet zo worden aangeroepen,
maar moet als barewords worden genoemd. Zoiets zal werken:

BEGIN { *shove = \&CORE::duwen; }
schuif @array, 1,2,3; # duwt door naar @array

CORE::%s is geen trefwoord
(F) De CORE::-naamruimte is gereserveerd voor Perl-sleutelwoorden.

Beschadigde regexp-opcode %d > %d
(P) Dit is óf een fout in Perl, óf, als u er een gebruikt, uw aangepaste standaard
expressie motor. Als dit laatste niet het geval is, rapporteer het probleem dan via het hulpprogramma perlbug.

beschadigde regexp-aanwijzers
(P) De reguliere expressie-engine raakte in de war door wat de reguliere expressie-compiler gebruikte
gaf het.

beschadigd regexp-programma
(P) De reguliere expressie-engine heeft een regexp-programma doorgegeven zonder geldige magie
nummer.

Corrupte malloc ptr 0x%x op 0x%x
(P) Het malloc-pakket dat bij Perl wordt geleverd, had een interne fout.

Tel na lengte/code bij het uitpakken
(F) U had een uitpaksjabloon die een tekenreeks met een getelde lengte aangeeft, maar u hebt ook:
een expliciete grootte voor de tekenreeks opgegeven. Zie "pak" in perlfunc.

Diepe recursie op anonieme subroutine
Diepe recursie op subroutine "%s"
(W-recursie) Deze subroutine heeft zichzelf 100 keer (direct of indirect) aangeroepen
meer dan het is teruggekeerd. Dit duidt waarschijnlijk op een oneindige recursie, tenzij
je schrijft vreemde benchmarkprogramma's, in welk geval het iets anders aangeeft.

Deze drempelwaarde kan worden gewijzigd van 100 door het bestand perl binair, waarbij de C wordt ingesteld
pre-processor macro "PERL_SUB_DEPTH_WARN" naar de gewenste waarde.

(?(DEFINE)....) staat geen vertakkingen in regex toe; gemarkeerd door <-- HIER in m/%s/
(F) Je hebt iets als "(?(DEFINE)...|..)" gebruikt, wat illegaal is. De meest waarschijnlijke
De oorzaak van deze fout is dat u een haakje hebt weggelaten in het gedeelte "....".

De <-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt.

%s definieert noch pakket, noch VERSIE--versiecontrole mislukt
(F) Je zei zoiets als "gebruik Module 42", maar in het Modulebestand staan ​​geen van beide
pakketdeclaraties noch een $VERSION.

argument verwijderen is index/waarde array-plak, gebruik array-plak
(F) U gebruikte index/waarde array slice-syntaxis (%array[...]) als argument voor "delete".
Je bedoelde waarschijnlijk @array[...] met een @-teken.

verwijder argument is sleutel/waarde hash slice, gebruik hash slice
(F) U hebt de sleutel/waarde-hash slice-syntaxis (%hash{...}) gebruikt als argument voor "verwijderen".
Je bedoelde waarschijnlijk @hash{...} met een @-symbool.

het verwijderargument is geen HASH- of ARRAY-element of -segment
(F) Het argument voor "verwijderen" moet een hash- of array-element zijn, zoals:

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

of een hash- of array-segment, zoals:

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

Scheidingsteken voor dit document is te lang
(F) In een here-documentconstructie zoals "<
hendel. Je moet serieus gestoord zijn om code te schrijven die deze fout activeert.

Afgeschaft gebruik van mijn() in valse voorwaardelijk
(D verouderd) Je hebt een declaratie gebruikt die lijkt op "my $x if 0". Er is een lange-
permanente bug in Perl die ervoor zorgt dat een lexicale variabele niet wordt gewist bij het verlaten van de scope
wanneer de verklaring een valse voorwaardelijke voorwaarde bevat. Sommige mensen hebben hiervan misbruik gemaakt
bug om een ​​soort statische variabele te bereiken. Omdat we van plan zijn deze bug op te lossen, doen we dat niet
wil dat mensen op dit gedrag vertrouwen. Je kunt een soortgelijk statisch effect bereiken door
het declareren van de variabele in een apart blok buiten de functie, bijv

sub f { mijn $x als 0; retourneer $x++ }

wordt

{ mijn $x; sub f { retour $x++ } }

Vanaf perl 5.10.0 kunt u ook "state"-variabelen gebruiken om lexicalen te hebben die
worden slechts één keer geïnitialiseerd (zie functie):

sub f {staat $x; retourneer $x++ }

DESTROY heeft een nieuwe referentie gemaakt naar dood object '%s'
(V) EEN KAPOT MAKEN() methode creëerde een nieuwe verwijzing naar het object dat gewoon is
Vernietigd. Perl is in de war en geeft er de voorkeur aan af te breken in plaats van een bungeling te creëren
referentie.

Heeft geen geldige koptekst geproduceerd
Zie Serverfout.

%s heeft geen echte waarde geretourneerd
(F) Een vereist (of gebruikt) bestand moet een echte waarde retourneren om aan te geven dat het is gecompileerd
correct en voerde de initialisatiecode correct uit. Het is traditioneel om zo'n ding te beëindigen
bestand met een "1;", hoewel elke echte waarde zou volstaan. Zie "vereisen" in perlfunc.

(Bedoelde je in plaats daarvan &%s?)
(W overige) U hebt waarschijnlijk naar een geïmporteerde subroutine &FOO verwezen als $FOO of iets dergelijks.

(Bedoelde je "lokaal" in plaats van "onze"?)
(W misc) Onthoud dat "our" de gedeclareerde globale variabele niet lokaliseert. Jij hebt
verklaarde het opnieuw in dezelfde lexicale reikwijdte, wat overbodig lijkt.

(Bedoelde je $ of @ in plaats van %?)
(W) Je zei waarschijnlijk %hash{$key} terwijl je $hash{$key} of @hash{@keys} bedoelde. Op de
aan de andere kant bedoelde je misschien gewoon %hash en liet je je meeslepen.

Ging dood
(F) Je bent geslaagd sterven () een lege string (het equivalent van "die "") of je noemde het
zonder argumenten en $@ was leeg.

Document bevat geen gegevens
Zie Serverfout.

%s definieert %s::VERSION niet--versiecontrole mislukt
(F) U zei zoiets als "gebruik Module 42", maar de module definieerde geen $VERSION.

'/' telt niet opnieuw
(F) U kunt geen enkele herhalingstelling direct na de '/'-code plaatsen. Zie "pak" in
perfunc.

Weet niet hoe ik de bestandsnaam moet achterhalen
(P) "PerlIO_getname", een perl interne I/O-functie specifiek voor VMS, werd op de een of andere manier aangeroepen
op een ander platform. Dit mag niet gebeuren.

Ik weet niet hoe ik met magie van het type \%o moet omgaan
(P) De interne omgang met magische variabelen is vervloekt.

do_study: geen geheugen
(P) Dit had moeten worden opgemerkt door veiligemalloc() gebruiken.

(Moet u %s vooraf declareren?)
(S-syntaxis) Dit is een goed onderbouwde gok, gemaakt in combinatie met het bericht "%s gevonden
waar de operator verwacht wordt". Het betekent vaak dat er een subroutine- of modulenaam wordt gebruikt
waarnaar wordt verwezen en die nog niet is gedeclareerd. Dit kan komen door bestelproblemen in
uw bestand, of vanwege een ontbrekende instructie "sub", "pakket", "require" of "use".
Als u verwijst naar iets dat nog niet is gedefinieerd, hoeft u dat eigenlijk niet te doen
definieer de subroutine of het pakket vóór de huidige locatie. Je kunt een lege gebruiken
"sub foo;" of "pakket FOO;" om een ​​"voorwaartse" aangifte in te voeren.

dumpen() beter geschreven als KERN::dump()
(W overige) U hebt de verouderde ingebouwde functie "dump()" gebruikt, zonder dat u zich hiervoor volledig kwalificeerde
het als "CORE::dump()". Misschien is het een typefout. Zie "dump" in perlfunc.

dumpen wordt niet ondersteund
(F) Uw machine ondersteunt dump/undump niet.

Dupliceren vrij() genegeerd
(S malloc) Een interne routine gebeld vrij() op iets dat al was vrijgelaten.

Dupliceer de modifier '%c' na '%c' in %s
(W uitpakken) Je hebt dezelfde modifier meer dan eens toegepast na een type in een pakket
sjabloon. Zie "pack" in perlfunc.

elk ter referentie is experimenteel
(S experimenteel::autoderef) "each" met een scalair argument is experimenteel en mag
wijzigen of verwijderen in een toekomstige Perl-versie. Als u het risico wilt nemen om te gebruiken
deze functie, schakelt u eenvoudigweg deze waarschuwing uit:

geen waarschuwingen "experimenteel::autoderef";

elseif moet elsif zijn
(S-syntaxis) Er is geen trefwoord "elseif" in Perl omdat Larry het lelijk vindt. Jouw
code zal worden geïnterpreteerd als een poging om een ​​methode met de naam "elseif" voor de klasse aan te roepen
geretourneerd door het volgende blok. Het is onwaarschijnlijk dat dit is wat je wilt.

Lege \%c{} in regex; gemarkeerd door <-- HIER in m/%s/
(F) "\p" en "\P" worden gebruikt om een ​​benoemde Unicode-eigenschap te introduceren, zoals beschreven in
perlunicode en perlre. U hebt "\p" of "\P" gebruikt in een reguliere expressie zonder
door de eigenschapsnaam op te geven.

invoeren van effectieve %s mislukt
(F) Onder het "gebruik bestandstest" pragma, het wisselen van de echte en effectieve uids of
gids mislukt.

%ENV heeft een alias voor %s
(F) U werkt in de taint-modus en de %ENV-variabele heeft een alias naar een andere
hash, zodat het niet meer de toestand van de programmaomgeving weerspiegelt. Dit is
potentieel onzeker.

Fout bij het converteren van bestandsspecificatie %s
(F) Een fout die eigen is aan VMS. Omdat Perl mogelijk te maken heeft met bestandsspecificaties
in VMS- of Unix-syntaxis converteert het ze naar een enkele vorm wanneer het moet werken
rechtstreeks op hen. Ofwel heeft u een ongeldige bestandsspecificatie doorgegeven aan Perl, ofwel
je hebt een geval gevonden dat de conversieroutines niet aankunnen. Dra.

Eval-groep in onveilige reguliere expressie
(F) Perl heeft besmette gegevens gedetecteerd bij het compileren van een reguliere expressie
bevat de "(?{ ... })" bewering met nulbreedte, wat onveilig is. Zie "(?{code })" in
perlre en perlsec.

Eval-groep niet toegestaan ​​tijdens runtime, gebruik re 'eval' in regex m/%s/
(F) Perl heeft geprobeerd een reguliere expressie te compileren die de "(?{ ... })" nulbreedte bevat
bewering tijdens runtime, zoals het geval zou zijn wanneer het patroon geïnterpoleerde waarden bevat.
Omdat dat een veiligheidsrisico is, is dat niet toegestaan. Als u erop staat, kunt u dat nog steeds doen
dit door gebruik te maken van het "re 'eval'"-pragma of door het patroon expliciet op te bouwen op basis van een
geïnterpoleerde string tijdens runtime en gebruik die in een eval (). Zie "(?{code })" in
perl.

Eval-groep niet toegestaan, gebruik re 'eval' in regex m/%s/
(F) Een reguliere expressie bevatte de "(?{ ... })" bewering met nulbreedte, maar dat
constructie is alleen toegestaan ​​als het pragma "use re 'eval'" van kracht is. Zie "(?{ code
})" in perlre.

EVAL zonder pos-wijziging overschrijdt de limiet in regex; gemarkeerd door <-- HIER in m/%s/
(F) U hebt een patroon gebruikt dat te veel EVAL-oproepen heeft genest zonder tekst te verbruiken.
Herstructureer het patroon zodat tekst wordt verbruikt.

De <-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt.

Buitensporig lange operator <>
(F) De inhoud van een <> operator mag de maximale grootte van een Perl niet overschrijden
identificatie. Als je alleen maar een lange lijst met bestandsnamen probeert samen te voegen, probeer dan de
klodder() operator, of plaats de bestandsnamen in een variabele en glob die.

leidinggevende? Ik ben niet *dat* soort besturingssysteem
(F) De functie "exec" is op sommige systemen, bijvoorbeeld Symbian OS, niet geïmplementeerd. Zien
perlport.

Uitvoering van %s afgebroken vanwege compilatiefouten.
(F) Het laatste samenvattingsbericht wanneer een Perl-compilatie mislukt.

exist-argument is geen HASH- of ARRAY-element of een subroutine
(F) Het argument voor "bestaat" moet een hash- of array-element zijn of een subroutine met een
ampersand, zoals:

$foe{$bar}
$ref->{"susie"}[12]
&doe iets

exist-argument is geen subroutinenaam
(F) Het argument voor "bestaat" voor "bestaat &sub" moet een subroutinenaam zijn, en geen
subroutine oproep. "exists &sub()" zal deze fout genereren.

Eval verlaten via %s
(W exiting) Je verlaat een eval op onconventionele wijze, zoals een goto of een lus
controle verklaring.

Formaat verlaten via %s
(W exiting) U verlaat een format op onconventionele wijze, zoals een goto of a
luscontroleverklaring.

Pseudo-blok verlaten via %s
(W exit) Je verlaat een nogal speciale blokconstructie (zoals een sorteerblok of
subroutine) op onconventionele wijze, zoals een goto of een luscontrole-instructie. Zien
"sorteren" in perlfunc.

Subroutine verlaten via %s
(W exiting) Je verlaat een subroutine op onconventionele wijze, zoals een goto of een
luscontroleverklaring.

Vervanging verlaten via %s
(W verlaat) U verlaat een wissel op onconventionele wijze, zoals door terug te keren,
een goto of een luscontrole-instructie.

Verwacht een nauwe beugel in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je schreef zoiets als

(?13

om een ​​vastleggende groep van de vorm "(?PARNO)", maar liet de ")" weg.

Verwacht '(?flags:(?[...' in regex; gemarkeerd door <-- HIER in m/%s/
(F) De "(?[...])" uitgebreide tekenklasse reguliere expressie-constructie staat alleen toe
karakterklassen (inclusief karakterklasse-escapes zoals "\d"), operators en
haakjes. De enige uitzondering is "(?flags:...)" met minstens één vlag en
precies één "(?[...])" constructie. Hierdoor is een reguliere expressie mogelijk die just bevat
"(?[...])" moet worden geïnterpoleerd. Als u deze foutmelding ziet, is dat waarschijnlijk het geval
een andere "(?...)" constructie binnen je karakterklasse. Zie "Uitgebreide haakjes
Tekenklassen" in perlrecharclass.

Experimentele aliasing via referentie is niet ingeschakeld
(F) Om aliasing via referenties uit te voeren, moet u eerst de functie inschakelen:

geen waarschuwingen "experimenteel::refaliasing";
gebruik de functie "refaliasing";
\$x = \$y;

Experimentele subroutinehandtekeningen niet ingeschakeld
(F) Om subroutinehandtekeningen te gebruiken, moet u deze eerst inschakelen:

geen waarschuwingen "experimenteel::handtekeningen";
gebruik de functie "handtekeningen";
sub foo ($links, $right) { ... }

Experimentele "%s" subs zijn niet ingeschakeld
(F) Om lexicale ondertitels te gebruiken, moet u ze eerst inschakelen:

geen waarschuwingen 'experimenteel::lexical_subs';
gebruik de functie 'lexical_subs';
mijn sub foo { ... }

Expliciete zegen voor '' (ervan uitgaande dat het hoofdpakket is)
(W overige) Je zegent een verwijzing naar een string met lengte nul. Dit heeft het effect van
zegen de verwijzing naar het hoofdpakket. Dit is meestal niet wat je wilt.
Overweeg om een ​​standaard doelpakket aan te bieden, bijvoorbeeld bless($ref, $p || 'MyPackage');

%s: syntaxis van expressie
(A) Je hebt per ongeluk je script doorlopen csh in plaats van Perl. Controleer de #!
regel, of voer uw script zelf handmatig in Perl in.

%s mislukt: oproepwachtrij afgebroken
(F) Er is een niet-opgevangen uitzondering opgetreden tijdens het uitvoeren van een UNITCHECK, CHECK, INIT of END
subroutine. De verwerking van de rest van de wachtrij van dergelijke routines heeft plaatsgevonden
voortijdig beëindigd.

Vals [] bereik "%s" in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp)(F) Een tekenklassebereik moet beginnen en eindigen met een letterlijk teken, niet
een andere tekenklasse zoals "\d" of "[:alpha:]". De "-" in uw valse bereik is
geïnterpreteerd als een letterlijke "-". In een "(?[...])"-constructie is dit eerder een fout
dan een waarschuwing. Overweeg om de "-", "\-" te citeren. De <-- HIER geeft aan waar zich bevindt
de reguliere expressie werd het probleem ontdekt. Zie perlre.

Fatale VMS-fout (status=%d) op %s, regel %d
(P) Een fout die eigen is aan VMS. Er is iets ongewoons gebeurd in een VMS-systeemservice of
RTL-routine; De afsluitstatus van Perl zou meer details moeten opleveren. De bestandsnaam in "at %s"
en het regelnummer in "regel %d" vertelt u welk gedeelte van de Perl-broncode is
bedroefd.

fcntl is niet geïmplementeerd
(F) Uw machine werkt blijkbaar niet fctl(). Wat is dit, een PDP-11 of
iets?

FETCHSIZE heeft een negatieve waarde geretourneerd
(F) Een gebonden array beweert een negatief aantal elementen te hebben, wat niet mogelijk is.

Veld te breed in 'u'-formaat in verpakking
(W-pakket) Elke regel in een uu-gecodeerde string begint met een lengte-indicator die dat niet kan
codeer waarden boven 63. Het heeft dus geen zin om een ​​regellengte groter dan
Dat. Perl gedraagt ​​zich alsof u "u63" als formaat heeft opgegeven.

Bestandshandle %s alleen geopend voor invoer
(W io) U hebt geprobeerd te schrijven op een alleen-lezen bestandshandle. Als je het bedoeld had als lees-
write filehandle, je moest het openen met "+<" of "+>" of "+>>" in plaats van met "<"
of niets. Als u alleen het bestand wilde schrijven, gebruikt u ">" of ">>". Zie "openen" in
perfunc.

Bestandshandle %s alleen geopend voor uitvoer
(W io) Je hebt geprobeerd te lezen van een bestandshandle die alleen was geopend om te schrijven, als je dat bedoelde
om een ​​lees-/schrijfbestandshandle te zijn, moest je deze openen met "+<" of "+>" of "+>>"
in plaats van met ">". Als u alleen uit het bestand wilde lezen, gebruikt u "<". Zie "openen"
in perlfunc. Een andere mogelijkheid is dat u hebt geprobeerd filedescriptor 0 (ook
bekend als STDIN) voor uitvoer (misschien heb je STDIN eerder gesloten?).

Bestandshandle %s is alleen opnieuw geopend als %s voor invoer
(W io) U hebt voor het lezen een bestandshandle geopend die dezelfde bestandshandle-id heeft als STDOUT
of STDERR. Dit is gebeurd omdat u STDOUT of STDERR eerder heeft gesloten.

Filehandle STDIN is alleen opnieuw geopend als %s voor uitvoer
(W io) U hebt voor het schrijven een bestandshandle geopend die dezelfde bestandshandle-id heeft als STDIN.
Dit is gebeurd omdat u STDIN eerder heeft gesloten.

De uiteindelijke $ moet \$ of $name zijn
(F) U moet nu beslissen of de laatste $ in een string letterlijk bedoeld was
dollarteken, of was bedoeld om een ​​variabelenaam te introduceren die toevallig ontbreekt. Dus
je moet de backslash of de naam invoeren.

kudde() op gesloten bestandshandle %s
(W gesloten) De bestandshandle die u probeert te kudde() heeft zichzelf een tijdje gesloten
voor nu. Controleer uw controlestroom. kudde() werkt op filehandles. Ben jij
proberen te bellen kudde() op een dirhandle met dezelfde naam?

Formaat niet beëindigd
(F) Een format moet worden afgesloten met een regel met een enkele punt. Perl is aan het einde gekomen
uw bestand zonder een dergelijke regel te vinden.

Formaat %s opnieuw gedefinieerd
(W herdefiniëren) U hebt een formaat opnieuw gedefinieerd. Om deze waarschuwing te onderdrukken, zegt u

{
geen waarschuwingen 'herdefiniëren';
eval "formaat NAAM =...";
}

Gevonden = in voorwaardelijk, zou == moeten zijn
(W-syntaxis) Je zei

als ($foo = 123)

wanneer je bedoelde

als ($foo == 123)

(of zoiets).

%s gevonden waar operator verwachtte
(S-syntaxis) De Perl-lexer weet of hij een term of een operator kan verwachten. Als het ziet
wat het weet als een term terwijl het een telefoniste verwachtte, geeft het je dit
waarschuwing. Meestal geeft dit aan dat een operator of scheidingsteken is weggelaten, zoals a
puntkomma.

gdbm-winkel heeft %d geretourneerd, fout %d, sleutel "%s"
(S) Een waarschuwing van de GDBM_File-extensie dat een winkel is mislukt.

gethostent niet geïmplementeerd
(F) Uw C-bibliotheek wordt blijkbaar niet geïmplementeerd gethostent(), waarschijnlijk omdat als het
Als dat wel het geval zou zijn, zou het zich moreel verplicht voelen om elke hostnaam op internet terug te geven.

krijgen%snaam() op gesloten socket %s
(W gesloten) U hebt geprobeerd een socket- of peer-socketnaam op een gesloten socket te krijgen. Heb jij
vergeet de retourwaarde van uw stopcontact () bellen?

getpwnam heeft een ongeldige UIC %#o geretourneerd voor gebruiker "%s"
(S) Een waarschuwing die specifiek is voor VMS. De aanroep van "sys$getuai" die ten grondslag ligt aan de "getpwnam"
operator heeft een ongeldige UIC geretourneerd.

krijgtockopt() op gesloten socket %s
(W gesloten) U heeft geprobeerd een stopcontactoptie te krijgen op een gesloten stopcontact. Ben je dat vergeten
controleer de retourwaarde van uw stopcontact () telefoongesprek? Zie "getsockopt" in perlfunc.

gegeven is experimenteel
(S experimenteel::smartmatch) "gegeven" hangt af van smartmatch, wat experimenteel is, dus
het gedrag ervan kan veranderen of zelfs worden verwijderd in een toekomstige release van perl. Zie de
uitleg onder "Experimentele details over gegeven en wanneer" in perlsyn.

Globaal symbool "%s" vereist een expliciete pakketnaam (ben je vergeten "mijn %s" te declareren?)
(F) Je hebt gezegd "gebruik strikt" of "gebruik strikte vars", wat aangeeft dat alle variabelen
moet ofwel lexicaal gedefinieerd zijn (met behulp van "mijn" of "staat"), vooraf aangegeven met behulp van
"onze", of expliciet gekwalificeerd om te zeggen in welk pakket de globale variabele zich bevindt (met behulp van
"::").

glob mislukt (%s)
(S glob) Er is iets misgegaan met de externe programma('s) die gebruikt zijn voor "glob" en
"<*.c>". Meestal betekent dit dat u een 'glob'-patroon hebt opgegeven dat de oorzaak is van de
extern programma mislukt en sluit af met een status die niet nul is. Als het bericht aangeeft
dat de abnormale exit resulteerde in een coredump, kan dit ook betekenen dat uw csh (C
schaal) is gebroken. Als dat zo is, moet u alle csh-gerelateerde variabelen wijzigen in
config.sh: Als je tcsh hebt, zorg er dan voor dat de variabelen ernaar verwijzen alsof het csh is (bijv.
"full_csh='/usr/bin/tcsh'"); maak ze anders allemaal leeg (behalve dat "d_csh"
moet 'undef' zijn), zodat Perl denkt dat csh ontbreekt. In beide gevallen daarna
bewerk config.sh, voer "./Configure -S" uit en herbouw Perl.

Glob is niet beëindigd
(F) De lexer zag een linker hoekbeugel op een plek waar hij een term verwachtte, dus
hij zoekt naar de overeenkomstige haakse beugel en vindt deze niet. Kansen
heb je eerder in de regel enkele benodigde haakjes weggelaten, en bedoelde je echt a
"minder dan".

gmtime(%f) is mislukt
(W overflow) Je hebt "gmtime" gebeld met een getal dat het niet aankan: te groot,
te klein, of NaN. De geretourneerde waarde is "undef".

gmtime(%f) te groot
(W overflow) Je hebt "gmtime" gebeld met een getal dat groter was dan betrouwbaar kan
handle en "gmtime" hebben waarschijnlijk de verkeerde datum geretourneerd. Deze waarschuwing wordt ook geactiveerd
met NaN (de speciale niet-getalwaarde).

gmtime(%f) te klein
(W overflow) Je hebt "gmtime" gebeld met een getal dat kleiner was dan betrouwbaar kan
handle en "gmtime" hebben waarschijnlijk de verkeerde datum geretourneerd.

Er is een fout opgetreden van DosAllocMem
(P) Een fout die eigen is aan OS/2. Waarschijnlijk gebruik je een verouderde versie van
Perl, en dit zou toch niet mogen gebeuren.

goto moet een label hebben
(F) In tegenstelling tot "volgende" of "laatste" mag je niet naar een niet-gespecificeerd veld gaan
bestemming. Zie "ga naar" in perlfunc.

Ga naar ongedefinieerde subroutine%s
(F) U hebt geprobeerd een subroutine aan te roepen met de syntaxis "goto &sub", maar het aangegeven
subroutine is niet gedefinieerd, of als dat wel het geval was, is deze sindsdien ongedefinieerd.

Groepsnaam moet beginnen met een niet-cijferig woordteken in regex; gemarkeerd met <-- HIER in
Mevr/
(F) Groepsnamen moeten de regels voor perl-ID's volgen, wat betekent dat ze moeten beginnen
met een niet-cijferig woordteken. Een veelvoorkomende oorzaak van deze fout is het gebruik van (?&0).
van (?0). Zie perlre.

()-groep begint met een telling
(F) Een ()-groep begon met tellen. Een telling wordt verondersteld iets te volgen:
sjabloonteken of een ()-groep. Zie "pack" in perlfunc.

%s had compilatiefouten.
(F) Het laatste samenvattingsbericht wanneer een "perl -c" mislukt.

Moest %s onverwachts aanmaken
(S intern) Een routine vroeg om een ​​symbool uit een symbolentabel dat dit zou moeten hebben
bestond al, maar om de een of andere reden niet, en moest in geval van nood worden aangemaakt
basis om een ​​kerndump te voorkomen.

%s bevat te veel fouten
(F) De parser heeft na 10 fouten de poging opgegeven om het programma te parseren. Verder
foutmeldingen zouden waarschijnlijk niet informatief zijn.

Het hebben van meer dan één /%c regexp-modifier is verouderd
(D verouderd, regexp) Je hebt de aangegeven patroonmodifier voor reguliere expressies gebruikt op
minstens twee keer in een reeks modificatoren. Het is afgeraden om dit hiermee te doen
bepaalde modifier, om toekomstige uitbreidingen van de Perl-taal mogelijk te maken.

Hexadecimale vlotter: exponentoverloop
(W-overflow) De hexadecimale drijvende komma heeft een grotere exponent dan de drijvende komma
punt ondersteunt.

Hexadecimale vlotter: exponent onderstroom
(W-overflow) De hexadecimale drijvende komma heeft een kleinere exponent dan de drijvende komma
punt ondersteunt.

Hexadecimale float: interne fout (%s)
(F) Er ging iets vreselijk mis bij het omgaan met hexadecimale floats.

Hexadecimale vlotter: mantisse-overloop
(W-overflow) De hexadecimale drijvende-kommagetal-letterlijke had meer bits in de mantisse (de
deel tussen de 0x en de exponent, ook wel de breuk of de significantie genoemd)
dan de drijvende-kommasteunen.

Hexadecimale vlotter: precisieverlies
(W-overloop) De hexadecimale drijvende komma had intern meer cijfers dan mogelijk waren
uitgang. Dit kan worden veroorzaakt door niet-ondersteunde lange dubbele formaten of door 64-bits gehele getallen
niet beschikbaar (nodig om de cijfers op te halen onder sommige configuraties).

Hexadecimale float: niet-ondersteund lang dubbel formaat
(F) U hebt Perl geconfigureerd om lange dubbels te gebruiken, maar de interne onderdelen van de lange dubbel
formaat is onbekend; daarom is de hexadecimale float-uitvoer onmogelijk.

Hexadecimaal getal > 0xffffffff niet-draagbaar
(W draagbaar) Het door u opgegeven hexadecimale getal is groter dan 2**32-1 (4294967295)
en daarom niet overdraagbaar tussen systemen. Zie perlport voor meer informatie over draagbaarheid
zorgen.

Identificatie te lang
(F) Perl beperkt identificatiegegevens (namen voor variabelen, functies, enz.) tot ongeveer 250
tekens voor eenvoudige namen, en iets meer voor samengestelde namen (zoals $A::B).
Je hebt de limieten van Perl overschreden. Toekomstige versies van Perl zullen deze waarschijnlijk elimineren
willekeurige beperkingen.

Negeren van nullengte \N{} in tekenklasse in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp) Benoemde Unicode-teken-escapes ("\N{...}") kunnen een lengte nul retourneren
reeks. Wanneer een dergelijke ontsnapping in een karakterklasse wordt gebruikt, is het gedrag ervan niet goed
bepaald. Controleer of de juiste escape is gebruikt en de juiste charname
behandelaar valt onder de reikwijdte.

Illegaal binair cijfer %s
(F) Je hebt een ander cijfer dan 0 of 1 gebruikt in een binair getal.

Illegaal binair cijfer %s genegeerd
(W-cijfer) Mogelijk hebt u geprobeerd een ander cijfer dan 0 of 1 in een binair getal te gebruiken.
Interpretatie van het binaire getal stopte voor het gewraakte cijfer.

Ongeldig teken na '_' in prototype voor %s: %s
(W illegalproto) Er is een illegaal karakter gevonden in een prototypedeclaratie. De '_'
in een prototype moet worden gevolgd door een ';', waarmee wordt aangegeven dat de rest van de parameters hetzelfde is
optioneel, of een van '@' of '%', aangezien deze twee 0 of meer final accepteren
parameters.

Ongeldig teken \%o (carriage return)
(F) Perl behandelt regeleinden in de programmatekst normaal gesproken op dezelfde manier als alle andere regels
witruimte, wat betekent dat u deze fout nooit zou moeten zien toen Perl werd gebouwd met behulp van
standaard opties. Om de een of andere reden lijkt het erop dat uw versie van Perl is gebouwd
zonder deze steun. Neem contact op met uw Perl-beheerder.

Ongeldig karakter in prototype voor %s: %s
(W illegalproto) Er is een illegaal karakter gevonden in een prototypedeclaratie. Legaal
tekens in prototypes zijn $, @, %, *, ;, [, ], &, \ en +. Misschien was je dat wel
Ik probeerde een handtekening van een subroutine te schrijven, maar schakelde die functie niet eerst in ("use
feature 'handtekeningen'"), dus uw handtekening werd in plaats daarvan geïnterpreteerd als een slecht prototype.

Illegale aangifte van anonieme subroutine
(F) Wanneer u het sleutelwoord "sub" gebruikt om een ​​anonieme subroutine te construeren, moet u dit altijd doen
specificeer een codeblok. Zie perlsub.

Ongeldige aangifte van subroutine %s
(F) Een subroutine is niet correct gedeclareerd. Zie perlsub.

Illegale deling door nul
(F) Je hebt geprobeerd een getal door 0 te delen. Er klopte iets niet in je logica, of
je moet een voorwaardelijke invoeging plaatsen om je te beschermen tegen betekenisloze invoer.

Ongeldig hexadecimaal cijfer %s genegeerd
(W-cijfer) Mogelijk hebt u geprobeerd een ander teken te gebruiken dan 0 - 9 of A - F, a - f in a
hexadecimaal getal. De interpretatie van het hexadecimale getal stopte vóór de
illegaal karakter.

Illegale modulus nul
(F) Je hebt geprobeerd een getal door 0 te delen om de rest te krijgen. De meeste nummers zijn niet geldig
hier vriendelijk op in.

Illegaal aantal bits in vec
(F) Het aantal bits in vec() (het derde argument) moet een macht van twee zijn van 1 tot
32 (of 64, als je platform dat ondersteunt).

Ongeldig octaal cijfer %s
(F) Je hebt een 8 of 9 gebruikt in een octaal getal.

Ongeldig octaal cijfer %s genegeerd
(W-cijfer) Mogelijk hebt u geprobeerd een 8 of 9 in een octaal getal te gebruiken. Interpretatie van
het octale getal stopte vóór de 8 of 9.

Illegaal patroon in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je schreef zoiets als

(?+foe)

De "+" is alleen geldig als deze wordt gevolgd door cijfers, die een vastleggende groep aangeven. Zien
"(?PARNO)".

Illegaal suidscript
(F) Het script dat onder suidperl werd uitgevoerd, was op de een of andere manier illegaal.

Illegale overstap in PERL5OPT: -%c
(X) De omgevingsvariabele PERL5OPT mag alleen worden gebruikt om de volgende schakelaars in te stellen:
-[CDIMUdmtw].

Slecht gevormde CRTL-omgevingswaarde "%s"
(W intern) Een waarschuwing eigen aan VMS. Perl probeerde de interne CRTL te lezen
environ-array, en een element aangetroffen zonder het scheidingsteken "=" dat wordt gebruikt om te scheiden
sleutels van waarden. Het element wordt genegeerd.

Verkeerd opgesteld bericht in prime_env_iter: |%s|
(W intern) Een waarschuwing eigen aan VMS. Perl probeerde een logische naam of CLI . te lezen
symbooldefinitie bij het voorbereiden om over %ENV te herhalen, en zag niet het verwachte
scheidingsteken tussen sleutel en waarde, dus de regel werd genegeerd.

(bij opruimen) %s
(W misc) Dit voorvoegsel geeft meestal aan dat a KAPOT MAKEN() methode verhoogde de aangegeven
uitzondering. Omdat destructors meestal op willekeurige punten door het systeem worden aangeroepen
tijdens de uitvoering, en vaak een groot aantal keren, wordt de waarschuwing slechts één keer gegeven
voor een willekeurig aantal fouten die er anders toe zouden leiden dat hetzelfde bericht
herhaald.

Het mislukken van callbacks van gebruikers die zijn verzonden met de vlag "G_KEEPERR" kan ook leiden tot:
deze waarschuwing. Zie "G_KEEPERR" in perlcall.

Onvolledige expressie binnen '(?[ ])' in regex; gemarkeerd door <-- HIER in m/%s/
(F) Er is een syntaxisfout opgetreden in de tekst "(?[ ])". Dit kan gebeuren als de expressie
binnen het construct helemaal leeg was, of als er te veel of te weinig operanden zijn
voor het aantal exploitanten. Perl is niet slim genoeg om u een nauwkeuriger beeld te geven
indicatie wat er mis is.

Inconsistente hiërarchie tijdens C3-samenvoeging van klasse '%s': samenvoegen mislukt op ouder '%s'
(F) De methoderesolutievolgorde (MRO) van de gegeven klasse is niet C3-consistent, en jij
hebben de C3 MRO voor deze klasse ingeschakeld. Zie de C3-documentatie in mro voor meer informatie
informatie.

In EBCDIC mogen de v-stringcomponenten niet groter zijn dan 2147483647
(F) Een fout die eigen is aan EBCDIC. Intern worden v-strings opgeslagen als Unicode-code
punten, en gecodeerd in EBCDIC als UTF-EBCDIC. De UTF-EBCDIC-codering is beperkt tot
codepunten niet groter dan 2147483647 (0x7FFFFFFF).

Oneindige recursie in regex
(F) U hebt een patroon gebruikt dat naar zichzelf verwijst zonder invoertekst te gebruiken. Jij
moet het patroon controleren om er zeker van te zijn dat recursieve patronen tekst verbruiken of
mislukken.

Initialisatie van statusvariabelen in lijstcontext is momenteel verboden
(F) Momenteel staat de implementatie van "state" alleen de initialisatie van scalair toe
variabelen in scalaire context. Herschrijf "state ($a) = 42" als "state $a = 42" om te wijzigen
van lijst naar scalaire context. Constructies zoals "state (@a) = foo()" zullen dat zijn
ondersteund in een toekomstige perl-release.

%%s[%s] in scalaire context beter geschreven als $%s[%s]
(W-syntaxis) In scalaire context hebt u een array-index/waarde-segment gebruikt (aangegeven met %)
om een ​​enkel element van een array te selecteren. Over het algemeen is het beter om een ​​scalair te vragen
waarde (aangegeven met $). Het verschil is dat $foo[&bar] zich altijd gedraagt ​​als een
scalair, zowel in de waarde die het retourneert als bij het evalueren van het argument, terwijl
%foo[&bar] geeft een lijstcontext aan zijn subscript, wat rare dingen kan doen als
je verwacht maar één subscript. Wanneer aangeroepen in lijstcontext, retourneert het ook de
index (wat &bar retourneert) naast de waarde.

%%s{%s} in scalaire context beter geschreven als $%s{%s}
(W-syntaxis) In scalaire context hebt u een hashsleutel/waarde-segment (aangegeven met %) gebruikt om
selecteer een enkel element van een hash. Over het algemeen is het beter om een ​​scalaire waarde te vragen
(aangegeven met $). Het verschil is dat $foo{&bar} zich altijd gedraagt ​​als een scalair,
zowel in de waarde die het retourneert als bij het evalueren van het argument, terwijl @foo{&bar} en
biedt een lijstcontext aan zijn subscript, wat rare dingen kan doen als je
verwacht slechts één subscript. Wanneer aangeroepen in lijstcontext, retourneert het ook de sleutel in
naast de waarde.

Onveilige afhankelijkheid in %s
(F) Je probeerde iets te doen wat het besmettingsmechanisme niet leuk vond. De bederf
mechanisme wordt ingeschakeld wanneer u setuid of setgid gebruikt, of wanneer u dit opgeeft -T naar
schakel het expliciet in. Het besmettingsmechanisme labelt alle gegevens die rechtstreeks zijn afgeleid
of indirect van de gebruiker, die wordt beschouwd als uw vertrouwen onwaardig. Indien aanwezig
dergelijke gegevens worden gebruikt in een "gevaarlijke" operatie, krijgt u deze foutmelding. Zie perlsec voor
meer informatie.

Onveilige map in %s
(F) Je kunt het niet gebruiken systeem(), exec (), of een doorgesluisd open in een setuid- of setgid-script if
$ENV{PATH} bevat een map die door de hele wereld beschrijfbaar is. Ook moet het PATH
geen relatieve map bevatten. Zie perlsec.

Onveilige $ENV{%s} tijdens het uitvoeren van %s
(F) Je kunt het niet gebruiken systeem(), exec (), of een doorgesluisd open in een setuid- of setgid-script if
een van $ENV{PATH}, $ENV{IFS}, $ENV{CDPATH}, $ENV{ENV}, $ENV{BASH_ENV} of $ENV{TERM}
zijn afgeleid van door de gebruiker aangeleverde (of potentieel aangeleverde) gegevens. Het script moet
stel het pad in naar een bekende waarde, met behulp van betrouwbare gegevens. Zie perlsec.

Onveilige, door de gebruiker gedefinieerde eigenschap %s
(F) Perl heeft besmette gegevens gedetecteerd bij het compileren van een reguliere expressie
bevat een aanroep naar een door de gebruiker gedefinieerde tekeneigenschapsfunctie, dwz "\p{IsFoo}" of
"\p{InFoo}". Zie "Door de gebruiker gedefinieerde tekeneigenschappen" in perlunicode en perlsec.

Overloop van gehele getallen in opmaaktekenreeks voor %s
(F) De indexen en breedtes die zijn opgegeven in de opmaakreeks van "printf()" of "sprintf()"
zijn te groot. De getallen mogen voor u niet groter zijn dan gehele getallen
architectuur.

Geheel getal overloop in %s getal
(S-overflow) Het hexadecimale, octale of binaire getal dat u hebt opgegeven als a
letterlijk of als argument om hex () or okt () is te groot voor uw architectuur, en heeft
omgezet naar een getal met drijvende komma. Op een 32-bits architectuur de grootste
hexadecimaal, octaal of binair getal dat zonder overloop kan worden weergegeven, is 0xFFFFFFFF,
respectievelijk 037777777777 of 0b11111111111111111111111111111111. Merk op dat Perl
promoot transparant alle getallen naar een drijvende-kommaweergave
intern--onderhevig aan verlies van precisie fouten in volgende bewerkingen.

Overloop van gehele getallen in streng
(S overflow) Het getal dat je aan de rand hebt doorgegeven is te groot om in je te passen
de gehele representatie van de architectuur. Het getal is vervangen door het grootste
geheel getal ondersteund (0xFFFFFFFF op 32-bit architecturen). Dit betekent dat u mogelijk krijgt
minder willekeur dan je verwacht, omdat verschillende willekeurige zaden boven het maximale willen
dezelfde reeks willekeurige getallen teruggeven.

Overloop van gehele getallen in versie
Overloop van gehele getallen in versie %d
(W-overflow) Een deel van een versie-initialisatie is te groot voor de grootte van
gehele getallen voor uw architectuur. Dit is geen waarschuwing, want er is geen rationele
reden voor een versie om te proberen een element te gebruiken dat groter is dan normaal gesproken 2**32. Dit is
meestal veroorzaakt door een vreemde wiskundige bewerking als versie te gebruiken, zoals
100 / 9.

Interne ramp in regex; gemarkeerd door <-- HIER in m/%s/
(P) Er is iets ernstig misgegaan in de parser voor reguliere expressies. De <-- HIER wordt weergegeven
waar in de reguliere expressie het probleem werd ontdekt.

Interne inconsistentie bij het volgen van vforks
(S) Een waarschuwing die specifiek is voor VMS. Perl houdt het aantal keren bij dat u gebeld heeft
"fork" en "exec", om te bepalen of de huidige aanroep naar "exec" invloed zou moeten hebben op de
huidige script of een subproces (zie "exec LIST" in perlvms). Op de een of andere manier heeft deze telling dat wel gedaan
worden vervormd, dus Perl doet een gok en behandelt deze "exec" als een verzoek om
beëindig het Perl-script en voer de opgegeven opdracht uit.

intern % p kan conflicteren met toekomstige printf-extensies
(S internal) De interne routine van Perl die de opmaak "printf" en "sprintf" afhandelt
volgt een iets andere reeks regels wanneer deze wordt aangeroepen vanuit C- of XS-code.
In het bijzonder zijn formaten bestaande uit cijfers gevolgd door "p" (bijvoorbeeld "%7p") gereserveerd
voor toekomstig gebruik. Als u deze melding ziet, heeft een XS-module geprobeerd die routine aan te roepen
met zo'n gereserveerd formaat.

Interne urp in regex; gemarkeerd door <-- HIER in m/%s/
(P) Er is iets ernstig misgegaan in de parser voor reguliere expressies. De <-- HIER wordt weergegeven
waar in de reguliere expressie het probleem werd ontdekt.

%s (...) geïnterpreteerd als functie
(W-syntaxis) Je bent in strijd met de regel die zegt dat elke lijstoperator wordt gevolgd door
haakjes veranderen in een functie, met daarin alle argumenten van de lijstoperatoren
de haakjes. Zie "Termen en lijstoperatoren (naar links)" in perlop.

In '(?...)' moeten de '(' en '?' aangrenzend zijn in de regex; gemarkeerd met <-- HIER in m/%s/
(F) De reeks van twee tekens "(?" in deze context in een reguliere expressiepatroon
moet een ondeelbaar token zijn, zonder dat er iets tussen de "(" en de "?" staat),
maar je hebt ze gescheiden met witruimte.

Ongeldig %s-kenmerk: %s
(F) Het aangegeven attribuut voor een subroutine of variabele werd niet herkend door Perl of
door een door de gebruiker geleverde handler. Zie attributen.

Ongeldige %s attributen: %s
(F) De aangegeven attributen voor een subroutine of variabele werden niet herkend door Perl
of door een door de gebruiker geleverde handler. Zie attributen.

Ongeldig teken in aliasdefinitie van charnames; gemarkeerd door <-- HIER in '%s
(F) Je hebt geprobeerd een aangepaste alias voor een karakternaam te maken, met de optie ":alias".
om "charnames te gebruiken" en het opgegeven teken in de aangegeven naam is niet geldig. Zien
"AANGEPASTE ALIASES" in charnames.

Ongeldig \0-teken in %s voor %s: %s\0%s
(W syscalls) Ingesloten \0-tekens in padnamen of andere systeemaanroepargumenten
een waarschuwing geven vanaf 5.20. De delen na de \0 werden voorheen genegeerd door system
noemt.

Ongeldig teken in \N{...}; gemarkeerd door <-- HIER in \N{%s}
(F) Alleen bepaalde tekens zijn geldig voor tekennamen. De aangegeven is dat niet.
Zie "AANGEPASTE ALIASES" in charnames.

Ongeldige conversie in %s: "%s"
(W printf) Perl begrijpt de gegeven formaatconversie niet. Zie "sprintf" in
perfunc.

Ongeldige ontsnapping in de opgegeven codering in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp)(F) De numerieke escape (bijvoorbeeld "\xHH") van waarde < 256 kwam niet overeen
naar één enkel teken door de conversie van de codering gespecificeerd door de
pragma coderen. De ontsnapping werd in plaats daarvan vervangen door VERVANGINGSKARAKTER (U+FFFD),
behalve binnen "(?[ ])", waar het een fatale fout is. De <-- HIER toont de verblijfplaats
in de reguliere expressie werd de ontsnapping ontdekt.

Ongeldig hexadecimaal getal in \N{U+...}
Ongeldig hexadecimaal getal in \N{U+...} in regex; gemarkeerd door <-- HIER in m/%s/
(F) De tekenconstante die wordt weergegeven door "..." is geen geldig hexadecimaal getal.
Of het is leeg, of je hebt geprobeerd een ander teken te gebruiken dan 0 - 9 of A - F, a - f
in een hexadecimaal getal.

Ongeldige modulenaam %s met -%c optie: bevat enkele ':'
(F) Het moduleargument voor perl's -m en -M opdrachtregelopties mogen geen single
dubbele punten in de modulenaam, maar alleen in de argumenten na "=". Met andere woorden,
-MFoo::Bar=:baz is ok, maar -MFoo:Bar=baz is niet.

Ongeldige mro-naam: '%s'
(F) Je hebt geprobeerd "mro::set_mro("classname", "foo")" of "mro 'foo' te gebruiken", waarbij "foo" is
geen geldige methoderesolutieopdracht (MRO). Momenteel worden de enige geldige ondersteund
zijn "dfs" en "c3", tenzij u een module hebt geladen die een MRO-plug-in is. Zie mr en
perlmroapi.

Ongeldig negatief getal (%s) in chr
(W utf8) Je hebt een negatief getal doorgegeven aan "chr". Negatieve getallen zijn niet geldig
tekennummers, dus het retourneert het Unicode-vervangende teken (U+FFFD).

ongeldige optie -D%c, gebruik -D'' om keuzes te zien
(S-foutopsporing) Perl is aangeroepen met ongeldige debuggervlaggen. Bel perl met de -D
optie zonder vlaggen om de lijst met acceptabele waarden te zien. Zie ook "-Dletters" in
perlrun.

Ongeldige kwantor in {,} in regex; gemarkeerd door <-- HIER in m/%s/
(F) Het patroon lijkt op een {min,max}-kwantificator, maar de min of max kunnen dat niet zijn
ontleed als een geldig getal: het heeft voorloopnullen, of het vertegenwoordigt een te grote a
nummer om mee om te gaan. De <-- HIER laat zien waar in de reguliere expressie het probleem zich voordoet
was ontdekt. Zie perlre.

Ongeldig [] bereik "%s" in regex; gemarkeerd door <-- HIER in m/%s/
(F) Het bereik dat is opgegeven in een tekenklasse had een minimumteken dat groter was dan de
maximaal karakter. Eén mogelijkheid is dat je de "{}" uit je einde bent vergeten
"\x{}" - "\x" zonder de accolades kan slechts oplopen tot "ff". De <-- HIER wordt weergegeven
waar in de reguliere expressie het probleem werd ontdekt. Zie perlre.

Ongeldig bereik "%s" in transliteratieoperator
(F) Het bereik dat is opgegeven in de operator tr/// of y/// had een minimumteken groter
dan het maximale karakter. Zie perlop.

Ongeldig scheidingsteken %s in attributenlijst
(F) Er werd iets anders dan een dubbele punt of witruimte gezien tussen de elementen van een
lijst met attributen. Als het vorige attribuut een parameterlijst tussen haakjes had, misschien
die lijst is te vroeg beëindigd. Zie attributen.

Ongeldig scheidingsteken %s in PerlIO-laagspecificatie %s
(W-laag) Wanneer lagen naar het Perl I/O-systeem worden geduwd, iets anders dan een dubbele punt
of er werd witruimte gezien tussen de elementen van een lagenlijst. Als de vorige
attribuut een parameterlijst tussen haakjes had, misschien is die lijst ook beëindigd
binnenkort.

Ongeldig strikt versieformaat (%s)
(F) Een versienummer voldeed niet aan de "strenge" criteria voor versies. Een "streng"
versienummer is een positief decimaal getal (geheel getal of decimale breuk) zonder
machtsverheffen of anders een decimale v-string met een leidend 'v'-teken en at
minimaal drie componenten. De tekst tussen haakjes geeft aan aan welke criteria niet is voldaan.
Zie de versiemodule voor meer details over toegestane versieformaten.

Ongeldig type '%s' in %s
(F) Het opgegeven teken is geen geldig inpak- of uitpaktype. Zie "pack" in perlfunc.

(W) Het opgegeven teken is geen geldig inpak- of uitpaktype, maar was vroeger stil
buiten beschouwing gelaten.

Ongeldig versieformaat (%s)
(F) Een versienummer voldeed niet aan de "laxe" criteria voor versies. Een "laxe" versie
getal is een positief decimaal getal (geheel getal of decimale breuk) zonder
machtsverheffen of anders een decimale v-string met punten. Als de v-string minder dan heeft
drie componenten, het moet een leidend 'v'-teken hebben. Anders is de leidende 'v' dat wel
optioneel. Zowel decimale als decimale versies met stippellijnen kunnen een 'alfa' aan het einde hebben
component gescheiden door een onderstrepingsteken na een breuk of een decimaal met punten
bestanddeel. De tekst tussen haakjes geeft aan aan welke criteria niet is voldaan. Zie de
versiemodule voor meer details over toegestane versieformaten.

Ongeldig versieobject
(F) De interne structuur van het versieobject was ongeldig. Misschien de binnenkant
werden op de een of andere manier rechtstreeks gewijzigd of er werd een willekeurige verwijzing in de
klasse "versie".

In '(*VERB...)' moeten de '(' en '*' aangrenzend zijn in de regex; gemarkeerd met <-- HIER in m/%s/
(F) De reeks van twee tekens "(*" in deze context in een reguliere expressiepatroon
moet een ondeelbaar token zijn, zonder dat er iets tussen de "(" en de "*" staat,
maar jij hebt ze gescheiden.

ioctl is niet geïmplementeerd
(F) Uw machine werkt blijkbaar niet ioctl(), wat behoorlijk vreemd is voor a
machine die C ondersteunt.

ioctl() op ongeopend %s
(W ongeopend) Je hebt het geprobeerd ioctl() op een filehandle die nooit is geopend. Controleer je
controlestroom en aantal argumenten.

IO-lagen (zoals '%s') zijn niet beschikbaar
(F) Uw Perl is niet geconfigureerd voor PerlIO en daarom kunt u IO niet gebruiken
lagen. Om PerlIO te hebben, moet Perl worden geconfigureerd met 'useperlio'.

IO::Socket::atmark niet geïmplementeerd op deze architectuur
(F) Uw machine implementeert de sokkenmerk() functionaliteit, noch als systeem
oproep noch een ioctl-oproep (SIOCATMARK).

'%s' is een onbekend gebonden type in regex; gemarkeerd door <-- HIER in m/%s/
(F) U gebruikte "\b{...}" of "\B{...}" en de "..." is niet bekend bij Perl. De huidige
geldige waarden worden gegeven in "\b{}, \b, \B{}, \B" in perlrebackslash.

"%s" wordt duidelijker eenvoudigweg geschreven als "%s" in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp) (alleen onder "use re 'strict'" of binnen "(?[...])")

Je hebt een personage gespecificeerd dat de gegeven duidelijkere manier heeft om het te schrijven, en dat is het ook
ook draagbaar naar platforms met verschillende tekensets.

$* wordt niet langer ondersteund
(D verouderd, syntaxis) De speciale variabele $*, verouderd in oudere perls, is
verwijderd vanaf 5.10.0 en wordt niet langer ondersteund. In eerdere versies van perl werd het gebruik
van $* heeft het matchen van meerdere regels binnen een tekenreeks in- of uitgeschakeld.

In plaats van $* te gebruiken, zou je de regexp-modifiers "/m" (en misschien "/s") moeten gebruiken. Jij
kan "/m" inschakelen voor een lexicale reikwijdte (zelfs een heel bestand) met "use re '/m'". (Bij ouder
versies: wanneer $* op een echte waarde was ingesteld, gedroegen alle reguliere expressies zich alsof
ze zijn geschreven met "/m".)

$# wordt niet langer ondersteund
(D verouderd, syntaxis) De speciale variabele $#, verouderd in oudere perls, is
verwijderd vanaf 5.10.0 en wordt niet langer ondersteund. Je zou het bestand printf/sprintf moeten gebruiken
functies in plaats daarvan.

'%s' is geen codereferentie
(W overbelasting) Het tweede (vierde, zesde, ...) argument van overbelasting::constant moet
een codereferentie zijn. Ofwel een anonieme subroutine, ofwel een verwijzing naar een subroutine.

'%s' is geen overbelastbaar type
(W-overbelasting) U hebt geprobeerd een constant type te overbelasten waarvan het overbelastingspakket zich niet bewust is.

-ik gebruikte zonder bestandsnamen op de opdrachtregel, lezend vanuit STDIN
(S inplace) De optie "-i" werd doorgegeven op de opdrachtregel, wat aangeeft dat het script
is bedoeld om bestanden ter plaatse te bewerken, maar er zijn geen bestanden opgegeven. Dit is meestal een
fout, aangezien het op zijn plaats bewerken van STDIN geen zin heeft en verwarrend kan zijn omdat
het kan ervoor zorgen dat Perl eruitziet alsof het blijft hangen, terwijl het eigenlijk alleen maar probeert te lezen
STDIN. U moet een bestandsnaam doorgeven om te bewerken, of "-i" uit de opdracht verwijderen
lijn. Zie perlrun voor meer details.

Ongewenste berichten aan het einde van de regexp in regex m/%s/
(P) De parser voor reguliere expressies is in de war.

toetsen op referentie zijn experimenteel
(S experimenteel::autoderef) "sleutels" met een scalair argument zijn experimenteel en mogen
wijzigen of verwijderen in een toekomstige Perl-versie. Als u het risico wilt nemen om te gebruiken
deze functie, schakelt u eenvoudigweg deze waarschuwing uit:

geen waarschuwingen "experimenteel::autoderef";

Label niet gevonden voor "laatste %s"
(F) Je hebt een lus genoemd waar je uit moet breken, maar je bevindt je momenteel niet in een lus met die naam,
zelfs niet als je meetelt vanwaar je bent gebeld. Zie "laatste" in perlfunc.

Label niet gevonden voor "volgende %s"
(F) Je hebt een lus een naam gegeven om door te gaan, maar je bevindt je momenteel niet in een lus met die naam
zelfs als u telt waar u vandaan bent gebeld. Zie "laatste" in perlfunc.

Label niet gevonden voor "opnieuw %s"
(F) Je hebt een lus een naam gegeven om opnieuw te starten, maar je bevindt je momenteel niet in een lus met die naam
zelfs als u telt waar u vandaan bent gebeld. Zie "laatste" in perlfunc.

het verlaten van effectieve %s mislukt
(F) Onder het "gebruik bestandstest" pragma, het wisselen van de echte en effectieve uids of
gids mislukt.

lengte/code na het einde van de string bij het uitpakken
(F) Tijdens het uitpakken was de stringbuffer al opgebruikt bij het uitpakken van lengte/code
combinatie geprobeerd om meer gegevens te verkrijgen. Dit resulteert in een ongedefinieerde waarde voor de
lengte. Zie "pack" in perlfunc.

lengte() gebruikt op %s (bedoelde u "scalair(%s)"?)
(W-syntaxis) Je hebt gebruikt lengte() op een array of een hash terwijl je waarschijnlijk een
telling van de artikelen.

De arraygrootte kan worden verkregen door het volgende te doen:

scalair(@array);

Het aantal items in een hash kan worden verkregen door:

scalair(sleutels %hash);

Lexingcode heeft geprobeerd om niet-Latijn-1-tekens in de Latijns-1-invoer te stoppen
(F) Een extensie probeert tekst in te voegen in de huidige parsering (met behulp van
lex_stuff_pvn of iets dergelijks), maar probeerde een teken in te voegen dat geen deel kon uitmaken van
de huidige invoer. Dit is een inherente valkuil van het vulmechanisme, en één van
de redenen om het te vermijden. Waar het nodig is om op te vullen, is opvullen alleen gewone ASCII
aanbevolen.

Interne fout in lexingcode (%s)
(F) Door een extensie geleverde lexingcode heeft de API van de lexer op een detecteerbare manier geschonden.

luister() op gesloten socket %s
(W gesloten) U hebt geprobeerd te luisteren op een gesloten socket. Ben je vergeten de
retourwaarde van uw stopcontact () telefoongesprek? Zie "luisteren" in perlfunc.

Lijstvorm van doorgesluisd open niet geïmplementeerd
(F) Op sommige platforms, met name Windows, vormt de vorm van 'open' met drie of meer argumenten
ondersteunt geen pipelines, zoals "open($pipe, '|-', @args)". Gebruik het twee-argument
In plaats daarvan "open($pipe, '|prog arg1 arg2...')" formulier.

%s: laadbare bibliotheek en perl-binaire bestanden komen niet overeen (handshake-sleutel %p ontvangen, %p nodig)
(P) Er werd een dynamische laadbibliotheek ".so" of ".dll" in het proces geladen
werd gebouwd tegen een andere build van perl dan de genoemde bibliotheek was samengesteld
tegen. Het opnieuw installeren van de XS-module zal deze fout waarschijnlijk oplossen.

Landinstelling '%s' werkt mogelijk niet goed.%s
(W-landinstelling) U gebruikt de benoemde landinstelling, die niet UTF-8 is, en welke perl
heeft vastgesteld, is niet volledig verenigbaar met wat het aankan. De tweede %s geeft a
reden.

Veruit de meest voorkomende reden is dat de landinstelling tekens bevat die dat wel zijn
vertegenwoordigd door meer dan één byte. De enige landinstellingen die Perl aankan zijn de
UTF-8-landinstellingen. Hoogstwaarschijnlijk is de opgegeven landinstelling niet-UTF-8 voor een Oost-Aziatisch land
taal zoals Chinees of Japans. Als de landinstelling een superset van ASCII is, wordt de ASCII
een deel ervan werkt mogelijk in Perl.

Sommige in wezen verouderde landinstellingen die geen supersets van ASCII zijn, voornamelijk die in ISO
646 of andere 7-bits landinstellingen, zoals ASMO 449, kunnen ook problemen opleveren, afhankelijk van
welke delen van de ASCII-tekenset worden gewijzigd door de landinstelling en ook worden gebruikt
door het programma. Het waarschuwingsbericht vermeldt de bepaalbare conflicterende tekens.

Houd er rekening mee dat niet alle incompatibiliteiten worden gevonden.

Als dit bij u gebeurt, kunt u niet veel doen, behalve overschakelen naar een ander apparaat
locale of gebruik Encode om vanuit de locale naar UTF-8 te vertalen; als dat onuitvoerbaar is,
u bent gewaarschuwd dat sommige dingen kapot kunnen gaan.

Dit bericht wordt één keer uitgevoerd telkens wanneer er binnen het bereik naar een slechte landinstelling wordt overgeschakeld
van "use locale", of bij de eerste mogelijk beïnvloede bewerking als de "use locale"
erft een slechte. Het wordt niet gegenereerd voor bewerkingen vanuit de POSIX-module.

localtime(%f) is mislukt
(W overflow) Je hebt "localtime" aangeroepen met een getal dat het niet aankan: te groot,
te klein, of NaN. De geretourneerde waarde is "undef".

lokale tijd(%f) te groot
(W overflow) Je hebt "localtime" aangeroepen met een getal dat groter was dan betrouwbaar mogelijk is
handle en "localtime" hebben waarschijnlijk de verkeerde datum geretourneerd. Deze waarschuwing is dat ook
geactiveerd met NaN (de speciale niet-getalwaarde).

lokale tijd(%f) te klein
(W overflow) Je hebt "localtime" aangeroepen met een getal dat kleiner was dan mogelijk
betrouwbaar afgehandeld en "localtime" heeft waarschijnlijk de verkeerde datum geretourneerd.

Achteruitkijken langer dan %d niet geïmplementeerd in regex m/%s/
(F) Er is momenteel een limiet aan de lengte van de string die Lookbehind aankan.
Deze beperking kan in een toekomstige release worden versoepeld.

Verloren precisie wanneer %s %f met 1
(W onnauwkeurigheid) De waarde die u met één probeerde te verhogen of te verlagen, is te groot
zodat de onderliggende drijvende-kommaweergave nauwkeurig kan worden opgeslagen, vandaar het doel
van "++" of "--" blijft ongewijzigd. Perl geeft deze waarschuwing omdat dit al is gebeurd
overgeschakeld van gehele getallen naar drijvende komma wanneer waarden te groot zijn voor gehele getallen, en
nu is zelfs drijvende komma onvoldoende. Mogelijk wilt u overstappen op het gebruik van Math::BigInt
uitdrukkelijk.

lstat () op bestandshandle%s
(W io) Je hebt geprobeerd een lstat uit te voeren op een bestandshandle. Wat bedoel je daarmee? lstat ()
heeft alleen zin voor bestandsnamen. (Perl deed een fstat () in plaats daarvan op de filehandle.)

lvalue attribuut %s reeds gedefinieerde subroutine
(W overige) Hoewel attributen.pm dit toestaat, wordt het lvalue-attribuut in- of uitgeschakeld
een Perl-subroutine die al is gedefinieerd, werkt niet altijd correct. Het kan of
doet mogelijk niet wat u wilt, afhankelijk van welke code zich in de subroutine bevindt, met exact
details kunnen veranderen tussen Perl-versies. Doe dit alleen als je echt weet wat
jij bent aan het doen.

lvalue attribuut genegeerd nadat de subroutine is gedefinieerd
(W misc) De declaratieve syntaxis ":lvalue" gebruiken om van een Perl-subroutine een lvalue te maken
subroutine nadat deze is gedefinieerd, is niet toegestaan. Om de subroutine een
lvalue subroutine, voeg het lvalue attribuut toe aan de definitie, of plaats de "sub foo
:lvalue;"-declaratie vóór de definitie.

Zie ook attributen.pm.

Magische lijstconstanten worden niet ondersteund
(F) Je hebt een magische array toegewezen aan een stash-element en vervolgens geprobeerd de . te gebruiken
subroutine van hetzelfde slot. Je vraagt ​​Perl iets te doen wat het niet kan,
details zijn onderhevig aan verandering tussen Perl-versies.

Verkeerd opgemaakt geheel getal in [] in pakket
(F) Tussen de haakjes die een numerieke herhalingstelling omsluiten, zijn alleen cijfers toegestaan.
Zie "pak" in perlfunc.

Verkeerd gevormd geheel getal in [] bij het uitpakken
(F) Tussen de haakjes die een numerieke herhalingstelling omsluiten, zijn alleen cijfers toegestaan.
Zie "pak" in perlfunc.

Verkeerd opgemaakte PERLLIB_PREFIX
(F) Een fout die eigen is aan OS/2. PERLLIB_PREFIX moet de vorm hebben

voorvoegsel1;voorvoegsel2

or
voorvoegsel1 voorvoegsel2

met niet-lege prefix1 en prefix2. Als "prefix1" inderdaad een voorvoegsel is van een ingebouwd
bibliotheekzoekpad, prefix2 wordt vervangen. De fout kan verschijnen als er componenten zijn
niet gevonden of zijn te lang. Zie "PERLLIB_PREFIX" in perlos2.

Verkeerd opgemaakt prototype voor %s: %s
(F) U hebt geprobeerd een functie te gebruiken met een verkeerd ingedeeld prototype. De syntaxis van functie
prototypes krijgen een korte compilatiecontrole op duidelijke fouten, zoals ongeldig
karakters. Er wordt een strengere controle uitgevoerd wanneer de functie wordt aangeroepen. Misschien de
De auteur van de functie probeerde een subroutinehandtekening te schrijven, maar schakelde dat niet in
feature eerst ("gebruik feature 'handtekeningen'"), dus in plaats daarvan werd de handtekening geïnterpreteerd
als een slecht prototype.

Verkeerd opgemaakt UTF-8-teken (%s)
(S utf8)(F) Perl heeft een string gedetecteerd die niet voldeed aan de UTF-8-coderingsregels, zelfs
hoewel er de UTF8-vlag op stond.

Een mogelijke oorzaak is dat je zelf de UTF8-vlag hebt ingesteld voor data waar je aan dacht
in UTF-8 zijn, maar dat was het niet (het waren bijvoorbeeld oudere 8-bits gegevens). Om tegen te waken
Hiervoor kunt u Encode::decode_utf8 gebruiken.

Als u de PerlIO-laag ":encoding(UTF-8)" voor invoer gebruikt, worden ongeldige bytereeksen
netjes afgehandeld, maar als u ":utf8" gebruikt, wordt de vlag ingesteld zonder de
gegevens, mogelijk resulterend in deze foutmelding.

Zie ook "Omgaan met verkeerd opgemaakte gegevens" in Coderen.

Verkeerd opgemaakt UTF-8-teken onmiddellijk na '%s'
(F) U zei "gebruik utf8", maar het programmabestand voldoet niet aan de UTF-8-codering
reglement. Het bericht drukt de correct gecodeerde tekens vlak voor de eerste af
Een slechte. Als "utf8"-waarschuwingen zijn ingeschakeld, wordt er een waarschuwing gegenereerd die meer geeft
details over het type misvorming.

Verkeerd opgemaakte UTF-8 geretourneerd door \N{%s} onmiddellijk na '%s'
(F) De charnames-handler heeft een verkeerd ingedeelde UTF-8 geretourneerd.

Verkeerd opgemaakte UTF-8-tekenreeks in '%c'-indeling bij het uitpakken
(F) U heeft geprobeerd iets uit te pakken dat niet voldeed aan de UTF-8-coderingsregels en
perl kon niet raden hoe hij meer vooruitgang kon boeken.

Misvormde UTF-8-snaar in verpakking
(F) Je hebt geprobeerd iets in te pakken dat niet voldeed aan de UTF-8-coderingsregels en perl
kon niet raden hoe hij meer vooruitgang kon boeken.

Misvormde UTF-8-tekenreeks bij het uitpakken
(F) U heeft geprobeerd iets uit te pakken dat niet voldeed aan de UTF-8-coderingsregels en
perl kon niet raden hoe hij meer vooruitgang kon boeken.

Misvormd UTF-16-surrogaat
(F) Perl dacht dat het UTF-16-gecodeerde tekengegevens aan het lezen was, maar terwijl hij dit deed, Perl
ontmoette een misvormde Unicode-surrogaat.

Verplichte parameter volgt optionele parameter
(F) In een subroutinehandtekening schreef je iets als "$a = undef, $b", waardoor je een
eerdere parameter optioneel en een latere parameter verplicht. Parameters worden vanaf links gevuld
naar rechts, dus het is voor de beller onmogelijk om een ​​eerder nummer over te slaan en een later nummer door te geven
een. Als u wilt doen alsof de parameters van rechts naar links zijn gevuld, declareert u
de meest rechtse optionele en schud vervolgens de parameters in de subroutines
lichaam.

Matcht niet-Unicode-codepunt 0x%X met de Unicode-eigenschap; is mogelijk niet draagbaar
(S non_unicode) Perl staat toe dat strings een superset van Unicode-codepunten bevatten; elk
codepunt kan zo groot zijn als wat kan worden opgeslagen in een geheel getal zonder teken op uw systeem,
maar deze worden mogelijk niet geaccepteerd door andere talen/systemen. Dit bericht verschijnt wanneer
je hebt een string met zo'n codepunt vergeleken met een reguliere expressie
patroon, en het codepunt werd vergeleken met een Unicode-eigenschap, "\p{...}" of
"\P{...}". Unicode-eigenschappen worden alleen gedefinieerd op Unicode-codepunten, dus het resultaat
van deze match is niet gedefinieerd door Unicode, maar Perl (vanaf v5.20) behandelt niet-Unicode
code punten alsof het typische niet-toegewezen Unicode-codes waren, en kwamen overeen met deze
overeenkomstig. Er wordt gespecificeerd of een bepaalde eigenschap al dan niet overeenkomt met deze codepunten
in "Eigenschappen toegankelijk via \p{} en \P{}" in perluniprops.

Dit bericht wordt onderdrukt (tenzij het fataal is gemaakt) als het niet van belang is voor de
resultaten van de wedstrijd, ongeacht of het codepunt Unicode is of niet. Het onroerend goed bijvoorbeeld
"\p{ASCII_Hex_Digit}" kan alleen overeenkomen met de 22 tekens "[0-9A-Fa-f]", dus uiteraard allemaal
andere codepunten, Unicode of niet, komen er niet mee overeen. (En "\P{ASCII_Hex_Digit}" wel
overeenkomen met elk codepunt behalve deze 22.)

Als u dit bericht krijgt, geeft dit aan dat de uitkomst van de wedstrijd waarschijnlijk zo had moeten zijn
het tegenovergestelde van wat er feitelijk gebeurde. Als u denkt dat dit het geval is, kunt u dat wensen
om de categorie "non_unicode"-waarschuwingen fataal te maken; als u het eens bent met de beslissing van Perl,
Mogelijk wilt u deze categorie uitschakelen.

Zie "Beyond Unicode code points" in perlunicode voor meer informatie.

%s komt vele malen overeen met nultekenreeks in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp) Het patroon dat u heeft gespecificeerd zou een oneindige lus zijn als het reguliere
expressie-engine heeft daar niet specifiek op gecontroleerd. De <-- HIER toont de verblijfplaats
in de reguliere expressie werd het probleem ontdekt. Zie perlre.

Maximaal aantal openstaande signalen (%u) overschreden
(F) Perl afgebroken vanwege een te groot aantal in behandeling zijnde signalen. Dit geeft meestal aan
dat uw besturingssysteem te snel signalen probeerde af te leveren (met een zeer hoge
prioriteit), waardoor het perl-proces geen middelen meer krijgt die het nodig heeft om een ​​punt te bereiken
waar het signalen veilig kan verwerken. (Zie "Uitgestelde signalen (veilige signalen)" in
perlipc.)

"%s" kan conflicteren met een toekomstig gereserveerd woord
(W) Deze waarschuwing kan te wijten zijn aan het uitvoeren van een perl5-script via een perl4-interpreter,
vooral als het woord waarvoor wordt gewaarschuwd 'gebruik' of 'mijn' is.

'%' mag niet in het pakket worden gebruikt
(F) U kunt een string niet inpakken door een controlesom op te geven, vanwege het controlesommingsproces
verliest informatie en u kunt niet de andere kant op. Zie "uitpakken" in perlfunc.

Werkwijze voor bewerking %s niet gevonden in pakket %s tijdens zegening
(F) Er is geprobeerd een item in een overbelastingstabel op te geven dat dit niet doet
om te zetten in een geldige subroutine. Zie overbelasting.

Methode %s niet toegestaan
Zie Serverfout.

Het kan een op hol geslagen tekenreeks van meerdere regels %s zijn, beginnend op regel %d
(S) Een advies dat aangeeft dat de vorige fout mogelijk is veroorzaakt door een ontbrekende fout
scheidingsteken op een string of patroon, omdat het uiteindelijk eerder eindigde op de huidige
lijn.

Misplaatst _ in aantal
(W-syntaxis) Een onderstrepingsteken (onderstreepje) in een numerieke constante scheidde niet twee cijfers.

Ontbrekend argument in %s
(W ontbreekt) Je hebt een functie aangeroepen met minder argumenten dan andere argumenten
bijgeleverd aangegeven nodig zou zijn.

Momenteel alleen verzonden wanneer een printf-type formaat meer argumenten vereist dan er waren
geleverd, maar kan in de toekomst worden gebruikt voor andere gevallen waarin we dit statisch kunnen doen
bepaal dat argumenten voor functies ontbreken, bijvoorbeeld voor het "pack" in perlfunc
functie.

Ontbrekend argument voor -%c
(F) Het argument voor de aangegeven opdrachtregelschakelaar moet onmiddellijk daarna volgen
de schakelaar, zonder tussenliggende spaties.

Ontbrekende accolades op \N{}
Ontbrekende accolades op \N{} in regex; gemarkeerd door <-- HIER in m/%s/
(F) Verkeerde syntaxis van letternaam "\N{charname}" binnen dubbele aanhalingstekens
context. Dit kan ook gebeuren als er een spatie (of commentaar) staat tussen de "\N" en
de "{" in een regex met de modifier "/x". Deze modifier verandert niets aan de
vereiste dat de accolade onmiddellijk de "\N" volgt.

Ontbrekende accolades op \o{}
(F) Een "\o" moet onmiddellijk worden gevolgd door een "{" in de context van dubbele aanhalingstekens.

Ontbrekende komma na het eerste argument voor de functie %s
(F) Hoewel u met bepaalde functies een bestandshandle of een "indirect object" kunt specificeren
vóór de argumentenlijst: dit is er niet een van.

Ontbrekend commando in doorgesluisd open
(W-pipe) Je hebt de constructie "open(FH, "| command")" of "open(FH, "command |")" gebruikt,
maar de opdracht ontbrak of was leeg.

Ontbrekende controletekennaam in \c
(F) Een tekenreeks tussen dubbele aanhalingstekens eindigde met "\c", zonder het vereiste controleteken
naam.

Ontbrekende ']' in prototype voor %s: %s
(W illegalproto) Een groepering is begonnen met "[" maar nooit afgesloten met "]".

Ontbrekende naam in "%s sub"
(F) De syntaxis voor subroutines met een lexicaal bereik vereist dat ze een naam hebben met
waarin ze te vinden zijn.

Ontbrekende $ in lusvariabele
(F) Blijkbaar heb je aan het programmeren geweest csh te veel. Variabelen zijn dat altijd
vermeld met de $ in Perl, in tegenstelling tot in de shells, waar het van één regel tot kan variëren
de volgende.

(Ontbrekende operator vóór %s?)
(S-syntaxis) Dit is een goed onderbouwde gok, gemaakt in combinatie met het bericht "%s gevonden
waar operator verwacht". Vaak is de ontbrekende operator een komma.

Ontbrekend of ongedefinieerd argument dat moet worden vereist
(F) U hebt geprobeerd require aan te roepen zonder argument of met een ongedefinieerde waarde als
argument. Require verwacht een pakketnaam of een bestandsspecificatie als
argument. Zie "vereisen" in perlfunc.

Ontbrekende rechter accolade op \%c{} in regex; gemarkeerd door <-- HIER in m/%s/
(F) Ontbrekende rechter accolade in "\x{...}", "\p{...}", "\P{...}" of "\N{...}".

Ontbrekende rechter accolade op \N{}
Ontbrekende rechter accolade op \N{} of niet-ontsnapte linker accolade na \N
(F) "\N" heeft twee betekenissen.

Bij de traditionele wordt het gevolgd door een naam tussen accolades, wat 'de' betekent
teken (of reeks tekens) gegeven door die naam. Dus "\N{ASTERISK}" is
een andere manier om "*" te schrijven, geldig in zowel tekenreeksen tussen dubbele aanhalingstekens als in reguliere expressies
patronen. In patronen heeft het niet de betekenis die een "*" zonder escapecodes heeft.

Vanaf Perl 5.12.0 kan "\N" ook (alleen) een extra betekenis hebben in patronen,
namelijk om overeen te komen met een niet-nieuwregelteken. (Dit is een afkorting voor "[^\n]", en net als "." maar
wordt niet beïnvloed door de regex-modifier "/s".)

Dit kan tot enkele onduidelijkheden leiden. Wanneer "\N" niet onmiddellijk wordt gevolgd door een linker
accolade, neemt Perl de betekenis "[^\n]" aan. Ook als de accolades een geldige kwantificator vormen
zoals "\N{3}" of "\N{5,}", gaat Perl ervan uit dat dit betekent dat het overeenkomt met de opgegeven hoeveelheid
van niet-nieuwe regels (in deze voorbeelden respectievelijk 3 en 5 of meer). In alle andere
In het geval dat er een "\N{" en een overeenkomende "}" is, gaat Perl ervan uit dat het een karakternaam is
gewenst.

Als er echter geen overeenkomende "}" is, weet Perl niet of deze per ongeluk is weggelaten.
of als "[^\n]{" gewenst was, en deze fout veroorzaakt. Als je de eerste bedoelde, voeg dan de
rechter beugel; als je het laatste bedoelde, ontsnap dan aan de accolade met een backslash, zoals zo:
"\N\{"

Rechter gekrulde of vierkante haak ontbreekt
(F) De lexer telde meer gekrulde of vierkante haakjes bij het openen dan bij het sluiten. Als een
algemene regel: je zult merken dat het ontbreekt in de buurt van de plaats waar je het laatst hebt bewerkt.

(Ontbreekt de puntkomma op de vorige regel?)
(S-syntaxis) Dit is een goed onderbouwde gok, gemaakt in combinatie met het bericht "%s gevonden
waar operator verwacht". Plaats niet automatisch een puntkomma op de vorige regel
alleen maar omdat je dit bericht hebt gezien.

Er is geprobeerd een alleen-lezen waarde te wijzigen
(F) Je hebt geprobeerd, direct of indirect, de waarde van een constante te veranderen. Dat deed je niet,
Probeer natuurlijk "2 = 1", want de compiler vangt dat op. Maar een gemakkelijke manier om het te doen
hetzelfde is:

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

Een andere manier is om toe te wijzen aan a substr() dat is aan het einde van de reeks.

Nog een andere manier is om een ​​"foreach"-lus toe te wijzen VAR wanneer VAR is een alias van een constante
in de blik LIJST:

$ x = 1;
foreach mijn $n ($x, 2) {
$n *= 2; # wijzigt de $x, maar mislukt bij poging daartoe
} # wijzig de 2

Er is geprobeerd een niet-maakbare arraywaarde te wijzigen, %s
(F) Je hebt geprobeerd een arraywaarde te laten ontstaan, en het subscript was dat ook
waarschijnlijk negatief, zelfs vanaf het einde van de array naar achteren geteld.

Er is geprobeerd een niet-maakbare hashwaarde te wijzigen, %s
(P) Je hebt geprobeerd een hashwaarde te laten ontstaan, maar deze kon niet worden gecreëerd
om een ​​of andere bijzondere reden.

De modulenaam moet constant zijn
(F) Alleen een kale modulenaam is toegestaan ​​als eerste argument voor een "gebruik".

Modulenaam vereist met optie -%c
(F) De opties "-M" of "-m" zeggen dat Perl een module moet laden, maar u hebt dit weggelaten
de naam van de module. Raadpleeg perlrun voor volledige details over "-M" en "-m".

Er zijn meer dan één argument voor '%s' geopend
(F) De functie "openen" is gevraagd om meerdere bestanden te openen. Dit kan gebeuren als u
proberen een pijp te openen naar een commando dat een lijst met argumenten nodig heeft, maar dat is het geval
vergeten een doorgesluisde open modus op te geven. Zie "openen" in perlfunc voor details.

mprotect voor COW-reeks %p %u mislukt met %d
(S) Je hebt perl gecompileerd -DPERL_DEBUG_READONLY_COW (zie "Kopiëren bij schrijven" in
perlguts), maar een gedeelde tekenreeksbuffer kon niet alleen-lezen worden gemaakt.

mprotect voor %p %u mislukt met %d
(S) Je hebt perl gecompileerd -DPERL_DEBUG_READONLY_OPS (zie perlhacktips), maar een op
boom kan niet alleen-lezen worden gemaakt.

mprotect RW voor COW-reeks %p %u mislukt met %d
(S) Je hebt perl gecompileerd -DPERL_DEBUG_READONLY_COW (zie "Kopiëren bij schrijven" in
perlguts), maar een alleen-lezen gedeelde tekenreeksbuffer kon niet veranderlijk worden gemaakt.

mprotect RW voor %p %u mislukt met %d
(S) Je hebt perl gecompileerd -DPERL_DEBUG_READONLY_OPS (zie perlhacktips), maar een lees-
alleen op tree kon niet veranderlijk worden gemaakt voordat de ops waren vrijgegeven.

msg%s niet geïmplementeerd
(F) U heeft geen System V-bericht-IPC op uw systeem.

Multidimensionale syntaxis %s wordt niet ondersteund
(W-syntaxis) Multidimensionale arrays worden niet geschreven als $foo[1,2,3]. Ze zijn geschreven
zoals $foo[1][2][3], zoals in C.

'/' moet bij het uitpakken een numeriek type volgen
(F) U had een uitpaksjabloon die een '/' bevatte, maar deze volgde op sommige niet
uitpakspecificatie die een numerieke waarde oplevert. Zie "pack" in perlfunc.

"mijn sub" nog niet geïmplementeerd
(F) Subroutines met lexicale scope zijn nog niet geïmplementeerd. Probeer dat nog niet.

"mijn" subroutine %s mag niet in een pakket voorkomen
(F) Subroutines met een lexicaal bereik zitten niet in een pakket, dus het heeft geen zin om het te proberen
om er een aan te geven met een pakketkwalificatie op de voorkant.

"mijn %s" gebruikt in soortvergelijking
(W-syntaxis) De pakketvariabelen $a en $b worden gebruikt voor sorteervergelijkingen. Je hebt $a gebruikt
of $b in als operand voor de operator "<=>" of "cmp" in een sorteervergelijkingsblok,
en de variabele was eerder gedeclareerd als een lexicale variabele. Ofwel kwalificeert u de
sorteer de variabele met de pakketnaam, of hernoem de lexicale variabele.

"mijn" variabele %s mag niet in een pakket voorkomen
(F) Variabelen met een lexicaal bereik zitten niet in een pakket, dus het heeft geen zin om dat te proberen
declareer er een met een pakketkwalificatie op de voorkant. Gebruik lokaal() als je wilt
lokaliseer een pakketvariabele.

Naam "%s::%s" slechts één keer gebruikt: mogelijke typefout
(W eenmaal) Typografische fouten verschijnen vaak als unieke namen van variabelen. Als je een
goede reden om een ​​unieke naam te hebben, en noem deze dan op de een of andere manier opnieuw om te onderdrukken
de boodschap. Hiervoor wordt tevens de "onze" verklaring verstrekt.

OPMERKING: Deze waarschuwing detecteert pakketsymbolen die slechts één keer zijn gebruikt. Dit betekent
Lexicale variabelen zullen deze waarschuwing nooit activeren. Het betekent ook dat alle
pakketvariabelen $c, @c, %c, evenals *c, &c, sub c{}, c() en c (de bestandshandle
of formaat) worden als hetzelfde beschouwd; als een programma $c slechts één keer gebruikt, maar ook elke
van de anderen zal deze waarschuwing niet worden geactiveerd. Symbolen die beginnen met een onderstrepingsteken
en symbolen die speciale identificatiegegevens gebruiken (qv perldata) zijn vrijgesteld van deze waarschuwing.

Er zijn precies 3 octale cijfers nodig in regex; gemarkeerd door <-- HIER in m/%s/
(F) Binnen "(?[ ])" moeten alle constanten die als octaal worden geïnterpreteerd, precies uit 3 cijfers bestaan
lang. Dit helpt bij het onderkennen van enkele onduidelijkheden. Als uw constante te kort is, voegt u voorloop toe
nullen, zoals

(?[ [ \078 ] ]) # Syntaxisfout!
(?[ [\0078] ]) # Werkt
(?[ [ \007 8 ] ]) # Duidelijker

Het maximale aantal dat deze constructie kan uitdrukken is "\777". Als je een grotere nodig hebt,
je moet in plaats daarvan \o{} gebruiken. Als je twee afzonderlijke dingen bedoelde, moet je ze scheiden
hen:

(?[ [ \7776 ] ]) # Syntaxisfout!
(?[ [ \o{7776} ] ]) # Eén betekenis
(?[ [\777 6 ] ]) # Een andere betekenis
(?[ [ \777 \006 ] ]) # Nog eentje

Negatief '/'-aantal bij uitpakken
(F) De lengtetelling verkregen uit een lengte/code-uitpakbewerking was negatief. Zien
"pak" in perlfunc.

Negatieve lengte
(F) U hebt geprobeerd een lees-/schrijf-/verzend-/recv-bewerking uit te voeren met een bufferlengte die kleiner is
dan 0. Dit is moeilijk voor te stellen.

Negatieve verschuiving naar vec in lvalue-context
(F) Wanneer "vec" wordt aangeroepen in een lvalue-context, moet het tweede argument groter zijn
dan of gelijk aan nul.

Negatieve herhalingstellingen doen niets
(W numeriek) U heeft minder dan 0 keer geprobeerd de herhalingsoperator "x" uit te voeren
heeft geen zin.

Geneste kwantoren in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je kunt een kwantor niet kwantificeren zonder tussenliggende haakjes. Dus dingen als
** of +* of ?* zijn illegaal. De <-- HIER toont de locatie in de reguliere expressie
het probleem werd ontdekt.

Merk op dat de minimaal overeenkomende kwantoren, "*?", "+?", en "??" lijken genest te zijn
kwantificatoren, maar zijn dat niet. Zie perlre.

%s nooit geïntroduceerd
(S intern) Het symbool in kwestie is gedeclareerd, maar viel op de een of andere manier eerder buiten het bereik
het zou mogelijk gebruikt kunnen zijn.

next::method/next::can/misschien::next::method kan de insluitende methode niet vinden
(F) "next::method" moet worden aangeroepen binnen de context van een echte methode in een real
pakket, en het kon een dergelijke context niet vinden. Zie mr.

\N in een tekenklasse moet een benoemd teken zijn: \N{...} in regex; gemarkeerd met <-- HIER in
Mevr/
(F) De nieuwe (vanaf Perl 5.12) betekenis van "\N" als "[^\n]" is niet geldig tussen haakjes
karakterklasse, om dezelfde reden als "." in een karakterklasse verliest zijn
bijzonderheid: het past bij bijna alles, wat waarschijnlijk niet is wat je wilt.

\N{} in omgekeerde tekenklasse of als bereikeindpunt is beperkt tot één teken in
regex; gemarkeerd door <-- HIER in m/%s/
(F) Benoemde Unicode-teken-escapes ("\N{...}") kunnen een reeks van meerdere tekens retourneren.
Hoewel een karakterklasse verondersteld wordt slechts één teken van invoer te matchen, kan perl
zal het hele ding correct matchen, behalve wanneer de klasse wordt omgekeerd ("[^...]"), of
de ontsnapping is het begin- of laatste eindpunt van een bereik. Het wiskundig logische
gedrag voor wat overeenkomt bij het omkeren is heel anders dan wat mensen verwachten, dus
we hebben besloten het te verbieden. Eveneens onduidelijk is wat er moet worden gegenereerd wanneer het
"\N{...}" wordt gebruikt als een van de eindpunten van het bereik, zoals in

[\x{41}-\N{ARABISCHE VOLGORDE JA MET HAMZA BOVEN MET AE}]

Wat hier wordt bedoeld is onduidelijk, aangezien de ontsnapping "\N{...}" een reeks codepunten is,
dus dit is een fout gemaakt.

\N{NAME} moet worden opgelost door de lexer in regex; gemarkeerd door <-- HIER in m/%s/
(F) Bij het compileren van een regex-patroon was er een onopgelost benoemd teken of een reeks
tegengekomen. Dit kan op verschillende manieren gebeuren waarbij de lexer wordt omzeild, zoals
met behulp van context met enkele aanhalingstekens, of een extra backslash in dubbele aanhalingstekens:

$re = '\N{SPATIE}'; # Fout!
$re = "\\N{SPATIE}"; # Fout!
/$opnieuw/;

Gebruik in plaats daarvan dubbele aanhalingstekens met een enkele backslash:

$re = "\N{SPATIE}"; # OK
/$opnieuw/;

De lexer kan ook worden omzeild door het patroon uit kleinere componenten te maken:

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

Het is geen goed idee om een ​​constructie op deze manier in het midden te splitsen, en dat werkt niet
hier. Gebruik in plaats daarvan de bovenstaande oplossing.

Ten slotte kan het bericht ook verschijnen onder de regex-modifier "/x" wanneer de "\N" is
gescheiden door spaties van de "{", verwijder in dat geval de spaties.

/\N {SPATIE}/x; # Fout!
/\N{SPATIE}/x; # OK

Geen %s toegestaan ​​tijdens het uitvoeren van setuid
(F) Bepaalde bewerkingen worden als te onveilig beschouwd voor een setuid- of setgid-script
zelfs mogen proberen. Over het algemeen zal er een andere manier zijn om wat te doen
u wilt dat het, als het niet veilig is, op zijn minst beveiligbaar is. Zie perlsec.

NO-BREAK SPACE in de definitie van een charnames-alias is verouderd
(D verouderd) U hebt een tekennaam gedefinieerd die een spatie zonder onderbreking bevat
karakter. Verander het in een gewone ruimte. Meestal worden deze namen gedefinieerd in de
":alias" importargument om "charnames te gebruiken", maar deze kunnen door een vertaler worden gedefinieerd
geïnstalleerd in $^H{charnames}. Zie "AANGEPASTE ALIASES" in charnames.

Geen code gespecificeerd voor -%c
(F) Perls -e en -E opdrachtregelopties vereisen een argument. Als u een
leeg programma, geef de lege string door als een afzonderlijk argument of voer een programma uit
bestaande uit een enkele 0 of 1:

perl -e ""
perl-e0
perl-e1

Geen komma toegestaan ​​na %s
(F) Een lijstoperator die een filehandle of "indirect object" heeft, mag deze niet hebben
een komma tussen dat en de volgende argumenten. Anders zou het gewoon een andere zijn
van de argumenten.

Een mogelijke oorzaak hiervoor is dat u verwachtte een constante in uw bestand te hebben geïmporteerd
naamruimte mee . or importeren terwijl een dergelijke import niet heeft plaatsgevonden, kan dit bijvoorbeeld wel het geval zijn
het kan zijn dat uw besturingssysteem die specifieke constante niet ondersteunt. Hopelijk
je hebt wel een expliciete importlijst gebruikt voor de constanten die je verwacht te zien; alsjeblieft zie
"gebruik" in perlfunc en "importeren" in perlfunc. Terwijl een expliciete importlijst dat wel zou doen
Ik heb deze fout waarschijnlijk al eerder opgemerkt, maar dat verhelpt natuurlijk niet het feit dat
uw besturingssysteem ondersteunt die constante nog steeds niet. Misschien zit er een typefout in
de constanten van de symboolimportlijst van . or importeren of in de constante naam at
de regel waar deze fout werd geactiveerd?

Geen opdracht waarnaar op de opdrachtregel moet worden gesluisd
(F) Een fout die eigen is aan VMS. Perl verzorgt zijn eigen omleiding naar de opdrachtregel, en
vond een '|' aan het einde van de opdrachtregel, zodat het niet weet waar u naartoe wilt pipen
de uitvoer van deze opdracht.

Geen DB::DB-routine gedefinieerd
(F) De momenteel uitgevoerde code is gecompileerd met de -d overstappen, maar om een ​​of andere reden
de huidige debugger (bijv perl5db.pl of een "Devel::" module) heeft geen routine gedefinieerd
dat aan het begin van elke verklaring moet worden opgeroepen.

Geen dbm op deze machine
(P) Dit wordt geteld als een interne fout, omdat elke machine dbm zou moeten leveren
tegenwoordig, omdat Perl met SDBM wordt geleverd. Zie SDBM_File.

Geen DB::subroutine gedefinieerd
(F) De momenteel uitgevoerde code is gecompileerd met de -d overstappen, maar om een ​​of andere reden
de huidige debugger (bijv perl5db.pl of een "Devel::" module) heeft geen "DB::sub" gedefinieerd
routine die moet worden aangeroepen aan het begin van elke gewone subroutineoproep.

Er is geen map opgegeven voor -I
(F) De -I opdrachtregeloptie vereist een mapnaam als onderdeel van de dezelfde argument.
Te gebruiken -IlibBijvoorbeeld. -I lib zal niet werken.

Geen foutbestand na 2> of 2>> op de opdrachtregel
(F) Een fout die eigen is aan VMS. Perl verzorgt zijn eigen omleiding naar de opdrachtregel, en
heb een '2>' of een '2>>' gevonden op de opdrachtregel, maar kan de naam van het bestand niet vinden
waarmee gegevens moeten worden geschreven die bestemd zijn voor stderr.

Geen groepseindteken '%c' gevonden in sjabloon
(F) Een in- of uitpaksjabloon heeft een opening '(' of '[' zonder dat deze overeenkomt
tegenhanger. Zie "pack" in perlfunc.

Geen invoerbestand na < op de opdrachtregel
(F) Een fout die eigen is aan VMS. Perl verzorgt zijn eigen omleiding naar de opdrachtregel, en
heb een '<' gevonden op de opdrachtregel, maar kan de naam van het bestand waar naartoe moet niet worden gevonden
gegevens lezen voor stdin.

Geen volgende::methode '%s' gevonden voor %s
(F) "next::method" heeft geen verdere exemplaren van deze methodenaam gevonden in de overige
pakketten van de MRO van deze klasse. Als je niet wilt dat er een uitzondering wordt gegenereerd, gebruik dan
"misschien::volgende::methode" of "volgende::kan". Zie mr.

Niet-eindige herhalingstellingen doen niets
(W numeriek) U heeft geprobeerd de herhalingsoperator "x" "Inf" (of "-Inf") of uit te voeren
"NaN"-tijden, wat niet logisch is.

Niet-hexadecimaal karakter in regex; gemarkeerd door <-- HIER in m/%s/
(F) In een reguliere expressie was er een niet-hexadecimaal teken waar een hexadecimaal teken stond
verwacht, zoals

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

Niet-octaal karakter in regex; gemarkeerd door <-- HIER in m/%s/
(F) In een reguliere expressie was er een niet-octaal karakter, terwijl er wel een octaal karakter was
verwacht, zoals

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

Niet-octaal teken '%c'. Opgelost als "%s"
(W-cijfer) Bij het ontleden van een octale numerieke constante kwam er onverwacht een teken voor
tegengekomen dat niet octaal is. De resulterende waarde is zoals aangegeven.

"Nee" is niet toegestaan ​​in de uitdrukking
(F) Het sleutelwoord "no" wordt herkend en uitgevoerd tijdens het compileren, en retourneert geen bruikbaar resultaat
waarde. Zie perlmod.

Niet-string doorgegeven als bitmasker
(W misc) Er is een getal doorgegeven als bitmaskerargument selecteer(). Gebruik de vec()
functie om de bestandsdescriptor-bitmaskers voor select te construeren. Zie "selecteren" in
perfunc.

Geen uitvoerbestand na > op de opdrachtregel
(F) Een fout die eigen is aan VMS. Perl verzorgt zijn eigen omleiding naar de opdrachtregel, en
vond een eenzame '>' aan het einde van de opdrachtregel, dus hij weet niet waar je wilde
om stdout om te leiden.

Geen uitvoerbestand na > of >> op de opdrachtregel
(F) Een fout die eigen is aan VMS. Perl verzorgt zijn eigen omleiding naar de opdrachtregel, en
heb een '>' of een '>>' gevonden op de opdrachtregel, maar kan de naam van het bestand niet vinden
waarmee gegevens moeten worden geschreven die bestemd zijn voor stdout.

Geen pakketnaam toegestaan ​​voor variabele %s in "onze"
(F) Volledig gekwalificeerde variabelenamen zijn niet toegestaan ​​in "onze" declaraties, omdat dat
heeft volgens de bestaande regels weinig zin. Een dergelijke syntaxis is gereserveerd voor de toekomst
extensies.

Geen Perl-script gevonden in invoer
(F) Je hebt "perl -x" aangeroepen, maar er is geen regel gevonden in het bestand dat begint met #! En
met het woord "perl".

Geen setregid beschikbaar
(F) Configure heeft niets gevonden dat lijkt op de setregid() bel voor uw systeem.

Geen setreuid beschikbaar
(F) Configure heeft niets gevonden dat lijkt op de setreuid() bel voor uw systeem.

Een dergelijke klasse %s bestaat niet
(F) U heeft een klassekwalificatie opgegeven in een "mijn", "onze" of "staat"-verklaring, maar dit
klasse bestaat op dit moment niet in uw programma.

Een dergelijk klasseveld "%s" bestaat niet in variabele %s van het type %s
(F) U hebt geprobeerd toegang te krijgen tot een sleutel uit een hash via de aangegeven getypte variabele, maar
die sleutel is niet toegestaan ​​door het pakket van hetzelfde type. Het aangegeven pakket heeft
beperkte de set toegestane sleutels met behulp van de velden pragma.

Geen dergelijke hook: %s
(F) U heeft een signaalhook opgegeven die niet door Perl werd herkend. Momenteel Perl
accepteert "__DIE__" en "__WARN__" als geldige signaalhaken.

Zo'n pijp is niet open
(P) Een fout die eigen is aan VMS. De interne routine mijn_pclose() probeerde een leiding af te sluiten
die niet geopend was. Dit had eerder opgemerkt moeten worden als poging tot sluiting
een ongeopende bestandshandle.

Geen dergelijk signaal: SIG%s
(W-signaal) U heeft een signaalnaam opgegeven als subscript voor %SIG, die niet werd herkend.
Zeg "kill -l" in uw shell om de geldige signaalnamen op uw systeem te zien.

Geen CODE-referentie
(F) Perl probeerde een verwijzing naar een codewaarde (dat wil zeggen een subroutine) te evalueren,
maar vond in plaats daarvan een verwijzing naar iets anders. U kunt gebruik maken van de referentie() functie naar
Ontdek wat voor soort ref het werkelijk was. Zie ook perlref.

Geen GLOB-referentie
(F) Perl probeerde een verwijzing naar een "typeglob" (dat wil zeggen een symbooltabel) te evalueren
invoer die lijkt op *foo), maar in plaats daarvan een verwijzing naar iets anders heeft gevonden. Jij kan
Gebruik de referentie() functie om erachter te komen wat voor soort ref het werkelijk was. Zie perlref.

Geen HASH-referentie
(F) Perl probeerde een verwijzing naar een hashwaarde te evalueren, maar vond een verwijzing naar
iets anders in plaats daarvan. U kunt gebruik maken van de referentie() functie om erachter te komen wat voor soort ref
het was echt zo. Zie perlref.

Geen ARRAY-referentie
(F) Perl probeerde een verwijzing naar een arraywaarde te evalueren, maar vond een verwijzing
naar iets anders in plaats daarvan. U kunt gebruik maken van de referentie() functie om erachter te komen wat voor soort
ref, het was echt zo. Zie perlref.

Geen ongezegende ARRAY-referentie
(F) Je hebt een verwijzing naar een gezegende array doorgegeven aan "push", "shift" of een andere array
functie. Deze accepteren alleen ongezegende arrayreferenties of arrays die expliciet beginnen
met "@".

Geen SCALAR-referentie
(F) Perl probeerde een verwijzing naar een scalaire waarde te evalueren, maar vond een verwijzing
naar iets anders in plaats daarvan. U kunt gebruik maken van de referentie() functie om erachter te komen wat voor soort
ref, het was echt zo. Zie perlref.

Geen subroutinereferentie
(F) Perl probeerde een verwijzing naar een codewaarde (dat wil zeggen een subroutine) te evalueren,
maar vond in plaats daarvan een verwijzing naar iets anders. U kunt gebruik maken van de referentie() functie naar
Ontdek wat voor soort ref het werkelijk was. Zie ook perlref.

Geen subroutinereferentie in de overbelastingstabel
(F) Er is geprobeerd een item in een overbelastingstabel op te geven dat dit niet doet
op de een of andere manier naar een geldige subroutine verwijzen. Zie overbelasting.

Niet genoeg argumenten voor %s
(F) De functie vereist meer argumenten dan u hebt opgegeven.

Niet genoeg formaatargumenten
(W-syntaxis) Een formaat specificeerde meer afbeeldingsvelden dan de volgende regel leverde. Zien
perlform.

%s: niet gevonden
(A) U hebt uw script per ongeluk via de Bourne-shell uitgevoerd in plaats van via Perl.
Controleer de #! regel, of voer uw script zelf handmatig in Perl in.

(?[...]) niet geldig in landinstelling in regex; gemarkeerd door <-- HIER in m/%s/
(F) "(?[...])" kan niet worden gebruikt binnen het bereik van een "gebruik locale" of met een "/l"
modifier voor reguliere expressies, omdat daarvoor uitstel nodig is om het
berekening van wat het zou moeten evalueren, en het is alleen regex-compilatietijd.

geen UTC-offset-informatie; ervan uitgaande dat de lokale tijd UTC is
(S) Een waarschuwing die eigen is aan VMS. Perl kon de lokale tijdzone-offset niet vinden, dus
het gaat ervan uit dat de lokale systeemtijd gelijk is aan UTC. Als dit niet het geval is, definieert u de
logische naam SYS$TIMEZONE_DIFFERENTIEEL om te vertalen naar het aantal seconden dat
moeten worden toegevoegd aan UTC om de lokale tijd te krijgen.

NULL OP IN UITVOERING
(S-foutopsporing) Er is een interne routine gebeld rennen() met een nul-opcode-aanwijzer.

Nulbeeld in formulierlijn
(F) Het eerste argument voor de vormlijn moet een geldige beeldspecificatie zijn. Het
bleek leeg te zijn, wat waarschijnlijk betekent dat u er een niet-geïnitialiseerde waarde aan heeft opgegeven.
Zie perlform.

Nul realloc
(P) Er is geprobeerd om NULL opnieuw toe te wijzen.

NULL regexp-argument
(P) De interne patroonmatchingroutines hebben het enorm verpest.

NULL regexp-parameter
(P) De routines voor het matchen van interne patronen zijn uit de kast.

Nummer te lang
(F) Perl beperkt de weergave van decimale getallen in programma's tot ongeveer 250
karakters. Je hebt die lengte overschreden. Toekomstige versies van Perl zullen dat waarschijnlijk ook doen
elimineer deze willekeurige beperking. Probeer in de tussentijd de wetenschappelijke notatie te gebruiken
(bijvoorbeeld "1e6" in plaats van "1_000_000").

Nummer zonder cijfers
(F) Perl zocht naar een getal, maar vond niets dat op een getal leek. Dit
gebeurt bijvoorbeeld met "\o{}", zonder nummer tussen de accolades.

Octaal nummer > 037777777777 niet-draagbaar
(W draagbaar) Het door u opgegeven octale getal is groter dan 2**32-1 (4294967295) en
daarom niet overdraagbaar tussen systemen. Zie perlport voor meer informatie over draagbaarheid
zorgen.

Oneven naam/waarde-argument voor subroutine
(F) Een subroutine die een slurpy hash-parameter in zijn handtekening gebruikt, heeft een oneven nummer ontvangen
van argumenten om de hash te vullen. Het vereist dat de argumenten worden gecombineerd met de
hetzelfde aantal sleutels als waarden. De beller van de subroutine is vermoedelijk in gebreke is gebleven.
Onhandig genoeg wordt deze fout gerapporteerd op de locatie van de subroutine, en niet
die van de beller.

Oneven aantal argumenten voor overload::constant
(W overload) De aanroep van overload::constant bevatte een oneven aantal argumenten. De
argumenten moeten in paren komen.

Oneven aantal elementen in anonieme hash
(W misc) Je hebt een oneven aantal elementen opgegeven om een ​​hash te initialiseren, wat oneven is,
omdat hashes in sleutel/waarde-paren voorkomen.

Oneven aantal elementen in hash-toewijzing
(W misc) Je hebt een oneven aantal elementen opgegeven om een ​​hash te initialiseren, wat oneven is,
omdat hashes in sleutel/waarde-paren voorkomen.

Offset buiten string
(F)(W-laag) U hebt geprobeerd een lees-/schrijf-/verzend-/recv/zoek-bewerking uit te voeren met een offset
buiten de buffer wijzend. Dit is moeilijk voor te stellen. De enige uitzonderingen daarop
Dit betekent dat er geen opvulling zal plaatsvinden wanneer u voorbij het einde van de string gaat
ofwel "sysread()" bij het zoeken naar voorbij het einde van een scalaire waarde die is geopend voor I/O
(in afwachting van toekomstige leesbewerkingen en om het gedrag met echte bestanden te imiteren).

%s() op ongeopend %s
(W ongeopend) Er is geprobeerd een I/O-bewerking uit te voeren op een bestandshandle die nooit is geopend
begonnen. Je moet een doen Open(), een sysopen()Of een stopcontact () bel, of bel a
constructor uit het FileHandle-pakket.

-%s op ongeopende bestandshandle %s
(W ongeopend) U hebt geprobeerd een bestandstestoperator aan te roepen op een bestandshandle die niet geopend is.
Controleer uw controlestroom. Zie ook "-X" in perlfunc.

oeps: oepsAV
(S intern) Een interne waarschuwing dat de grammatica verpest is.

oeps: oepsHV
(S intern) Een interne waarschuwing dat de grammatica verpest is.

Dirhandle %s ook als bestand openen
(D io, verouderd) Je gebruikte Open() om een ​​bestandshandle aan een symbool te koppelen (glob of
scalair) dat al een dirhandle bevat. Hoewel legaal, kan dit idioom uw
code verwarrend en is verouderd.

Bestandshandle %s ook openen als map
(D io, verouderd) Je gebruikte opendir() om een ​​dirhandle aan een symbool te koppelen (glob of
scalair) dat al een filehandle bevat. Hoewel legaal, kan dit idioom uw
code verwarrend en is verouderd.

Operand zonder voorgaande operator in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je schreef zoiets als

(?[ \p{Cijfer} \p{Thais} ])

Er zijn twee operanden, maar geen operator die aangeeft hoe je ze wilt combineren.

Bewerking "%s": geen methode gevonden, %s
(F) Er is geprobeerd een overbelaste operatie uit te voeren waarvoor geen handler aanwezig was
bepaald. Hoewel sommige handlers automatisch kunnen worden gegenereerd in termen van andere handlers, is er
is geen standaardhandler voor welke bewerking dan ook, tenzij de "fallback"-overbelastingssleutel dat wel is
opgegeven als waar. Zie overbelasting.

Bewerking "%s" retourneert het argument voor niet-Unicode-codepunt 0x%X
(S non_unicode) U hebt een bewerking uitgevoerd waarvoor Unicode-regels vereist zijn op een codepunt
dat is niet in Unicode, dus wat het zou moeten doen, is niet gedefinieerd. Perl heeft ervoor gekozen om te hebben
het doet niets en waarschuwt u.

Als de getoonde bewerking "ToFold" is, betekent dit dat hoofdletterongevoelige overeenkomsten in a
reguliere expressie werd uitgevoerd op het codepunt.

Als u weet wat u doet, kunt u deze waarschuwing uitschakelen met 'geen waarschuwingen'
'non_unicode';".

Bewerking "%s" retourneert het argument voor UTF-16 surrogaat U+%X
(S surrogaat) U hebt een bewerking uitgevoerd waarvoor Unicode-regels vereist zijn op een Unicode
surrogaat. Unicode fronst het gebruik van surrogaten voor alles behalve het opslaan van tekenreeksen
in UTF-16, maar er worden (met tegenzin) regels gedefinieerd voor de surrogaten, en dat moeten ze doen
niets voor deze operatie. Omdat het gebruik van surrogaten gevaarlijk kan zijn, heeft Perl
waarschuwt.

Als de getoonde bewerking "ToFold" is, betekent dit dat hoofdletterongevoelige overeenkomsten in a
reguliere expressie werd uitgevoerd op het codepunt.

Als u weet wat u doet, kunt u deze waarschuwing uitschakelen met 'geen waarschuwingen'
'surrogaat';".

Operator of puntkomma ontbreekt vóór %s
(Sambigu) U hebt een variabele of subroutineaanroep gebruikt waarbij de parser een an verwachtte
exploitant. De parser heeft aangenomen dat je echt een operator wilde gebruiken, maar dit is zo
zeer waarschijnlijk onjuist. Als u bijvoorbeeld "*foo *foo" zegt, zal dat zo zijn
geïnterpreteerd alsof je "*foo * 'foo'" zei.

Optionele parameter heeft geen standaardexpressie
(F) In een subroutinehandtekening schreef je iets als "$a =", waardoor je een naam maakte
optionele parameter zonder standaardwaarde. Een naamloze optionele parameter is
mag geen standaardwaarde hebben, maar een benoemde waarde moet een specifieke standaardwaarde hebben. Jij
wil waarschijnlijk "$a = undef".

"onze" variabele %s opnieuw gedeclareerd
(W misc) Het lijkt erop dat je dezelfde global al een keer eerder hebt gedeclareerd in de huidige
lexicale reikwijdte.

Geen geheugen!
(X) De malloc () functie retourneerde 0, wat aangeeft dat er onvoldoende resterend was
geheugen (of virtueel geheugen) om aan het verzoek te voldoen. Perl heeft geen andere keus dan af te sluiten
per direct plannen.

In Unix kun je hier in ieder geval voorbij komen door de datagrootte van je proces te vergroten
limieten: gebruik in csh/tcsh "limit" en "limit datasize n" (waarbij "n" het aantal is
kilobytes) om de huidige limieten te controleren en te wijzigen, en in ksh/bash/zsh gebruik
respectievelijk "ulimit -a" en "ulimit -dn".

Onvoldoende geheugen tijdens %s verlenging
(X) Er is geprobeerd een array, een lijst of een string uit te breiden tot voorbij de grootste
mogelijke geheugentoewijzing.

Onvoldoende geheugen tijdens "groot" verzoek voor %s
(F) De malloc () functie retourneerde 0, wat aangeeft dat er onvoldoende resterend was
geheugen (of virtueel geheugen) om aan het verzoek te voldoen. Het verzoek werd echter gehonoreerd
groot genoeg (de standaardwaarde bij het compileren is 64K), dus een mogelijkheid om af te sluiten door middel van trapping
deze fout wordt toegestaan.

Onvoldoende geheugen tijdens verzoek om %s
(X)(F) De malloc () functie retourneerde 0, wat aangeeft dat er onvoldoende resterend was
geheugen (of virtueel geheugen) om aan het verzoek te voldoen.

Het verzoek werd als klein beoordeeld, dus de mogelijkheid om het te vangen hangt af van de manier waarop
perl is samengesteld. Standaard is het niet trappeerbaar. Als dit echter voor dit doel wordt samengesteld,
Perl kan de inhoud van $^M daarna als noodpool gebruiken sterven ()hiermee aan de slag
bericht. In dit geval is de fout te vangen eens, en de foutmelding zal het volgende bevatten
de regel en het bestand waar het mislukte verzoek plaatsvond.

Onvoldoende geheugen tijdens belachelijk groot verzoek
(F) U kunt niet meer dan 2^31+"kleine hoeveelheid" bytes toewijzen. Deze fout is zeer waarschijnlijk
veroorzaakt door een typefout in het Perl-programma. bijvoorbeeld $arr[time] in plaats van $arr[$time].

Onvoldoende geheugen voor yacc-stack
(F) De yacc-parser wilde zijn stapel uitbreiden zodat deze kon doorgaan met parseren, maar
realloc() zou het niet meer geheugen geven, virtueel of anderszins.

'.' buiten het touwtje in de verpakking
(F) Het argument voor een '.' in uw sjabloon probeerde de werkpositie te verplaatsen
vóór het begin van het bouwen van de ingepakte string.

'@' buiten de tekenreeks bij het uitpakken
(F) U had een sjabloon die een absolute positie buiten het stringwezen specificeerde
uitgepakt. Zie "pak" in perlfunc.

'@' buiten de tekenreeks met verkeerd opgemaakte UTF-8 bij het uitpakken
(F) U had een sjabloon die een absolute positie buiten het stringwezen specificeerde
uitgepakt. De uitgepakte string was ook ongeldige UTF-8. Zie "pack" in perlfunc.

overbelasting arg '%s' is ongeldig
(W overload) Het overload-pragma kreeg een argument doorgegeven dat het niet herkende. Heb jij
een operator verkeerd getypt?

Overbelaste dereferentie heeft geen referentie opgeleverd
(F) Van een object met een overbelaste dereferentie-operator is geen referentie meer gemaakt, maar de
overbelaste bewerking heeft geen referentie geretourneerd. Zie overbelasting.

Overbelaste qr heeft geen REGEXP geretourneerd
(F) Er is een object met een "qr"-overbelasting gebruikt als onderdeel van een match, maar het is overbelast
bewerking heeft geen gecompileerde regexp geretourneerd. Zie overbelasting.

%s pakketkenmerk kan botsen met toekomstig gereserveerd woord: %s
(W gereserveerd) Er werd een attribuutnaam in kleine letters gebruikt die een pakketspecifieke handler had.
Die naam kan ooit een betekenis hebben voor Perl zelf, ook al heeft die dat nog niet.
Misschien moet u in plaats daarvan een attribuutnaam met meerdere hoofdletters gebruiken. Zie attributen.

in-/uitpakken herhaaltelling overstroom
(F) U kunt een herhalingstelling niet specificeren die zo groot is dat deze uw ondertekende gehele getallen overschrijdt.
Zie "pak" in perlfunc.

pagina overloop
(W io) Een enkele oproep naar schrijven() produceerde meer regels dan er op een pagina passen. Zien
perlform.

paniek: %s
(P) Een interne fout.

paniek: poging om %s te bellen in %s
(P) Een van de bestandstestoperators heeft een codetak ingevoerd die een ACL-gerelateerde aanroept
functie, maar die functie is niet beschikbaar op dit platform. Eerdere controles betekenen
dat het niet mogelijk zou moeten zijn om dit filiaal op dit platform te betreden.

paniek: kinderpseudoproces was nooit gepland
(P) Een onderliggend pseudo-proces in de ithreads-implementatie op Windows was niet gepland
binnen de toegestane tijdsperiode en kon daardoor niet goed initialiseren.

paniek: ck_grep, type=%u
(P) Een interne consistentiecontrole bij het compileren van een grep is mislukt.

paniek: ck_split, type=%u
(P) Een interne consistentiecontrole bij het compileren van een splitsing is mislukt.

paniek: corrupte opgeslagen stapelindex %ld
(P) Er is aan de savestack gevraagd om meer gelokaliseerde waarden te herstellen dan er in de
opslagstapel.

paniek: del_backref
(P) Er is geen interne consistentiecontrole uitgevoerd tijdens een poging om een ​​zwakke referentie opnieuw in te stellen.

paniek: sterf %s
(P) We hebben de contextstapel in een eval-context geplaatst en ontdekten toen dat dit geen
evaluatieve context.

paniek: do_subst
(P) Het interne pp_subst() routine werd aangeroepen met ongeldige operationele gegevens.

paniek: do_trans_%s
(P) De interne do_trans-routines zijn aangeroepen met ongeldige operationele gegevens.

paniek: fold_constants JMPENV_PUSH heeft %d geretourneerd
(P) Bij het proberen vouwconstanten deed zich een andere uitzondering voor dan een "eval"-fout
gevangen.

paniek: frexp: %f
(P) De bibliotheekfunctie frexp() mislukt, waardoor printf("%f") onmogelijk wordt.

paniek: ga naar, type=%u, ix=%ld
(P) We hebben de contextstapel naar een context met het opgegeven label verplaatst, en vervolgens
ontdekte dat het geen context was waarin we weten hoe we naar een goto moeten gaan.

paniek: gp_free kon de glob-aanwijzer niet vrijgeven
(P) De interne routine die wordt gebruikt om de invoer van een typeglob te wissen, heeft herhaaldelijk geprobeerd, maar elk
keer dat iets de vermeldingen in de glob opnieuw heeft gemaakt. Hoogstwaarschijnlijk bevat de glob een
object met een verwijzing terug naar de glob en een destructor die een nieuw object toevoegt
de bol.

paniek: INTERPCASEMOD, %s
(P) De lexer raakte in een slechte staat bij een case-modifier.

paniek: INTERPCONCAT, %s
(P) De lexer raakte in een slechte staat bij het parseren van een string met haakjes.

paniek: kid popen errno read
(F) Een gevorkt kind stuurde een onbegrijpelijke boodschap terug over zijn errno.

paniek: laatste, type=%u
(P) We hebben de contextstapel in een blokcontext geplaatst en ontdekten toen dat dit geen
blokcontext.

paniek: leave_scope clearsv
(P) Een beschrijfbare lexicale variabele werd op de een of andere manier alleen-lezen binnen het bereik.

paniek: leave_scope-inconsistentie %u
(P) De savestack is waarschijnlijk niet meer gesynchroniseerd. Er stond tenminste een ongeldige enum op
de bovenkant ervan.

paniek: magic_killbackrefs
(P) Een interne consistentiecontrole is mislukt tijdens een poging om alle zwakke referenties te resetten naar
een voorwerp.

paniek: malloc, %s
(P) Iets vroeg om een ​​negatief aantal bytes malloc.

paniek: geheugenomslag
(P) Iets heeft geprobeerd meer geheugen toe te wijzen dan mogelijk is, of een negatief bedrag.

paniek: pad_alloc, %p!=%p
(P) De compiler raakte in de war over welk kladblok het toewees en vrijmaakte
tijdelijke en lexicalen uit.

paniek: pad_free curpad, %p!=%p
(P) De compiler raakte in de war over welk kladblok het toewees en vrijmaakte
tijdelijke en lexicalen uit.

paniek: pad_free po
(P) Er is intern een nul-kladblok-offset gedetecteerd. Er werd geprobeerd om A. te bevrijden
doel dat aanvankelijk niet was toegewezen.

paniek: pad_reset curpad, %p!=%p
(P) De compiler raakte in de war over welk kladblok het toewees en vrijmaakte
tijdelijke en lexicalen uit.

paniek: pad_sv po
(P) Er is intern een nul-kladblok-offset gedetecteerd. Hoogstwaarschijnlijk was er een operator nodig
een doelwit, maar dat doelwit was om welke reden dan ook niet toegewezen.

paniek: pad_swipe curpad, %p!=%p
(P) De compiler raakte in de war over welk kladblok het toewees en vrijmaakte
tijdelijke en lexicalen uit.

paniek: pad_swipe po
(P) Er is intern een ongeldige kladblok-offset gedetecteerd.

paniek: pp_iter, type=%u
(P) De foreach-iterator werd aangeroepen in een contextframe zonder lus.

paniek: pp_match%s
(P) Het interne pp_match() routine werd aangeroepen met ongeldige operationele gegevens.

paniek: pp_split, pm=%p, s=%p
(P) Er is iets vreselijks misgegaan bij het voorbereiden van de splitsing.

paniek: realloc, %s
(P) Iets vroeg om een ​​negatief aantal bytes realloc.

paniek: referentiemistelling op nsv in sv_replace() (%d != 1)
(P) Het interne sv_replace() functie kreeg een nieuwe SV met een referentietelling
anders dan 1.

paniek: herstart over %s
(P) Een interne routine vroeg om een ​​goto (of iets dergelijks) en leverde niet
de bestemming.

paniek: return, type=%u
(P) We hebben de contextstapel in een subroutine of eval-context geplaatst en vervolgens ontdekt
het was geen subroutine of evaluatiecontext.

paniek: scan_num, %s
(P) scan_getal() werd gebeld op iets dat geen nummer was.

paniek: Reeks (?{...}): geen codeblok gevonden in regex m/%s/
(P) Tijdens het compileren van een patroon dat ingebedde (?{}) of (??{}) codeblokken heeft, kan perl
kon het codeblok niet vinden dat al door perl gezien en gecompileerd had moeten zijn
voordat de controle werd doorgegeven aan de regex-compiler.

paniek: strxfrm() wordt absurd - a => %u, ab => %u
(P) De gezondheidscontrole van de tolk van de C-functie strxfrm() mislukt. In uw
huidige locale de geretourneerde transformatie van de string "ab" is korter dan die van
de string "a", wat geen zin heeft.

paniek: sv_chop %s
(P) De sv_chop() routine is een positie doorgegeven die niet binnen de reeks van de scalair ligt
buffer.

paniek: sv_insert, midend=%p, bigend=%p
(P) De sv_insert() routine kreeg te horen dat er meer touw moest worden verwijderd dan er touw was.

paniek: top_env
(P) De compiler heeft geprobeerd een goto uit te voeren, of iets dergelijks.

paniek: niet-geïmplementeerde op %s (#%d) aangeroepen
(P) De compiler is in de war en heeft geprobeerd een op te gebruiken die tijdens run niet is toegestaan
tijd.

paniek: utf16_to_utf8: vreemde bytelen
(P) Iets probeerde utf16_to_utf8 aan te roepen met een oneven (in tegenstelling tot even) byte
lengte.

paniek: utf16_to_utf8_reversed: vreemde bytelen
(P) Iets probeerde utf16_to_utf8_reversed aan te roepen met een oneven (in tegenstelling tot even)
byte lengte.

paniek: yylex, %s
(P) De lexer raakte in een slechte staat tijdens het verwerken van een case-modifier.

Haakjes ontbreken rond "%s" lijst
(W-haakjes) Je zei zoiets als

mijn $foo, $bar = @_;

wanneer je bedoelde

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

Onthoud dat "mijn", "onze", "lokale" en "staat" strakker met elkaar verbonden zijn dan een komma.

Interne fout bij parseercode (%s)
(F) Het parseren van code die door een extensie wordt geleverd, heeft de API van de parser op een detecteerbare manier geschonden
manier.

Het doorgeven van verkeerd ingedeelde UTF-8 aan "%s" is verouderd
(D verouderd, utf8) Dit bericht duidt op een bug in de Perl-kern of in XS
code. Dergelijke code probeerde erachter te komen of een personage naar verluidt intern was opgeslagen
gecodeerd als UTF-8, was van een bepaald type, zoals leestekens of een cijfer. Maar de
-teken was niet gecodeerd in legale UTF-8. De %s wordt vervangen door een string die kan zijn
gebruikt door deskundige mensen om te bepalen welk type wordt gecontroleerd. Als
"utf8"-waarschuwingen zijn ingeschakeld, er verschijnt nog een bericht met details over de
misvorming.

Het nesten van patroonsubroutines zonder pos-wijziging overschreed de limiet in regex
(F) U hebt een patroon gebruikt dat te veel geneste subpatroonaanroepen gebruikt zonder te verbruiken
welke tekst dan ook. Herstructureer het patroon zodat de tekst wordt verbruikt voordat de nestlimiet is bereikt
overschreden.

"-p" bestemming: %s
(F) Er is een fout opgetreden tijdens de impliciete uitvoer die wordt aangeroepen door de opdrachtregel "-p".
schakelaar. (Deze uitvoer gaat naar STDOUT, tenzij u deze hebt omgeleid met selecteer().)

Perl API-versie %s van %s komt niet overeen met %s
(F) De XS-module in kwestie is gecompileerd tegen een andere, incompatibele versie van
Perl dan degene die de XS-module heeft geladen.

Perl-vouwregels zijn niet up-to-date voor 0x%X; gebruik alstublieft het perlbug-hulpprogramma om te rapporteren;
in regex; gemarkeerd door <-- HIER in m/%s/
(S regexp) Je hebt een reguliere expressie gebruikt met hoofdletterongevoelige overeenkomsten, en die is er
een bug in Perl waarbij de ingebouwde vouwregels voor reguliere expressies niet nauwkeurig zijn.
Dit kan tot onjuiste resultaten leiden. Rapporteer dit alstublieft als een bug met behulp van de perlbug
utility.

PerlIO-laag ':win32' is experimenteel
(S experimenteel::win32_perlio) De ":win32" PerlIO-laag is experimenteel. Als je wil
Om het risico te nemen deze laag te gebruiken, schakelt u eenvoudigweg deze waarschuwing uit:

geen waarschuwingen "experimenteel::win32_perlio";

Perl_my_%s() niet beschikbaar
(F) Uw platform heeft een zeer ongebruikelijke bytevolgorde en gehele getalgrootte, dus dat was het niet
Het is mogelijk om enkele of alle conversiefuncties voor bytevolgorde met vaste breedte in te stellen. Dit is
alleen een probleem als u de '<' of '>' modifiers gebruikt in (uit)paksjablonen. Zien
"pak" in perlfunc.

Perl %s vereist (bedoelde u %s?)--dit is slechts %s, gestopt
(F) De code die u probeert uit te voeren, heeft om een ​​nieuwere versie van Perl gevraagd dan u
rennen. Misschien is "gebruik 5.10" geschreven in plaats van "gebruik 5.010" of "gebruik v5.10".
Zonder de eerste "v" wordt het getal geïnterpreteerd als een decimaal, met elke drie
cijfers achter de komma die een deel van het versienummer vertegenwoordigen. Dus 5.10 is
gelijk aan v5.100.

Perl %s vereist - dit is slechts %s, gestopt
(F) De module in kwestie gebruikt functies van een versie van Perl die recenter is dan de
momenteel draaiende versie. Hoe lang is het eigenlijk geleden dat je een upgrade hebt uitgevoerd? Zien
"vereisen" in perlfunc.

PERL_SH_DIR te lang
(F) Een fout die eigen is aan OS/2. PERL_SH_DIR is de map waarin de "sh"-shell wordt gevonden
in. Zie "PERL_SH_DIR" in perlos2.

PERL_SIGNALS illegaal: "%s"
(X) Zie "PERL_SIGNALS" in perlrun voor legale waarden.

Perls sinds %s te modern--dit is %s, gestopt
(F) De code die u probeert uit te voeren beweert dat deze niet kan worden uitgevoerd op de versie van Perl die u gebruikt
gebruiken omdat het te nieuw is. Misschien moet de code worden bijgewerkt, of misschien is dat ook zo
gewoonweg verkeerd en de versiecontrole zou gewoon verwijderd moeten worden.

perl: waarschuwing: niet-hexadecimaal teken in '$ENV{PERL_HASH_SEED}', zaad slechts gedeeltelijk ingesteld
(S) PERL_HASH_SEED moet overeenkomen met /^\s*(?:0x)?[0-9a-fA-F]+\s*\z/ maar het bevatte een niet
hexadecimaal karakter. Dit kan betekenen dat je niet het hasjzaad gebruikt dat je denkt te gebruiken.

perl: waarschuwing: Landinstellingen instellen is mislukt.
(S) Het hele waarschuwingsbericht ziet er ongeveer zo uit:

perl: waarschuwing: Landinstellingen instellen is mislukt.
perl: waarschuwing: Controleer of uw landinstellingen:
LC_ALL = "En_US",
LANG = (niet ingesteld)
worden ondersteund en op uw systeem geïnstalleerd.
perl: waarschuwing: Terugvallen op de standaardlandinstelling ("C").

Wat precies de mislukte landinstellingen waren, varieert. In het bovenstaande waren de instellingen
dat de LC_ALL "En_US" was en dat de LANG geen waarde had. Deze fout betekent dat Perl
heeft vastgesteld dat u en/of uw besturingssysteemleverancier en/of systeembeheerder
hebben het zogenaamde locale-systeem opgezet, maar Perl kon die instellingen niet gebruiken. Dit
was gelukkig niet heel serieus: er is een "standaardlandinstelling" genaamd "C" die Perl
kan en zal gebruiken, en het script zal worden uitgevoerd. Voordat je het probleem echt oplost,
u krijgt echter elke keer dat u Perl uitvoert dezelfde foutmelding. Hoe echt
Het probleem oplossen is te vinden in de sectie Perllocale LOKAAL PROBLEMEN.

perl: waarschuwing: vreemde instelling in '$ENV{PERL_PERTURB_KEYS}': '%s'
(S) Perl werd uitgevoerd met de omgevingsvariabele PERL_PERTURB_KEYS gedefinieerd, maar
met een onverwachte waarde. De wettelijke waarden van deze instelling zijn als volgt.

Numeriek | Tekenreeks | Resultaat
--------+--------------+----------------------- ----------------
0 | NEE | Schakelt willekeurige sleuteloverdracht uit
1 | WILLEKEURIG | Maakt volledige randomisatie van sleutelpassages mogelijk
2 | DETERMINISTISCH | Maakt herhaalbare sleuteloverdracht mogelijk
| | randomisatie

Zowel numerieke waarden als tekenreekswaarden worden geaccepteerd, maar houd er rekening mee dat tekenreekswaarden hoofdlettergebruik zijn
gevoelig. De standaardinstelling voor deze instelling is "RANDOM" of 1.

pid %x geen kind
(W exec) Een waarschuwing die specifiek is voor VMS. wachtpid() werd gevraagd te wachten op een proces dat
is geen subproces van het huidige proces. Hoewel dit vanuit het perspectief van VMS prima is,
het is waarschijnlijk niet wat je bedoelde.

'P' moet bij het uitpakken een expliciete grootte hebben
(F) Het uitpakformaat P moet een expliciete grootte hebben, niet "*".

pop-on-referentie is experimenteel
(S experimenteel::autoderef) "pop" met een scalair argument is experimenteel en mag
wijzigen of verwijderen in een toekomstige Perl-versie. Als u het risico wilt nemen om te gebruiken
deze functie, schakelt u eenvoudigweg deze waarschuwing uit:

geen waarschuwingen "experimenteel::autoderef";

POSIX-klasse [:%s:] onbekend in regex; gemarkeerd door <-- HIER in m/%s/
(F) De klasse in de syntaxis van de karakterklasse [::] is onbekend. De <-- HIER wordt weergegeven
waar in de reguliere expressie het probleem werd ontdekt. Merk op dat de POSIX
karakterklassen wel niet het voorvoegsel "is" hebben, de overeenkomstige C-interfaces hebben: in
met andere woorden, het is "[[:print:]]", niet "isprint". Zie perlre.

POSIX getpgrp kan geen argument aannemen
(F) Uw systeem beschikt over POSIX getpgrp(), waarvoor geen argumenten nodig zijn, in tegenstelling tot de BSD-versie,
waarvoor een pid nodig is.

POSIX-syntaxis [%c %c] hoort thuis in tekenklassen in regex; gemarkeerd met <-- HIER in
Mevr/
(W regexp) De tekenklasse construeert [::], [= =] en [. .] gaan binnen karakter
klassen, de [] maken deel uit van het construct, bijvoorbeeld: /[012[:alpha:]345]/. Note
dat [= =] en [. .] zijn momenteel niet geïmplementeerd; het zijn gewoon tijdelijke aanduidingen voor
toekomstige uitbreidingen en zal fatale fouten veroorzaken. De <-- HIER toont de locatie in de
reguliere expressie werd het probleem ontdekt. Zie perlre.

POSIX-syntaxis [. .] is gereserveerd voor toekomstige extensies in regex; gemarkeerd door <-- HIER in m/%s/
(F) Binnen tekenklassen voor reguliere expressies ([]) de syntaxis die begint met "[."
en eindigend met ".]" is gereserveerd voor toekomstige uitbreidingen. Als je moet vertegenwoordigen
die tekenreeksen binnen een tekenklasse voor reguliere expressies, citeer gewoon de
vierkante haken met de backslash: "\[." En ".\]". De <-- HIER toont de verblijfplaats
in de reguliere expressie werd het probleem ontdekt. Zie perlre.

POSIX-syntaxis [= =] is gereserveerd voor toekomstige extensies in regex; gemarkeerd door <-- HIER in m/%s/
(F) Binnen tekenklassen voor reguliere expressies ([]) de syntaxis die begint met "[="
en eindigend met "=]" is gereserveerd voor toekomstige extensies. Als je moet vertegenwoordigen
die tekenreeksen binnen een tekenklasse voor reguliere expressies, citeer gewoon de
vierkante haken met de backslash: "\[=" en "=\]". De <-- HIER toont de verblijfplaats
in de reguliere expressie werd het probleem ontdekt. Zie perlre.

Mogelijke poging om commentaar in te voegen qw() lijst
(Wqw) qw() lijsten bevatten items gescheiden door witruimte; net als bij letterlijke snaren,
commentaartekens worden niet genegeerd, maar worden in plaats daarvan behandeld als letterlijke gegevens. (Je kan
hebben andere scheidingstekens gebruikt dan de hier getoonde haakjes; beugels zijn dat ook
vaak gebruikt.)

Je hebt waarschijnlijk zoiets als dit geschreven:

@lijst = qw(
een # een opmerking
b # nog een opmerking
);

terwijl je dit had moeten schrijven:

@lijst = qw(
a
b
);

Als je echt commentaar wilt, bouw je lijst dan op de ouderwetse manier op, met aanhalingstekens en
komma's:

@lijst = (
'a', # een opmerking
'b', # nog een opmerking
);

Mogelijke poging om woorden te scheiden met komma's
(Wqw) qw() lijsten bevatten items gescheiden door witruimte; daarom zijn komma's dat niet
nodig om de items te scheiden. (Misschien heb je andere scheidingstekens gebruikt dan de
haakjes hier weergegeven; beugels worden ook vaak gebruikt.)

Je hebt waarschijnlijk zoiets als dit geschreven:

qw! a, b, c!;

waardoor letterlijke komma's in sommige lijstitems worden geplaatst. Schrijf het zonder komma's als je
wil niet dat ze in uw gegevens verschijnen:

qw! alfabet!;

Mogelijke geheugenbeschadiging: %s overstroomde 3e argument
(Fan ioctl() or fctl() meer terug dan Perl had verwacht. Perl raadt a
redelijke buffergrootte, maar plaatst een sentinelbyte aan het einde van de buffer er net in
geval. Deze Sentinel-byte is gehackt en Perl gaat ervan uit dat het geheugen nu is
beschadigd. Zie "ioctl" in perlfunc.

Mogelijk prioriteitsprobleem met de control flow-operator
(W-syntaxis) Er is een mogelijk probleem met het mengen van een besturingsstroomoperator
(bijv. "return") en een operator met lage prioriteit zoals "or". Overwegen:

sub { retourneer $a of $b; }

Dit wordt geparseerd als:

sub { (retourneer $a) of $b; }

Wat in feite gewoon is:

sub { retourneer $a; }

Gebruik haakjes of de variant met hoge prioriteit van de operator.

Merk op dat dit ook kan worden geactiveerd voor constructies zoals:

sub { 1 als sterven; }

Mogelijk prioriteitsprobleem bij bitsgewijze operator %s
(W-prioriteit) Uw programma gebruikt een bitsgewijze logische operator in combinatie met a
numerieke vergelijkingsoperator, zoals deze:

als ($x & $y == 0) { ... }

Deze uitdrukking is feitelijk gelijk aan "$x & ($y == 0)", vanwege de hogere waarde
voorrang van "==". Dit is waarschijnlijk niet wat je wilt. (Als je dat echt bedoelde
schrijf dit, schakel de waarschuwing uit, of, beter, plaats de haakjes expliciet en schrijf
"$x & ($y == 0)").

Mogelijke onbedoelde interpolatie van $\ in regex
(W dubbelzinnig) Je zei zoiets als "m/$\/" in een regex. De regex "m/foo$\s+bar/m"
vertaalt zich naar: match het woord 'foo', het uitvoerrecordscheidingsteken (zie "$\" in perlvar)
en de letter 's' (een of meerdere keren), gevolgd door het woord 'bar'.

Als dit is wat u bedoelde, kunt u de waarschuwing uitschakelen door "m/${\}/" (for
voorbeeld: "m/foo${\}s+bar/").

Als u in plaats daarvan het woord 'foo' aan het einde van de regel wilt matchen, gevolgd door
witruimte en het woord 'bar' op de volgende regel, dan kunt u "m/$(?)\/" gebruiken (voor
voorbeeld: "m/foo$(?)\s+bar/").

Mogelijke onbedoelde interpolatie van %s in string
(W dubbelzinnig) Je zei zoiets als '@foo' in een tekenreeks met dubbele aanhalingstekens, maar dat was zo
er was op dat moment geen array @foo in bereik. Als je een letterlijke @foo wilt, schrijf het dan als
\@foo; zoek anders uit wat er is gebeurd met de array die u blijkbaar uit het oog bent verloren.

Postfix-dereferentie is experimenteel
(S experimenteel::postderef) Deze waarschuwing wordt uitgezonden als u de experimentele
postfix dereferentie syntaxis. Onderdruk gewoon de waarschuwing als u de . wilt gebruiken
functie, maar weet dat u daarbij het risico neemt om een ​​experimentele
functie die in een toekomstige Perl-versie kan worden gewijzigd of verwijderd:

geen waarschuwingen "experimenteel::postderef";
gebruik de functie "postderef", "postderef_qq";
$ref->$*;
$aref->@*;
$aref->@[@indices];
... enzovoort ...

Prioriteitsprobleem: open %s moet open(%s) zijn
(S-prioriteit) De oude onregelmatige constructie

open FOO || dood gaan;

wordt nu verkeerd geïnterpreteerd als

open(FOO || sterven);

vanwege de strikte regularisatie van de grammatica van Perl 5 in unair en lijst
exploitanten. (De oude open was een beetje van beide.) Je moet haakjes om de
filehandle, of gebruik de nieuwe operator "or" in plaats van "||".

Voortijdig einde van scriptheaders
Zie Serverfout.

printf () op gesloten bestandshandle %s
(W gesloten) De filehandle waarnaar u schrijft, is enige tijd geleden gesloten.
Controleer uw controlestroom.

afdrukken() op gesloten bestandshandle %s
(W gesloten) De bestandshandle waarop u afdrukt, is enige tijd geleden gesloten.
Controleer uw controlestroom.

Proces beëindigd door SIG%s
(W) Dit is een standaardbericht dat wordt uitgegeven door OS/2-applicaties, terwijl *nix-applicaties
in stilte sterven. Het wordt beschouwd als een kenmerk van de OS/2-poort. Men kan gemakkelijk uitschakelen
dit door de juiste signaalgevers, zie "Signalen" in perlipc. Zie ook "Proces
beëindigd door SIGTERM/SIGINT" in perlos2.

Eigenschap '%s' is onbekend in regex; gemarkeerd door <-- HIER in m/%s/
(F) De benoemde eigenschap die u hebt opgegeven via "\p" of "\P" is niet bekend bij Perl.
Misschien heb je de naam verkeerd gespeld? Zie "Eigenschappen toegankelijk via \p{} en \P{}" in
perluniprops voor een volledige lijst met beschikbare officiële eigendommen. Als het een gebruikers-
gedefinieerde eigenschap moet zijn gedefinieerd op het moment dat de reguliere expressie is
gecompileerd.

Prototype na '%c' voor %s: %s
(W illegalproto) Een karakter volgt % of @ in een prototype. Dit is nutteloos, aangezien %
en @ slokken de rest van de subroutineargumenten op.

Prototype komt niet overeen: %s versus %s
(S-prototype) De subroutine die wordt gedeclareerd of gedefinieerd, was eerder gedeclareerd of
gedefinieerd met een ander functieprototype.

Prototype niet beëindigd
(F) U hebt het haakje sluiten weggelaten in de definitie van een functieprototype.

Prototype '%s' overschreven door attribuut 'prototype(%s)' in %s
(W-prototype) Een prototype werd aangegeven tussen haakjes achter de subnaam en
via het prototype-attribuut. Het prototype tussen haakjes is nutteloos, omdat het zal
worden vervangen door het prototype van het attribuut voordat het ooit wordt gebruikt.

push-on-referentie is experimenteel
(S experimenteel::autoderef) "push" met een scalair argument is experimenteel en mag
wijzigen of verwijderen in een toekomstige Perl-versie. Als u het risico wilt nemen om te gebruiken
deze functie, schakelt u eenvoudigweg deze waarschuwing uit:

geen waarschuwingen "experimenteel::autoderef";

Kwantificator volgt niets in regex; gemarkeerd door <-- HIER in m/%s/
(F) U bent een reguliere expressie begonnen met een kwantor. Backslash als je het meende
letterlijk. De <-- HIER laat zien waar in de reguliere expressie het probleem zich voordeed
ontdekt. Zie perlre.

Kwantificator in {,} groter dan %d in regex; gemarkeerd door <-- HIER in m/%s/
(F) Er is momenteel een limiet aan de grootte van de min- en max-waarden van de {min,max}
construeren. De <-- HIER laat zien waar in de reguliere expressie het probleem zich voordeed
ontdekt. Zie perlre.

Kwantificator {n,m} met n > m kan niet overeenkomen in regex
Kwantificator {n,m} met n > m kan niet overeenkomen in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp) Minima moeten kleiner zijn dan of gelijk zijn aan maxima. Als je echt jouw
regexp om 0 keer met iets overeen te komen, typ dan gewoon {0}.

Kwantificator onverwacht bij expressie met lengte nul in regex m/%s/
(W regexp) U hebt een kwantor voor reguliere expressies toegepast op een plaats waar het nee maakt
zin, zoals op een nul-breedte bewering. Probeer de kwantor in de . te plaatsen
bewering in plaats daarvan. Bijvoorbeeld, de manier om "abc" te matchen, op voorwaarde dat deze wordt gevolgd
door drie herhalingen van "xyz" is "/abc(?=(?:xyz){3})/", niet "/abc(?=xyz){3}/".

Bereikiterator buiten geheel getalbereik
(F) Eén (of beide) van de numerieke argumenten voor de bereikoperator ".." vallen buiten de
bereik dat intern door gehele getallen kan worden weergegeven. Een mogelijke oplossing is om
dwing Perl om magische tekenreeksverhogingen te gebruiken door "0" voor uw cijfers te zetten.

Bereiken van ASCII-afdrukbare bestanden moeten een subset zijn van "0-9", "AZ" of "az" in regex;
gemarkeerd door <-- HIER in m/%s/
(W regexp) (alleen onder "use re 'strict'" of binnen "(?[...])")

Strengere regels helpen bij het opsporen van typefouten en andere fouten. Misschien was het niet eens de bedoeling dat je een
bereik hier, als de "-" bedoeld was als een ander teken, of had moeten zijn
ontsnapt (zoals "\-"). Als je een bereik bedoelde, is het gebruikte bereik niet draagbaar
tussen ASCII- en EBCDIC-platforms, en heeft geen voor de hand liggende betekenis voor een casual
reader.

[3-7] # OK; Duidelijk en draagbaar
[dg] # OK; Duidelijk en draagbaar
[AY] # OK; Duidelijk en draagbaar
[Az] # FOUT; Niet draagbaar; niet duidelijk wat er bedoeld wordt
[aZ] # FOUT; Niet draagbaar; niet duidelijk wat er bedoeld wordt
[%-.] # FOUT; Niet draagbaar; niet duidelijk wat er bedoeld wordt
[\x41-Z] # FOUT; Niet draagbaar; niet duidelijk voor niet-nerds

(U kunt portabiliteit afdwingen door een Unicode-bereik op te geven, wat betekent dat de
eindpunten worden gespecificeerd door "\N{...}", maar de betekenis is misschien nog steeds niet duidelijk.) The
strengere regels vereisen dat bereiken die beginnen of stoppen met een ASCII-teken
geen controle, al hun eindpunten zijn het letterlijke karakter, en niet een of andere ontsnapping
reeks (zoals "\x41"), en de bereiken moeten allemaal cijfers of hoofdletters zijn,
of allemaal kleine letters.

Cijferreeksen moeten uit dezelfde groep in regex komen; gemarkeerd door <-- HIER in m/%s/
(W regexp) (alleen onder "use re 'strict'" of binnen "(?[...])")

Strengere regels helpen bij het opsporen van typefouten en andere fouten. Je hebt een bereik toegevoegd, en op
minstens één van de eindpunten is een decimaal cijfer. Onder de strengere regels, wanneer dit
gebeurt, moeten beide eindpunten cijfers zijn in dezelfde groep van 10 opeenvolgende cijfers.

leesmap() geprobeerd op ongeldige dirhandle %s
(W io) De dirhandle waaruit je leest is gesloten of niet echt een dirhandle.
Controleer uw controlestroom.

Lees regel() op gesloten bestandshandle %s
(W gesloten) De filehandle waar je van leest, is enige tijd eerder gesloten.
Controleer uw controlestroom.

lezen() op gesloten bestandshandle %s
(W gesloten) U hebt geprobeerd te lezen van een gesloten bestandshandle.

lezen() op ongeopende bestandshandle %s
(W ongeopend) U hebt geprobeerd te lezen van een bestandshandle die nooit is geopend.

Herverdeling te groot: %x
(F) U kunt niet meer dan 64 KB toewijzen op een MS-DOS-machine.

realloc() van vrijgemaakt geheugen genegeerd
(S malloc) Een interne routine gebeld realloc() op iets dat al was
bevrijd.

Perl opnieuw compileren met -DDEBUGGING te gebruiken -D schakelaar
(S-foutopsporing) U kunt de -D optie tenzij de code het gewenste produceert
de uitvoer wordt gecompileerd in Perl, wat enige overhead met zich meebrengt, en daarom gebeurt dit momenteel
weggelaten uit uw exemplaar.

Recursieve aanroep naar Perl_load_module in PerlIO_find_layer
(P) Het is momenteel niet toegestaan ​​om modules te laden bij het maken van een filehandle in een
%INC haak. Dit kan gebeuren met "open my $fh, '<', \$scalar", dat impliciet wordt geladen
PerlIO::scalair. Probeer eerst PerlIO::scalar expliciet te laden.

Recursieve overerving gedetecteerd in pakket '%s'
(F) Bij het berekenen van de methoderesolutievolgorde (MRO) van een pakket gelooft Perl dit
heeft een oneindige lus gevonden in de @ISA-hiërarchie. Dit is een ruwe cheque die redding biedt
na 100 niveaus van @ISA-diepte.

Redundant argument in %s
(W redundant) Je hebt een functie aangeroepen met meer argumenten dan andere argumenten
bijgeleverd aangegeven nodig zou zijn. Momenteel alleen verzonden bij een printf-type formaat
vereiste minder argumenten dan er werden aangeleverd, maar zou in de toekomst kunnen worden gebruikt voor bijvoorbeeld
"pak" in perlfunc.

refcnt_dec: fd %d%s
referentie: fd %d%s
refcnt_inc: fd %d%s
(P) De I/O-implementatie van Perl slaagde niet voor een interne consistentiecontrole. Als je dit ziet
bericht, er is iets heel erg mis.

Referentie gevonden waar een lijst van gelijke grootte wordt verwacht
(W overige) U gaf een enkele verwijzing waarbij Perl een lijst met een even verwachtte
aantal elementen (voor toewijzing aan een hash). Dit betekent meestal dat u de
anon hash constructor wanneer je parens wilde gebruiken. In ieder geval vereist een hasj
sleutel waarde paren.

%hash = { één => 1, twee => 2, }; # FOUT
%hash = [ qw/ een anon-array / ]; # FOUT
%hash = ( één => 1, twee => 2, ); # rechts
%hash = qw( één 1 twee 2); # ook goed

Referentie is al zwak
(W misc) U hebt geprobeerd een referentie te verzwakken die al zwak is. Dit doen heeft
geen effect.

Verwijzing naar ongeldige groep 0 in regex; gemarkeerd door <-- HIER in m/%s/
(F) U hebt "\g0" of iets dergelijks gebruikt in een reguliere expressie. Je zou kunnen spreken van vastleggen
alleen haakjes met strikt positieve gehele getallen (normale terugverwijzingen) of met
strikt negatieve gehele getallen (relatieve terugverwijzingen). Het gebruik van 0 heeft geen zin.

Verwijzing naar niet-bestaande groep in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je hebt zoiets als "\7" in je reguliere expressie gebruikt, maar die zijn er niet
minimaal zeven sets haakjes in de uitdrukking. Als je dat wilde hebben
het teken met rangtelwoord 7 ingevoegd in de reguliere expressie, zet er nullen voor
maak er drie cijfers van: "\007"

De <-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt.

Verwijzing naar niet-bestaande benoemde groep in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je hebt iets gebruikt als "\k'NAME'" of "\k " in uw reguliere expressie, maar
er zijn geen overeenkomstige benoemde haakjes, zoals "(?'NAAM'...)" of
"(? ...)". Controleer of de naam correct is gespeld in zowel het
terugverwijzing en de declaratie.

De <-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt.

Verwijzing naar niet-bestaande of niet-gesloten groep in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je hebt zoiets als "\g{-7}" gebruikt in je reguliere expressie, maar die zijn er niet
minimaal zeven sets gesloten haakjes in de uitdrukking ervoor waar de
"\g{-7}" is gevonden.

De <-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt.

regexp geheugencorruptie
(P) De reguliere expressie-engine raakte in de war door wat de reguliere expressie-compiler gebruikte
gaf het.

Regexp-modifier "/%c" mag maximaal twee keer voorkomen
Regexp-modifier "%c" mag maximaal twee keer voorkomen in regex; gemarkeerd door <-- HIER in m/%s/
(F) Het reguliere expressiepatroon bevatte te vaak de opgegeven modifier.
Verwijder de overbodige.

Regexp-modifier "%c" verschijnt mogelijk niet na de "-" in regex; gemarkeerd door <-- HIER in m/%s/
(F) Het uitschakelen van de gegeven modifier heeft als neveneffect dat er een andere wordt ingeschakeld.
Perl staat dit momenteel niet toe. Herformuleer de reguliere expressie om de modifier te gebruiken
die u wilt inschakelen (en plaats deze vóór de min), in plaats van degene die u wilt inschakelen
zet uit.

Regexp-modifier "/%c" verschijnt mogelijk niet twee keer
Regexp-modifier "%c" verschijnt mogelijk niet twee keer in regex; gemarkeerd door <-- HIER in m/%s/
(F) Het reguliere expressiepatroon bevatte te vaak de opgegeven modifier.
Verwijder de overbodige.

Regexp-modificatoren "/%c" en "/%c" sluiten elkaar wederzijds uit
Regexp-modificatoren "%c" en "%c" sluiten elkaar wederzijds uit in regex; gemarkeerd met <-- HIER in
Mevr/
(F) Het reguliere expressiepatroon had meer dan één van deze die elkaar uitsloten
modificatoren. Bewaar alleen de modifier die daar hoort te zijn.

Regexp buiten ruimte in regex m/%s/
(P) Een 'kan niet gebeuren'-fout, omdat veiligemalloc() had het eerder moeten opvangen.

Herhaalde opmaakregels eindigen nooit (~~ en @#)
(F) Uw formaat bevat de reeks ~~ herhalen tot blanco en een numeriek veld dat
zal nooit blanco blijven, zodat de herhaling nooit eindigt. Je zou ^# kunnen gebruiken
in plaats van. Zie perlform.

Vervangingslijst is langer dan zoeklijst
(W overige) U heeft een vervangingslijst gebruikt die langer is dan de zoeklijst. Dus de
aanvullende elementen in de vervangingslijst zijn zinloos.

'%s' omgezet in '\o{%s}%d'
(W misc, regexp) Je hebt iets als "\08" of "\179" tussen dubbele aanhalingstekens geschreven
snaar. Alles behalve het laatste cijfer wordt behandeld als één enkel teken, gespecificeerd in octaal.
Het laatste cijfer is het volgende teken in de string. Om Perl te vertellen dat dit inderdaad zo is
wat u wilt, kunt u de syntaxis "\o{ }" gebruiken, of precies drie cijfers gebruiken om op te geven
het octaal voor het karakter.

Omgekeerde %s=-operator
(W-syntaxis) U hebt uw toewijzingsoperator achterstevoren geschreven. De = moet altijd als laatste komen,
om dubbelzinnigheid met daaropvolgende unaire operatoren te voorkomen.

terugspoelen() geprobeerd op ongeldige dirhandle %s
(W io) De dirhandle die je probeerde te doen terugspoelen() on is gesloten of niet echt a
dirhandle. Controleer uw controlestroom.

Scalaire gelekt: %d
(S intern) Er is iets misgegaan in Perl's interne boekhouding van scalairen: niet allemaal
scalaire variabelen werden niet meer toegewezen tegen de tijd dat Perl werd afgesloten. Wat dit meestal is
geeft aan dat er sprake is van een geheugenlek, wat uiteraard slecht is, vooral als het om het Perl-programma gaat
bedoeld om langlopend te zijn.

Scalaire waarde @%s[%s] beter geschreven als $%s[%s]
(W-syntaxis) U hebt een array-segment (aangegeven met @) gebruikt om één enkel element van te selecteren
een array. Over het algemeen is het beter om om een ​​scalaire waarde te vragen (aangegeven met $). De
Het verschil is dat $foo[&bar] zich altijd als een scalair gedraagt, zowel bij het toewijzen ervan
en bij het evalueren van het argument, terwijl @foo[&bar] zich bij het toewijzen als een lijst gedraagt
ernaar, en biedt een lijstcontext voor het subscript, dat rare dingen kan doen als
je verwacht slechts één subscript.

Aan de andere kant, als je eigenlijk hoopte het array-element als een lijst te behandelen,
je moet onderzoeken hoe verwijzingen werken, omdat Perl niet op magische wijze converteert
tussen scalairen en lijsten voor u. Zie perlref.

Scalaire waarde @%s{%s} beter geschreven als $%s{%s}
(W-syntaxis) Je hebt een hash-segment (aangegeven met @) gebruikt om een ​​enkel element van een
hasj. Over het algemeen is het beter om om een ​​scalaire waarde te vragen (aangegeven met $). De
Het verschil is dat $foo{&bar} zich altijd als een scalair gedraagt, zowel bij het toewijzen ervan
en bij het evalueren van het argument, terwijl @foo{&bar} zich bij het toewijzen als een lijst gedraagt
ernaar, en biedt een lijstcontext voor het subscript, dat rare dingen kan doen als
je verwacht slechts één subscript.

Aan de andere kant, als je eigenlijk hoopte het hash-element als een lijst te behandelen,
je moet onderzoeken hoe verwijzingen werken, omdat Perl niet op magische wijze converteert
tussen scalairen en lijsten voor u. Zie perlref.

Zoekpatroon niet beëindigd
(F) De lexer kon het laatste scheidingsteken van een // of m{} constructie niet vinden. Herinneren
dat scheidingstekens tussen haakjes het nestniveau tellen. Ontbreekt de leidende "$" van a
variabele $m kan deze fout veroorzaken.

Merk op dat sinds Perl 5.10.0 a // ook de gedefinieerd-of constructie, niet alleen de
leeg zoekpatroon. Daarom code geschreven in Perl 5.10.0 of hoger die de //
de gedefinieerd-of kan door Perls van vóór 5.10.0 verkeerd worden geparseerd als een niet-beëindigde zoekopdracht
patroon.

zoekmap() geprobeerd op ongeldige dirhandle %s
(W io) De dirhandle die je doet zoekmap() on is gesloten of niet echt a
dirhandle. Controleer uw controlestroom.

%szoek() op ongeopende filehandle
(W ongeopend) U hebt geprobeerd de zoeken() or syseek() functie op een filehandle die
is nooit geopend of is sindsdien gesloten.

selecteer niet geïmplementeerd
(F) Deze machine implementeert de selecteer() systeemoproep.

Self-koppelingen van arrays en hashes worden niet ondersteund
(F) Self-ties zijn van arrays en hashes worden momenteel niet ondersteund
implementatie.

Het lijkt erop dat de puntkomma ontbreekt
(W puntkomma) Een nabijgelegen syntaxisfout werd waarschijnlijk veroorzaakt door een ontbrekende puntkomma, of
mogelijk een andere ontbrekende operator, zoals een komma.

semi-paniek: poging om de bevrijde string te duperen
(S intern) De interne nieuwSVsv() routine werd aangeroepen om een ​​scalair te dupliceren die dat wel had
eerder als gratis gemarkeerd.

sem%s niet geïmplementeerd
(F) U heeft geen System V-semafoor IPC op uw systeem.

sturen() op gesloten socket %s
(W gesloten) De socket waarnaar u verzendt, is al een tijdje gesloten. Rekening
uw controlestroom.

Reeks "\c{" ongeldig
(F) Deze drie tekens verschijnen mogelijk niet op volgorde in een context met dubbele aanhalingstekens.
Dit bericht verschijnt alleen op niet-ASCII-platforms (een ander foutbericht is
uitvoer op ASCII-versies). Als u van plan was hiermee een controleteken op te geven
volgorde, moet u een andere manier gebruiken om deze op te geven.

Reeks (? onvolledig in regex; gemarkeerd met <-- HIER in m/%s/
(F) Een reguliere expressie eindigde met een onvolledige extensie (?. De <-- HIER wordt weergegeven
waar in de reguliere expressie het probleem werd ontdekt. Zie perlre.

Reeks (?%c...) niet geïmplementeerd in regex; gemarkeerd door <-- HIER in m/%s/
(F) Voor een voorgestelde uitbreiding van reguliere expressies is het teken gereserveerd, maar dat is nog niet het geval
geschreven. De <-- HIER laat zien waar in de reguliere expressie het probleem zich bevindt
was ontdekt. Zie perlre.

Reeks (?%s...) wordt niet herkend in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je hebt een reguliere expressie-extensie gebruikt die nergens op slaat. De <-- HIER
laat zien waar in de reguliere expressie het probleem is ontdekt. Dit zou
gebeurt wanneer u de constructie "(?^...)" gebruikt om Perl te vertellen de standaard reguliere versie te gebruiken
expressiemodifiers, en u specificeert redundant een standaardmodifier. Voor anderen
oorzaken, zie perlre.

Reeks (?#... niet beëindigd in regex m/%s/
(F) Een commentaar bij een reguliere expressie moet worden afgesloten met een haakje sluiten.
Ingesloten haakjes zijn niet toegestaan. Zie perlre.

Reeks (?&... niet beëindigd in regex; gemarkeerd door <-- HIER in m/%s/
(F) Bij een genoemde referentie van de vorm "(?&...)" ontbrak het laatste haakje sluiten
achter de naam. De <-- HIER laat zien waar in de reguliere expressie het probleem zich bevindt
was ontdekt.

Reeks (?%c... niet beëindigd in regex; gemarkeerd door <-- HIER in m/%s/
(F) Een benoemde groep met de vorm "(?'...')" of "(?<...>)" miste de definitieve afsluiting
citaat of hoekbeugel. De <-- HIER toont de locatie in de reguliere expressie the
probleem werd ontdekt.

Reeks (?(%c... niet beëindigd in regex; gemarkeerd door <-- HIER in m/%s/
(F) Bij een benoemde verwijzing in de vorm "(?('...')...)" of "(?(<...>)...)" ontbrak de
laatste afsluitende aanhalingsteken of punthaakje achter de naam. De <-- HIER toont de verblijfplaats
in de reguliere expressie werd het probleem ontdekt.

Reeks (?... niet beëindigd in regex; gemarkeerd door <-- HIER in m/%s/
(F) Er was geen overeenkomend haakje sluiten voor de '('. De <-- HIER wordt weergegeven
waar in de reguliere expressie het probleem werd ontdekt.

Reeks \%s... niet beëindigd in regex; gemarkeerd door <-- HIER in m/%s/
(F) De reguliere expressie verwacht een verplicht argument na de ontsnappingsreeks
en dit is weggelaten of verkeerd geschreven.

Reeks (?{...}) niet afgesloten met ')'
(F) Het einde van de perl-code in de {...} moet onmiddellijk worden gevolgd
door een ')'.

Reeks ?P=... niet beëindigd in regex; gemarkeerd door <-- HIER in m/%s/
(F) Bij een benoemde verwijzing met de vorm "(?P=...)" ontbrak het laatste haakje sluiten
achter de naam. De <-- HIER laat zien waar in de reguliere expressie het probleem zich bevindt
was ontdekt.

Reeks (?R) niet beëindigd in regex m/%s/
(F) Een reeks "(?R)" of "(?0)" in een reguliere expressie miste de finale
haakje.

Serverfout (ook wel '500 Serverfout' genoemd)
(A) Dit is de foutmelding die doorgaans wordt weergegeven in een browservenster wanneer u probeert een
CGI-programma (inclusief SSI) via internet. De daadwerkelijke fouttekst varieert sterk van
server tot server. De meest voorkomende varianten zijn "500 Server error", "Method
(iets) niet toegestaan", "Document bevat geen gegevens", "Voortijdig einde van script
headers", en "Heeft geen geldige header geproduceerd".

Deze is a CGI fout, niet a Perl fout.

U moet ervoor zorgen dat uw script uitvoerbaar is en toegankelijk is voor de CGI-gebruiker
het script uitvoeren waaronder (wat waarschijnlijk niet het gebruikersaccount is waaronder u het hebt getest),
vertrouwt niet op omgevingsvariabelen (zoals PATH) van de gebruiker waarop het niet draait
onder, en bevindt zich niet op een locatie waar de CGI-server het in principe niet kan vinden
minder. Zie het volgende voor meer informatie:

http://www.perl.org/CGI_MetaFAQ.html
http://www.htmlhelp.org/faq/cgifaq.html
http://www.w3.org/Security/Faq/

Kijk ook eens naar perlfaq9.

setegid() Niet geïmplementeerd
(F) U hebt geprobeerd toe te wijzen aan $), en uw besturingssysteem ondersteunt de setegid()
systeemaanroep (of gelijkwaardig), of in ieder geval Configure dacht van niet.

seteuid() Niet geïmplementeerd
(F) U hebt geprobeerd toe te wijzen aan $>, en uw besturingssysteem ondersteunt de seteuid()
systeemaanroep (of gelijkwaardig), of in ieder geval Configure dacht van niet.

setpgrp kan geen argumenten aan
(F) Uw systeem heeft de setpgrp() van BSD 4.2, dat geen argumenten nodig heeft, in tegenstelling tot POSIX
setpgid(), waarvoor een proces-ID en procesgroep-ID nodig zijn.

setrgid() Niet geïmplementeerd
(F) U hebt geprobeerd toe te wijzen aan $(, en uw besturingssysteem ondersteunt de setrgid()
systeemaanroep (of gelijkwaardig), of in ieder geval Configure dacht van niet.

setruid() Niet geïmplementeerd
(F) U hebt geprobeerd toe te wijzen aan $<, en uw besturingssysteem ondersteunt de setruid()
systeemaanroep (of gelijkwaardig), of in ieder geval Configure dacht van niet.

setsockopt() op gesloten socket %s
(W gesloten) U heeft geprobeerd een stopcontactoptie in te stellen op een gesloten stopcontact. Ben je dat vergeten
controleer de retourwaarde van uw stopcontact () telefoongesprek? Zie "setsockopt" in perlfunc.

De instelling ${^ENCODING} is verouderd
(D verouderd) Je hebt een niet-"undef"-waarde toegewezen aan "${^ENCODING}". Dit is
verouderd; zie ""${^ENCODING}" in perlvar" voor details.

Het instellen van $/ naar een verwijzing naar %s als een vorm van slurp is verouderd en wordt behandeld als undef
(D verouderd) U hebt een verwijzing toegewezen aan een scalair naar $/ waar het item waarnaar wordt verwezen zich bevindt
geen positief geheel getal. In oudere perls dit verscheen werkt hetzelfde als het instellen ervan
naar "undef", maar was in feite intern anders, minder efficiënt en met veel pech
had ertoe kunnen leiden dat uw bestand werd gesplitst door een stringente vorm van de verwijzing.

In Perl 5.20.0 is dit gewijzigd zodat dit wel het geval zou zijn precies hetzelfde als het instellen van $/ op
undef, met de uitzondering dat deze waarschuwing zou worden gegeven.

Het wordt aanbevolen om uw code te wijzigen en $/ expliciet in te stellen op "undef" als u dat wilt
slurp het bestand. In toekomstige versies van Perl zal het toewijzen van een verwijzing naar fatale gevolgen hebben
fout.

Het instellen van $/ op %s referentie is verboden
(F) U hebt geprobeerd een verwijzing naar een niet-geheel getal toe te wijzen aan $/. In oudere Perls zou dit wel het geval zijn
hebben zich op dezelfde manier gedragen als het instellen op een verwijzing naar een positief geheel getal, waarbij de
geheel getal was het adres van de referentie. Vanaf Perl 5.20.0 is dit een fatale fout
toestaan ​​dat toekomstige versies van Perl niet-gehele referenties gebruiken voor interessantere doeleinden.

verschuiving op referentie is experimenteel
(S experimenteel::autoderef) "shift" met een scalair argument is experimenteel en mag
wijzigen of verwijderen in een toekomstige Perl-versie. Als u het risico wilt nemen om te gebruiken
deze functie, schakelt u eenvoudigweg deze waarschuwing uit:

geen waarschuwingen "experimenteel::autoderef";

shm%s niet geïmplementeerd
(F) U beschikt niet over System V gedeeld geheugen IPC op uw systeem.

!=~ moet !~ zijn
(W-syntaxis) De niet-overeenkomende operator is !~, niet !=~. !=~ wordt geïnterpreteerd als de
!= (numeriek niet gelijk) en ~ (1's complement) operatoren: waarschijnlijk niet wat jij
bedoeld.

/%s/ moet waarschijnlijk worden geschreven als "%s"
(W-syntaxis) U hebt een patroon gebruikt waarbij Perl verwachtte een string te vinden, zoals in de
eerste argument om "mee te doen". Perl behandelt het ware of valse resultaat van het matchen van de
patroon tegen $_ als de string, wat waarschijnlijk niet is wat je in gedachten had.

stilgelegd() op gesloten socket %s
(W gesloten) U hebt geprobeerd een afsluiting uit te voeren op een gesloten stopcontact. Lijkt een beetje overbodig.

SIG%s-handler "%s" niet gedefinieerd
(W-signaal) De signaalbehandelaar genoemd in %SIG bestaat feitelijk niet. Misschien heb je gezet
in het verkeerde pakket?

Plaat lekt uit cv %p
(S) Als je deze melding ziet, dan is er iets ernstig mis met het interne
boekhouding van bomen. Een op tree moest worden vrijgegeven na een compilatiefout, maar
kon niet worden gevonden, dus het werd in plaats daarvan gelekt.

slaap(%u) te groot
(W overflow) Je hebt "slaap" gebeld met een getal dat groter was dan betrouwbaar kan
handvat en "slaap" hebben waarschijnlijk minder lang geslapen dan gevraagd.

Slurpy-parameter duurt niet lang
(F) In een subroutinehandtekening plaats je iets na een slurpy (array of hash)
parameter. De parameter slurpy neemt alle beschikbare argumenten over, dus dat kan niet
alles wat overblijft om latere parameters in te vullen.

Door slim te matchen met een niet-overbelast object wordt de inkapseling verbroken
(F) U moet de operator "~~" niet gebruiken voor een object dat het niet overbelast: Perl
weigert de onderliggende structuur van het object te gebruiken voor de slimme match.

Smartmatch is experimenteel
(S experimenteel::smartmatch) Deze waarschuwing wordt verzonden als u de smartmatch ("~~") gebruikt
exploitant. Dit is momenteel een experimentele functie en de details ervan zijn onderhevig aan
verandering in toekomstige releases van Perl. Vooral het huidige gedrag wordt opgemerkt
omdat het onnodig complex en niet-intuïtief is en het zeer waarschijnlijk zal worden herzien.

sort is nu een gereserveerd woord
(F) Een eeuwenoude foutmelding die bijna niemand meer tegenkomt. Maar voorheen
sort was een sleutelwoord, mensen gebruikten het soms als bestandshandle.

De sorteersubroutine heeft geen enkele waarde geretourneerd
(F) Een sorteervergelijkingssubroutine geschreven in XS moet precies één item retourneren. Zien
"sorteren" in perlfunc.

Bronfilters zijn alleen van toepassing op bytestreams
(F) U heeft geprobeerd een bronfilter te activeren (meestal door een bronfiltermodule te laden)
binnen een string doorgegeven aan "eval". Dit is niet toegestaan ​​onder de "unicode_eval"
functie. Overweeg om in plaats daarvan "evalbytes" te gebruiken. Zie functie.

splitsen() offset voorbij het einde van de array
(W overige) U heeft geprobeerd een offset op te geven die voorbij het einde van de doorgegeven array lag
naar splitsen(). Het splitsen begint in plaats daarvan aan het einde van de array, in plaats van voorbij
Het. Als dit niet is wat je wilt, probeer dan de array expliciet vooraf uit te breiden door toe te wijzen
$#matrix = $offset. Zie "splitsen" in perlfunc.

splitsing op referentie is experimenteel
(S experimenteel::autoderef) "splice" met een scalair argument is experimenteel en mag
wijzigen of verwijderen in een toekomstige Perl-versie. Als u het risico wilt nemen om te gebruiken
deze functie, schakelt u eenvoudigweg deze waarschuwing uit:

geen waarschuwingen "experimenteel::autoderef";

Gesplitste lus
(P) De splitsing liep oneindig door. (Het is duidelijk dat een splitsing niet meer herhaald moet worden
keer dan er karakters van invoer zijn, en dat is wat er gebeurde.) Zie "split" in
perfunc.

Het is onwaarschijnlijk dat deze verklaring wordt bereikt
(W exec) Je hebt een exec () met een andere verklaring erna dan a sterven (). Dit is
bijna altijd een fout, omdat exec () keert nooit terug, tenzij er sprake is van een mislukking. Jij
waarschijnlijk wilde gebruiken systeem() in plaats daarvan, wat wel terugkeert. Om deze waarschuwing te onderdrukken,
zet de exec () in een blok op zichzelf.

"state" subroutine %s mag niet in een pakket voorkomen
(F) Subroutines met een lexicaal bereik zitten niet in een pakket, dus het heeft geen zin om het te proberen
om er een aan te geven met een pakketkwalificatie op de voorkant.

"state %s" gebruikt in sorteervergelijking
(W-syntaxis) De pakketvariabelen $a en $b worden gebruikt voor sorteervergelijkingen. Je hebt $a gebruikt
of $b in als operand voor de operator "<=>" of "cmp" in een sorteervergelijkingsblok,
en de variabele was eerder gedeclareerd als een lexicale variabele. Ofwel kwalificeert u de
sorteer de variabele met de pakketnaam, of hernoem de lexicale variabele.

"state" variabele %s mag niet in een pakket voorkomen
(F) Variabelen met een lexicaal bereik zitten niet in een pakket, dus het heeft geen zin om dat te proberen
declareer er een met een pakketkwalificatie op de voorkant. Gebruik lokaal() als je wilt
lokaliseer een pakketvariabele.

stat () op ongeopende bestandshandle %s
(W ongeopend) U hebt geprobeerd de stat () functie op een filehandle die een van beide was
nooit geopend of sindsdien gesloten.

Tekenreeksen met codepunten groter dan 0xFF worden mogelijk niet toegewezen aan bestandshandvatten in het geheugen
(W utf8) U hebt geprobeerd een verwijzing naar een scalair te openen om te lezen of toe te voegen waar de scalair
bevatte codepunten van meer dan 0xFF. Bestanden in het geheugen modelleren bestanden op schijf en kunnen alleen
bytes bevatten.

Stub gevonden tijdens het oplossen van methode "%s" die "%s" overbelast in pakket "%s"
(P) Overbelastingsresolutie over de @ISA-boom kan worden verbroken door importstubs. Stompen
mag nooit impliciet worden gecreëerd, maar expliciete oproepen tot 'kunnen' kunnen dit doorbreken.

Subroutine "&%s" is niet beschikbaar
(W afsluiting) Tijdens het compileren probeert een innerlijke benoemde subroutine of eval dit te doen
een buitenste lexicale subroutine vastleggen die momenteel niet beschikbaar is. Dit kan gebeuren
om een ​​van twee redenen. Ten eerste kan de lexicale subroutine in een buitenste worden gedeclareerd
anonieme subroutine die nog niet is gemaakt. (Onthoud dat benoemde subs dat zijn
gemaakt tijdens het compileren, terwijl anonieme subs tijdens runtime worden gemaakt.) Bijvoorbeeld:

sub { mijn sub een {...} sub f { \&a } }

Op het moment dat f wordt gemaakt, kan deze de huidige "a" sub niet vastleggen, aangezien de
anonieme subroutine is nog niet gemaakt. Omgekeerd levert het volgende geen a op
waarschuwing aangezien de anonieme subroutine inmiddels is gemaakt en live is:

sub { mijn sub a {...} eval 'sub f { \&a }' }->();

De tweede situatie wordt veroorzaakt door een evaluatie die toegang krijgt tot een lexicale subroutine die verdwenen is
buiten bereik, bijvoorbeeld

sub-f {
mijn sub een {...}
sub { evaluatie '\&a' }
}
f()->();

Hier, wanneer de '\&a' in de eval wordt gecompileerd, is f() momenteel niet aanwezig
uitgevoerd, dus de &a kan niet worden vastgelegd.

"%s" subroutine &%s maskeert eerdere declaratie in dezelfde %s
(W misc) Een subroutine "my" of "state" is opnieuw gedeclareerd in het huidige bereik of
statement, waardoor alle toegang tot het vorige exemplaar effectief wordt geëlimineerd. Dit is
bijna altijd een typefout. Merk op dat de eerdere subroutine nog steeds werkt
bestaan ​​tot het einde van de reikwijdte of totdat alle afsluitingsreferenties ernaar zijn vernietigd.

Subroutine %s opnieuw gedefinieerd
(W herdefiniëren) U hebt een subroutine opnieuw gedefinieerd. Om deze waarschuwing te onderdrukken, zegt u

{
geen waarschuwingen 'herdefiniëren';
eval "subnaam { ... }";
}

Subroutine "%s" blijft niet gedeeld
(W sluiting) Een binnenste (geneste) genoemd subroutine verwijst naar een "mijn" subroutine
gedefinieerd in een buitenste benoemde subroutine.

Wanneer de binnenste subroutine wordt aangeroepen, ziet deze de waarde van de buitenste subroutine
lexicale subroutine zoals die was vóór en tijdens de *eerste* oproep naar de buitenwereld
subroutine; in dit geval, nadat de eerste oproep naar de buitenste subroutine is voltooid,
de binnenste en buitenste subroutines zullen niet langer een gemeenschappelijke waarde voor het lexicale delen
subroutine. Met andere woorden: het wordt niet langer gedeeld. Dit zal vooral een
verschil als de lexicale subroutines toegang krijgen tot lexicale variabelen die in de lexicale variabelen zijn gedeclareerd
omringende reikwijdte.

Dit probleem kan meestal worden opgelost door de binnenste subroutine anoniem te maken, met behulp van de
"sub {}" syntaxis. Wanneer innerlijke anonieme subs die verwijzen naar lexicale subroutines in
buitenste subroutines worden gemaakt, keren ze automatisch terug naar de huidige waarden van
zulke lexicale subs.

Vervangingslus
(P) De vervanging liep oneindig door. (Een vervanging mag uiteraard niet
herhaal vaker dan er invoertekens zijn, en dat is wat er gebeurde.) Zie je
de discussie over vervanging in "Regexp Quote-Like Operators" in perlop.

Vervangingspatroon niet beëindigd
(F) De lexer kon het interne scheidingsteken van een s/// of s{}{} constructie niet vinden.
Houd er rekening mee dat scheidingstekens tussen haakjes het nestniveau tellen. Ontbreekt de leidende "$" van
variabele $s kan deze fout veroorzaken.

Vervangingsvervanging niet beëindigd
(F) De lexer kon het laatste scheidingsteken van een s/// of s{}{} constructie niet vinden.
Houd er rekening mee dat scheidingstekens tussen haakjes het nestniveau tellen. Ontbreekt de leidende "$" van
variabele $s kan deze fout veroorzaken.

substr buiten de tekenreeks
(W substr)(F) Je hebt geprobeerd te verwijzen naar a substr() die naar buiten een touwtje wees.
Dat wil zeggen dat de absolute waarde van de offset groter was dan de lengte van de string.
Zie "substr" in perlfunc. Deze waarschuwing is fataal als substr wordt gebruikt in een lvalue
context (als de linkerkant van een opdracht of als subroutineargument voor
voorbeeld).

sv_upgrade van type %d naar type %d
(P) Perl probeerde de upgrade van een SV te forceren naar een type dat eigenlijk inferieur was aan
zijn huidige type.

SWASHNEW heeft geen HV-referentie geretourneerd
(P) Er ging intern iets mis toen Perl Unicode probeerde op te zoeken
tekens.

Switch (?(condition)... bevat te veel vertakkingen in regex; gemarkeerd met <-- HIER in m/%s/
(F) Een (?(condition)if-clause|else-clause) constructie kan maximaal twee takken hebben (de
if-clausule en de else-clausule). Als u wilt dat een of beide afwisseling bevatten, zoals
Als je "dit | dat | andere" gebruikt, plaats het dan tussen haakjes:

(?(voorwaarde)(?:dit|dat|andere)|anders-clausule)

De <-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt.
Zie perlre.

Schakelvoorwaarde wordt niet herkend in regex; gemarkeerd door <-- HIER in m/%s/
(F) Het voorwaardegedeelte van een (?(condition)if-clause|else-clause) constructie is dat niet
bekend. De voorwaarde moet een van de volgende zijn:

(1) (2) ... waar als 1e, 2e, etc., opname overeenkomen
( ) ('NAAM') waar als de benoemde opname overeenkomt
(?=...) (?<=...) waar als subpatroon overeenkomt
(?!...) (?
(?{ CODE }) waar als de code een echte waarde retourneert
(R) waar bij evaluatie van binnenrecursie
(R1) (R2) ... waar indien direct binnen capture-groep 1, 2, etc.
(R&NAME) waar indien direct binnen benoemde opname
(DEFINE) altijd onwaar; voor het definiëren van benoemde subpatronen

De <-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt.
Zie perlre.

Switch (?(voorwaarde)... niet beëindigd in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je hebt nagelaten ergens in het patroon een (?(voorwaarde)...) blok te sluiten. Voeg een ... toe
haakje sluiten in de juiste positie. Zie perlre.

omschakeling effectief %s is niet geïmplementeerd
(F) Terwijl we onder het "gebruik filetest" pragma zijn, kunnen we de echte en effectieve niet veranderen
uids of gids.

syntax error
(F) Dit betekent waarschijnlijk dat er een syntaxisfout is opgetreden. Veel voorkomende redenen zijn:

Een trefwoord is verkeerd gespeld.
Er ontbreekt een puntkomma.
Er ontbreekt een komma.
Er ontbreekt een haakje voor openen of sluiten.
Er ontbreekt een openings- of sluitbeugel.
Een slotcitaat ontbreekt.

Vaak is er nog een foutmelding gekoppeld aan de syntaxisfout die meer oplevert
informatie. (Soms helpt het om aan te zetten -w.) De foutmelding zelf vaak
vertelt je waar het in de rij stond toen het besloot op te geven. Soms de werkelijke
fout is meerdere tokens hiervoor, omdat Perl goed is in het begrijpen van willekeurig
invoer. Af en toe kan het regelnummer misleidend zijn, en eens in de zoveel tijd kan het
De enige manier om erachter te komen wat de fout veroorzaakt, is door herhaaldelijk "perl -c" aan te roepen,
elke keer de helft van het programma weghakken om te zien of de fout verdween. Soort van
cybernetische versie van 20 vragen.

syntaxisfout op regel %d: '%s' onverwacht
(A) U hebt uw script per ongeluk via de Bourne-shell uitgevoerd in plaats van via Perl.
Controleer de #! regel, of voer uw script zelf handmatig in Perl in.

syntaxisfout in bestand %s op regel %d, volgende 2 tokens "%s"
(F) Deze fout treedt waarschijnlijk op als u een perl5-script via een perl4 uitvoert
interpreter, vooral als de volgende 2 tokens "use strict" of "my $var" of "our
$var".

Syntaxisfout in (?[...]) in regex m/%s/
(F) Perl kon er niet achter komen wat je bedoelde in deze constructie; dit meldt u
dat het het proberen opgeeft.

%s syntaxis OK
(F) Het laatste samenvattingsbericht wanneer een "perl -c" slaagt.

sysread() op gesloten bestandshandle %s
(W gesloten) U hebt geprobeerd te lezen van een gesloten bestandshandle.

sysread() op ongeopende bestandshandle %s
(W ongeopend) U hebt geprobeerd te lezen van een bestandshandle die nooit is geopend.

Systeem V %s is niet geïmplementeerd op deze machine
(F) Je hebt geprobeerd iets te doen met een functie die begint met "sem", "shm" of "msg"
maar dat System V IPC niet op uw machine is geïmplementeerd. Bij sommige machines is de
functionaliteit kan bestaan, maar is niet geconfigureerd. Raadpleeg uw systeemondersteuning.

systeemschrijven() op gesloten bestandshandle %s
(W gesloten) De filehandle waarnaar u schrijft, is enige tijd geleden gesloten.
Controleer uw controlestroom.

"-T" en "-B" niet geïmplementeerd op bestandshandles
(F) Perl kan niet naar de stdio-buffer van filehandles kijken als het niets van uw gegevens weet
soort stdio. In plaats daarvan moet u een bestandsnaam gebruiken.

Doel van goto is te diep genest
(F) U hebt geprobeerd "goto" te gebruiken om een ​​label te bereiken dat te diep genest was voor Perl
bereik. Perl bewijst u een plezier door te weigeren.

telldir() geprobeerd op ongeldige dirhandle %s
(W io) De dirhandle die je probeerde telldir() is gesloten of niet echt een
dirhandle. Controleer uw controlestroom.

vertellen() op ongeopende filehandle
(W ongeopend) U hebt geprobeerd de vertellen() functie op een filehandle die een van beide was
nooit geopend of sindsdien gesloten.

Dat gebruik van $[ wordt niet ondersteund
(F) Toewijzing aan $[ is nu strikt omschreven en geïnterpreteerd als een compiler
richtlijn. Je zou er misschien maar één kunnen zeggen

$[ = 0;
$[ = 1;
...
lokaal $[ = 0;
lokaal $[ = 1;
...

Dit is om het probleem te voorkomen dat één module de arraybasis van onderaf verandert
per ongeluk een andere module. Zie "$[" in perlvar en arybase.

De bitsgewijze functie is experimenteel
(S experimenteel::bitwise) Deze waarschuwing wordt verzonden als u bitwise-operatoren gebruikt ("& | ^
~ &. |. ^. ~.") met de "bitwise"-functie ingeschakeld. Onderdruk eenvoudigweg de waarschuwing if
u de functie wilt gebruiken, maar weet dat u daarmee risico loopt
met behulp van een experimentele functie die in een toekomstige Perl-versie kan worden gewijzigd of verwijderd:

geen waarschuwingen "experimenteel::bitwise";
gebruik de functie "bitwise";
$x |.= $y;

De crypt() functie is niet geïmplementeerd vanwege overmatige paranoia.
(F) Configure kan het bestand niet vinden crypt() functie op uw machine, waarschijnlijk omdat
uw leverancier heeft het niet geleverd, waarschijnlijk omdat ze denken dat de Amerikaanse regering dat denkt
het is een geheim, of in ieder geval dat ze zullen blijven doen alsof het zo is. En als je
citeer mij daarover, ik zal het ontkennen.

De functie %s is niet geïmplementeerd
(F) De aangegeven functie is niet geïmplementeerd op deze architectuur, volgens de
onderzoeken van Configure.

De lexical_subs-functie is experimenteel
(S experimenteel::lexical_subs) Deze waarschuwing wordt verzonden als u een sub declareert met "mijn"
of "staat". Onderdruk eenvoudig de waarschuwing als u de functie wilt gebruiken, maar weet dat
Als u dit doet, loopt u het risico een experimentele functie te gebruiken die kan veranderen
of worden verwijderd in een toekomstige Perl-versie:

geen waarschuwingen "experimenteel::lexical_subs";
gebruik de functie "lexical_subs";
mijn sub foo { ... }

De regex_sets-functie is experimenteel
(S experimenteel::regex_sets) Deze waarschuwing wordt verzonden als u de syntaxis "(?[ ])" gebruikt
in een reguliere expressie. De details van deze functie kunnen worden gewijzigd. als jij
wilt gebruiken, maar weet dat u daarmee het risico loopt een
experimentele functie die in een toekomstige Perl-versie kan veranderen, kunt u dit doen
stil de waarschuwing:

geen waarschuwingen "experimenteel::regex_sets";

De handtekeningfunctie is experimenteel
(S experimenteel::signatures) Deze waarschuwing wordt verzonden als u de programma's van een subroutine uitpakt
argumenten met behulp van een handtekening. Onderdruk eenvoudigweg de waarschuwing als u gebruik wilt maken van de
functie, maar weet dat u daarbij het risico neemt om een ​​experimentele
functie die in een toekomstige Perl-versie kan worden gewijzigd of verwijderd:

geen waarschuwingen "experimenteel::handtekeningen";
gebruik de functie "handtekeningen";
sub foo ($links, $right) { ... }

De statistiek voorafgaand aan %s was geen lstat
(F) Het heeft geen zin om de huidige statistische buffer te testen op symbolische koppelingen als de
de laatste statistiek die naar de statbuffer schreef, ging al voorbij de symbolische link om naar de
echt bestand. Gebruik in plaats daarvan een echte bestandsnaam.

Het attribuut 'uniek' mag alleen worden toegepast op 'onze' variabelen
(F) Dit kenmerk werd nooit ondersteund in de declaraties 'mijn' of 'sub'.

Deze Perl kan CRTL-omgevingselementen (%s) niet resetten
Deze Perl kan geen CRTL-omgevingselementen instellen (%s=%s)
(W intern) Waarschuwingen eigen aan VMS. U heeft geprobeerd een element van . te wijzigen of te verwijderen
de interne omgevingsarray van de CRTL, maar uw exemplaar van Perl is niet gebouwd met een CRTL die
bevatte de setenv() functie. Je moet Perl opnieuw opbouwen met een CRTL die dat wel doet,
of herdefiniëren PERL_ENV_TABLES (zie perlvms) zodat de omgevingsarray niet het doelwit is
van de wijziging in %ENV die de waarschuwing veroorzaakte.

Deze Perl is niet gebouwd met ondersteuning voor gerandomiseerde hash-key traversal, maar zoiets
genaamd Perl_hv_rand_set().
(F) Iets heeft geprobeerd een interne API-aanroep te gebruiken die afhankelijk is van het feit dat Perl bestaat
gecompileerd met de standaardondersteuning voor gerandomiseerde hash-key traversal, maar deze Perl heeft dat wel
zonder deze samengesteld. U dient deze waarschuwing te melden aan de betreffende upstream
party, of compileer perl opnieuw met standaardopties.

keer niet uitgevoerd
(F) Jouw versie van de C-bibliotheek doet dat blijkbaar niet keer(). Ik vermoed dat je dat niet bent
draait op Unix.

"-T" staat op de #! regel, moet het ook op de opdrachtregel worden gebruikt
(X) De #! regel (of lokaal equivalent) in een Perl-script bevat de -T optie (of de
-t optie), maar Perl werd niet aangeroepen -T in zijn opdrachtregel. Dit is een fout
omdat, tegen de tijd dat Perl een -T in een script is het te laat om op de juiste manier te besmetten
alles uit de omgeving. Dus Perl geeft het op.

Als het Perl-script wordt uitgevoerd als een commando met behulp van de #! mechanisme (of zijn
lokaal equivalent), kan deze fout meestal worden opgelost door de #! lijn zodat de
-%C optie is een onderdeel van het eerste argument van Perl: wijzig bijvoorbeeld "perl -n -%c" in "perl -%c
-N".

Als het Perl-script wordt uitgevoerd als "perl-scriptnaam", dan wordt de -%C optie moet
verschijnen op de opdrachtregel: "perl -%c scriptnaam".

Naar%s: illegale mapping '%s'
(F) U heeft geprobeerd een aangepaste To-toewijzing voor te definiëren ik(), eerst, uc()of eerst ()
(of hun string-inline versies), maar je hebt een illegale mapping opgegeven. Zie "Gebruiker-
Gedefinieerde tekeneigenschappen" in perlunicode.

Te diep geneste ()-groepen
(F) Je sjabloon bevat ()-groepen met een belachelijk diep nestniveau.

Te weinig argumenten om te systeemcallen
(F) Er moet minstens één argument zijn systeemoproep() om de systeemaanroep op te geven
bel, gekke dilly.

Te weinig argumenten voor subroutine
(F) Een subroutine die een handtekening gebruikt, heeft minder argumenten ontvangen dan vereist door de
handtekening. De beller van de subroutine is vermoedelijk in gebreke is gebleven. Onhandig, dit
fout zal worden gerapporteerd op de locatie van de subroutine, niet die van de beller.

Te laat voor de optie "-%s".
(X) De #! regel (of lokaal equivalent) in een Perl-script bevat de -M, -m or -C
optie.

Bij -M en -m, is dit een fout omdat deze opties niet bedoeld zijn
gebruik interne scripts. Gebruik in plaats daarvan het 'gebruik'-pragma.

De -C optie werkt alleen als deze ook op de opdrachtregel is opgegeven (met hetzelfde
reeks letters of cijfers erna). Geef deze optie op in de opdracht
line, of, als uw systeem dit ondersteunt, maak uw script uitvoerbaar en voer het rechtstreeks uit
in plaats van het door te geven aan perl.

Te laat om %s blok uit te voeren
(W void) Een CHECK- of INIT-blok wordt gedefinieerd tijdens de eigenlijke looptijd, wanneer de
mogelijkheid om ze uit te voeren is al verstreken. Misschien laadt u een bestand met
"vereis" of "doen" wanneer u in plaats daarvan "gebruiken" zou moeten gebruiken. Of misschien moet je zetten
de "vereiste" of "doen" in een BEGIN-blok.

Te veel argumenten om te systeemcallen
(F) Perl ondersteunt maximaal slechts 14 argumenten systeemoproep().

Te veel argumenten voor %s
(F) De functie vereist minder argumenten dan u hebt opgegeven.

Te veel argumenten voor subroutine
(F) Een subroutine die een handtekening gebruikt, heeft meer argumenten ontvangen dan vereist door de
handtekening. De beller van de subroutine is vermoedelijk in gebreke is gebleven. Onhandig, dit
fout zal worden gerapporteerd op de locatie van de subroutine, niet die van de beller.

Te veel).
(A) Je hebt per ongeluk je script doorlopen csh in plaats van Perl. Controleer de #!
regel, of voer uw script zelf handmatig in Perl in.

Te veel ('s
(A) Je hebt per ongeluk je script doorlopen csh in plaats van Perl. Controleer de #!
regel, of voer uw script zelf handmatig in Perl in.

Volgend \ in regex m/%s/
(F) De reguliere expressie eindigt met een backslash zonder backslash. Backslash het. Zien
perl.

Transliteratiepatroon niet beëindigd
(F) De lexer kon het interne scheidingsteken van een tr/// of tr[][] of y/// of niet vinden
y[][] constructie. Het ontbreken van de voorafgaande "$" van de variabelen $tr of $y kan dit veroorzaken
fout.

Transliteratievervanging is niet beëindigd
(F) De lexer kon het laatste scheidingsteken van a tr///, tr[][], y/// of y[][] niet vinden
bouwen.

'%s' gevangen door bewerkingsmasker
(F) Je hebt geprobeerd een operator te gebruiken uit een veilig compartiment waarin dit niet is toegestaan.
Zie Veilig.

afkappen niet uitgevoerd
(F) Uw machine implementeert geen mechanisme voor het afkappen van bestanden dat Configure kent
over.

Type arg %d tot &CORE::%s moet %s zijn
(F) De subroutine in kwestie in het CORE-pakket vereist dat zijn argument hard is
verwijzing naar gegevens van het opgegeven type. Overbelasting wordt genegeerd, dus een verwijzing naar een
object dat niet van het opgegeven type is, maar toch overbelast is om het te verwerken,
zal nog steeds niet worden aanvaard.

Type arg %d tot %s moet %s zijn (niet %s)
(F) Deze functie vereist dat het argument in die positie van een bepaald type is.
Arrays moeten @NAME of "@{EXPR}" zijn. Hashes moeten %NAME of "%{EXPR}" zijn. Geen impliciete
het verwijderen van verwijzingen is toegestaan: gebruik de {EXPR}-formulieren als expliciete verwijdering van verwijzingen. Zien
perlref.

Het type argument voor %s moet unblessed hashref of arrayref zijn
(F) Je hebt "sleutels", "waarden" of "elk" aangeroepen met een scalair argument dat geen a was
verwijzing naar een ongezegende hash of array.

umask niet geïmplementeerd
(F) Uw machine implementeert de umask-functie niet en u hebt geprobeerd deze wel te gebruiken
beperk de rechten voor uzelf (EXPR & 0700).

Onevenwichtige context: %d meer PUSH's dan POP's
(S intern) De exitcode heeft een interne inconsistentie gedetecteerd in het aantal uitvoeringen
contexten werden ingevoerd en verlaten.

Ongebalanceerde saves: %d meer saves dan herstelingen
(S intern) De afsluitcode heeft een interne inconsistentie gedetecteerd in het aantal waarden
tijdelijk gelokaliseerd.

Ongebalanceerde scopes: %d meer ENTERs dan LEAVEs
(S intern) De exitcode heeft een interne inconsistentie gedetecteerd in het aantal blokken
binnengekomen en vertrokken.

Ongebalanceerde hertelling van de tekenreekstabel: (%d) voor "%s"
(S intern) Bij het afsluiten vond Perl enkele resterende strings in de gedeelde stringtabel
gebruikt voor kopiëren bij schrijven en voor hash-sleutels. De vermeldingen hadden moeten worden vrijgegeven, dus dit
geeft ergens een bug aan.

Ongebalanceerde tmps: %d meer toewijzingen dan vrijgaves
(S intern) De exitcode heeft een interne inconsistentie gedetecteerd in het aantal stervelingen
scalaren werden toegewezen en bevrijd.

Ongedefinieerd formaat "%s" aangeroepen
(F) Het aangegeven formaat lijkt niet te bestaan. Misschien zit het echt in een ander
pakket? Zie perlform.

Ongedefinieerde sorteersubroutine "%s" aangeroepen
(F) De opgegeven soortvergelijkingsroutine lijkt niet te bestaan. Misschien staat het in een
ander pakket? Zie "sorteren" in perlfunc.

Ongedefinieerde subroutine &%s aangeroepen
(F) De aangegeven subroutine is niet gedefinieerd, of als dat wel zo was, dan is dat sindsdien gebeurd
ongedefinieerd.

Ongedefinieerde subroutine opgeroepen
(F) De anonieme subroutine die u probeert op te roepen is niet gedefinieerd, of als dat wel het geval is,
het is sindsdien ongedefinieerd.

Ongedefinieerde subroutine in sortering
(F) De gespecificeerde sorteervergelijkingsroutine is gedeclareerd, maar lijkt niet zo te zijn geweest
nog niet gedefinieerd. Zie "sorteren" in perlfunc.

Ongedefinieerd topformaat "%s" aangeroepen
(F) Het aangegeven formaat lijkt niet te bestaan. Misschien zit het echt in een ander
pakket? Zie perlform.

Ongedefinieerde waarde toegewezen aan typeglob
(W misc) Er is een ongedefinieerde waarde toegewezen aan een typeglob, a la "*foo = undef". Dit
doet niets. Het is mogelijk dat je echt "undef *foo" bedoelt.

%s: Ongedefinieerde variabele
(A) Je hebt per ongeluk je script doorlopen csh in plaats van Perl. Controleer de #!
regel, of voer uw script zelf handmatig in Perl in.

Ongeëscapede linkeraccolade in regex is verouderd en wordt doorgegeven in regex; gemarkeerd met <-- HIER
in m/%s/
(D verouderd, regexp) Je hebt een letterlijk "{"-teken gebruikt in een reguliere expressie
patroon. U moet in plaats daarvan "\{" gebruiken, omdat een toekomstige versie van Perl
(voorlopig v5.26) zal dit als een syntaxisfout beschouwen. Als het patroon
scheidingstekens zijn ook accolades; elke overeenkomende rechter accolade ("}") moet ook worden geëscaped
vermijd verwarring met de parser, bijvoorbeeld

qr{abc\{def\}ghi}

unexec van %s naar %s mislukt!
(F) De unexec() routine mislukte om de een of andere reden. Neem contact op met uw plaatselijke FSF-vertegenwoordiger,
die het daar waarschijnlijk in de eerste plaats heeft neergezet.

Onverwachte binaire operator '%c' zonder voorgaande operand in regex; gemarkeerd met <-- HIER in
Mevr/
(F) Je had zoiets als dit:

(?[ | \p{Cijfer} ])

waar de "|" is een binaire operator met een operand aan de rechterkant, maar geen operand aan de
links.

Onverwacht teken in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je had zoiets als dit:

(?[z])

Binnen "(?[ ])" zijn geen letterlijke tekens toegestaan, tenzij ze binnen een inner
paar vierkante haakjes, zoals

(?[[z]])

Een andere mogelijkheid is dat u een backslash bent vergeten. Perl is niet slim genoeg om dit te bedenken
uit wat je werkelijk bedoelde.

Onverwachte invoer met constante lwaarde via type/targ %d:%d
(P) Bij het compileren van een subroutineaanroep in lvalue-context mislukte Perl een interne
consistentiecontrole. Er is een misvormde op-boom aangetroffen.

Onverwachte exit %u
(S) Uitgang() werd genoemd of het script op een andere manier netjes eindigde toen
"PERL_EXIT_WARN" is ingesteld in "PL_exit_flags".

Onverwachte afsluitfout %d
(S) Een ongepakte sterven () werd aangeroepen toen "PERL_EXIT_WARN" was ingesteld in "PL_exit_flags".

Onverwachte ')' in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je had zoiets als dit:

(?[ ( \p{Cijfer} + ) ])

De ")" is niet op zijn plaats. Blijkbaar moest er iets gecombineerd worden met de
cijfers, of de "+" zou er niet moeten zijn, of iets dergelijks. Perl kan het niet achterhalen
wat de bedoeling was.

Onverwachte '(' zonder voorafgaande operator in regex; gemarkeerd met <-- HIER in m/%s/
(F) Je had zoiets als dit:

(?[ \p{Cijfer} ( \p{Laotiaans} + \p{Thais} ) ])

Er moet een operator vóór de "(" staan, omdat er geen indicatie is hoe de
cijfers moeten worden gecombineerd met de karakters in het Laotiaanse en Thaise schrift.

Unicode-niet-teken U+%X is illegaal voor open uitwisseling
(S nonchar) Bepaalde codepunten, zoals U+FFFE en U+FFFF, worden gedefinieerd door de Unicode
standaard om niet-karakters te zijn. Dat zijn wettelijke codepunten, maar daar zijn ze voor gereserveerd
intern gebruik; toepassingen mogen dus niet proberen deze uit te wisselen. Een aanvraag mag
verwacht helemaal geen van deze karakters, en het ontvangen ervan kan tot bugs leiden.
Als u weet wat u doet, kunt u deze waarschuwing uitschakelen met 'geen waarschuwingen'
'nonchar';".

Dit is niet echt een "ernstige" fout, maar het zou zelfs standaard moeten gebeuren
als waarschuwingen niet zijn ingeschakeld, en momenteel is markeren de enige manier om dat in Perl te doen
het even ernstig.

Unicode-surrogaat U+%X is illegaal in UTF-8
(S surrogaat) U had een UTF-16-surrogaat in een context waarin deze niet in aanmerking worden genomen
aanvaardbaar. Deze codepunten, tussen U+D800 en U+DFFF (inclusief), worden gebruikt door
Unicode alleen voor UTF-16. Perl staat echter intern alle niet-ondertekende gehele code toe
punten (tot de maximale grootte die beschikbaar is op uw platform), inclusief surrogaten. Maar
deze kunnen problemen veroorzaken bij invoer of uitvoer, wat waarschijnlijk het geval is
bericht vandaan kwam. Als je echt weet wat je doet, kun je dit uitschakelen
waarschuwing door "geen waarschuwingen 'surrogaat';".

Onbekende karakternaam '%s'
(F) De naam die u in "\N{}" hebt gebruikt, is onbekend bij Perl. Controleer de spelling. Jij kan
zeg "use charnames ":loose"" om niet zo precies te hoeven zijn over spaties, koppeltekens en
hoofdlettergebruik op standaard Unicode-namen. (Alle aangepaste aliassen die zijn gemaakt
moet exact worden gespecificeerd, ongeacht of ":loose" wordt gebruikt of niet.) Deze fout
kan ook gebeuren als de "\N{}" niet binnen het bereik van de overeenkomstige valt
"gebruik charnames".

Onbekende fout
(P) Perl stond op het punt een foutmelding af te drukken in $@, maar de variabele $@ bestond niet,
zelfs na een poging om het te maken.

Onbekend Open() modus '%s'
(F) Het tweede argument van 3-argument Open() staat niet in de lijst met geldige modi:
"<", ">", ">>", "+<", "+>", "+>>", "-|", "|-", "<&", ">&".

Onbekende PerlIO-laag "%s"
(W-laag) Er is geprobeerd een onbekende laag op het Perl I/O-systeem te plaatsen.
(Lagen zorgen voor het transformeren van gegevens tussen externe en interne representaties.)
Houd er rekening mee dat sommige lagen, zoals "mmap", niet in alle omgevingen worden ondersteund. Als jouw
programma niet expliciet om de mislukte bewerking heeft gevraagd, kan dit het resultaat zijn van de
waarde van de omgevingsvariabele PERLIO.

Onbekend proces %x stuurde bericht naar prime_env_iter: %s
(P) Een fout die eigen is aan VMS. Perl las waarden voor %ENV voordat hij herhaalde
het, en iemand anders stopte een bericht in de gegevensstroom die Perl verwachtte. van iemand
erg verward, of misschien probeert Perl's populatie van %ENV te ondermijnen voor snode
praktische doeleinden.

Onbekende regex-modifier "%s"
(F) Alfanumerieke tekens onmiddellijk na het afsluitende scheidingsteken van een reguliere expressie
patroon worden door Perl geïnterpreteerd als modificatievlaggen voor de regex. Eén van die jij
opgegeven is ongeldig. Eén manier waarop dit kan gebeuren is als je geen witruimte hebt toegevoegd
tussen het einde van de regex en een volgende alfanumerieke operator:

als ($a =~ /foo/en $bar == 3) { ... }

De "a" is een geldige modificatievlag, maar de "n" niet, en veroorzaakt deze fout. Waarschijnlijk
wat in plaats daarvan werd bedoeld was:

if ($a =~ /foo/ en $bar == 3) { ... }

Onbekende "re" subpragma '%s' (bekende zijn: %s)
(W) Je hebt geprobeerd een onbekend subpragma van het 're'-pragma te gebruiken.

Onbekende schakelvoorwaarde (?(...)) in regex; gemarkeerd door <-- HIER in m/%s/
(F) Het voorwaardegedeelte van een (?(condition)if-clause|else-clause) constructie is dat niet
bekend. De voorwaarde moet een van de volgende zijn:

(1) (2) ... waar als 1e, 2e, etc., opname overeenkomen
( ) ('NAAM') waar als de benoemde opname overeenkomt
(?=...) (?<=...) waar als subpatroon overeenkomt
(?!...) (?
(?{ CODE }) waar als de code een echte waarde retourneert
(R) waar bij evaluatie van binnenrecursie
(R1) (R2) ... waar indien direct binnen capture-groep 1, 2, etc.
(R&NAME) waar indien direct binnen benoemde opname
(DEFINE) altijd onwaar; voor het definiëren van benoemde subpatronen

De <-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt.
Zie perlre.

Onbekende Unicode-optieletter '%c'
(F) U heeft een onbekende Unicode-optie opgegeven. Zie perlrun-documentatie van de "-C"
schakelaar voor de lijst met bekende opties.

Onbekende Unicode-optiewaarde %d
(F) U heeft een onbekende Unicode-optie opgegeven. Zie perlrun-documentatie van de "-C"
schakelaar voor de lijst met bekende opties.

Onbekend werkwoordpatroon '%s' in regex; gemarkeerd door <-- HIER in m/%s/
(F) U heeft een typefout gemaakt of u heeft verkeerd een "*"-kwantificator geplaatst na een open
zet je patroon vast. Controleer het patroon en bekijk perlre voor details over juridische werkwoorden
patronen.

Onbekende waarschuwingscategorie '%s'
(F) Een fout veroorzaakt door het "waarschuwingen"-pragma. U heeft een waarschuwingscategorie opgegeven
is op dit moment onbekend bij perl.

Merk op dat als u een waarschuwingscategorie wilt inschakelen die door een module is geregistreerd (bijvoorbeeld "use
waarschuwingen 'File::Find'"), moet u deze module eerst hebben geladen.

Ongeëvenaard '[' in POSIX-klasse in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je had zoiets als dit:

(?[[:cijfer: ])

Dat zou geschreven moeten worden:

(?[[:cijfer:] ])

Ongeëvenaard '%c' in POSIX-klasse in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je had zoiets als dit:

(?[[:alnum] ])

Er zou een tweede img moeten zijn, zoals deze:

(?[ [:alnum:] ])

Ongeëvenaard [ in regex; gemarkeerd door <-- HIER in m/%s/
(F) De haakjes rond een tekenklasse moeten overeenkomen. Als u een
sluithaakje in een tekenklasse, backslash of plaats het eerst. De <-- HIER
laat zien waar in de reguliere expressie het probleem is ontdekt. Zie perlre.

Ongeëvenaard ( in regex; gemarkeerd door <-- HIER in m/%s/
Ongeëvenaard ) in regex; gemarkeerd door <-- HIER in m/%s/
(F) Niet-backslashed haakjes moeten altijd in evenwicht zijn in reguliere expressies. Als
u een vi-gebruiker bent, is de %-toets waardevol voor het vinden van het overeenkomende haakje. De
<-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt. Zien
perl.

Ongeëvenaard rechter %s haakje
(F) De lexer telde dus meer sluitende gekrulde of vierkante haakjes dan openende
je mist waarschijnlijk een bijpassende openingsbeugel. Als algemene regel zul je merken
de ontbrekende (om zo te zeggen) in de buurt van de plaats waar je het laatst hebt bewerkt.

De niet-geciteerde tekenreeks "%s" kan conflicteren met een toekomstig gereserveerd woord
(W gereserveerd) Je hebt een blootwoord gebruikt dat ooit als gereserveerd woord zou kunnen worden geclaimd.
Het is het beste om zo'n woord tussen aanhalingstekens te zetten, of er op de een of andere manier een hoofdletter van te maken, of een
onderbalk erin. Je kunt het ook als een subroutine declareren.

Onbekend teken %s; gemarkeerd door <-- HIER na %s nabij kolom %d
(F) De Perl-parser heeft geen idee wat hij moet doen met het opgegeven teken in uw Perl
script (of eval) in de buurt van de opgegeven kolom. Misschien heb je geprobeerd een gecomprimeerd bestand uit te voeren
script, een binair programma of een map als een Perl-programma.

Onbekende escape \%c in karakterklasse in regex; gemarkeerd door <-- HIER in m/%s/
(F) U hebt een backslash-tekencombinatie gebruikt die niet door Perl inside wordt herkend
karakter klassen. Dit is een fatale fout wanneer de karakterklasse wordt gebruikt binnen "(?[
])".

Onbekende escape \%c in tekenklasse doorgegeven in regex; gemarkeerd met <-- HIER in
Mevr/
(W regexp) Je hebt een backslash-tekencombinatie gebruikt die niet wordt herkend door Perl
binnen karakterklassen. Het personage werd letterlijk begrepen, maar dit kan veranderen
in een toekomstige versie van Perl. De <-- HIER toont de locatie in de reguliere expressie
de ontsnapping werd ontdekt.

Onbekende ontsnapping \%c is doorgevoerd
(W misc) U hebt een backslash-tekencombinatie gebruikt die niet wordt herkend door Perl.
Het personage werd letterlijk opgevat, maar dit kan veranderen in een toekomstige versie van
Parel.

Onbekende escape \%s doorgegeven in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp) Je hebt een backslash-tekencombinatie gebruikt die niet wordt herkend door Perl.
De karakter(s) werden letterlijk opgevat, maar dit kan veranderen in een toekomstige versie van
Perl. De <-- HIER laat zien waar in de reguliere expressie de ontsnapping plaatsvond
ontdekt.

Onbekende signaalnaam "%s"
(F) U heeft een signaalnaam opgegeven voor de doden() functie die niet werd herkend. Inspraak
"kill -l" in uw shell om de geldige signaalnamen op uw systeem te zien.

Onbekende schakelaar: -%s (-h toont geldige opties)
(F) U heeft een illegale optie opgegeven voor Perl. Doe dat niet. (Als je denkt van niet
doe dat, controleer de #! lijn om te zien of deze namens u de slechte schakelaar levert.)

unshift bij referentie is experimenteel
(S experimenteel::autoderef) "unshift" met een scalair argument is experimenteel en mag
wijzigen of verwijderen in een toekomstige Perl-versie. Als u het risico wilt nemen om te gebruiken
deze functie, schakelt u eenvoudigweg deze waarschuwing uit:

geen waarschuwingen "experimenteel::autoderef";

Mislukte %s op bestandsnaam die nieuwe regel bevat
(W newline) Er is geprobeerd een bestandsbewerking uit te voeren op een bestandsnaam, maar die bewerking is mislukt.
WAARSCHIJNLIJK omdat de bestandsnaam een ​​nieuwe regel bevatte, WAARSCHIJNLIJK omdat je dat vergeten was
chomp() het uit. Zie "chomp" in perlfunc.

Niet-ondersteunde mapfunctie "%s" aangeroepen
(F) Uw machine ondersteunt dit niet opendir() en leesmap().

Niet-ondersteunde functie %s
(F) Deze machine implementeert de aangegeven functie blijkbaar niet. Ten minste,
Configure denkt van niet.

Niet-ondersteunde functievork
(F) Uw versie van het uitvoerbare bestand ondersteunt geen forking.

Merk op dat er onder sommige systemen, zoals OS/2, verschillende varianten van Perl kunnen zijn
uitvoerbare bestanden, waarvan sommige fork ondersteunen, andere niet. Probeer de naam die u belt te wijzigen
Perl door naar "perl_", "perl__", enzovoort.

Niet-ondersteunde scriptcodering %s
(F) Uw programmabestand begint met een Unicode Byte Order Mark (BOM) die dit aangeeft
een Unicode-codering hebben die Perl niet kan lezen.

Niet-ondersteunde socketfunctie "%s" aangeroepen
(F) Uw machine ondersteunt het Berkeley-socketmechanisme niet, althans dat is het
wat Configure dacht.

Onbeëindigde attributenlijst
(F) De lexer vond iets anders dan een eenvoudige identifier aan het begin van een
attribuut, en het was geen puntkomma of het begin van een blok. Misschien heb je beëindigd
de parameterlijst van het vorige attribuut te vroeg. Zie attributen.

Onbeëindigde attribuutparameter in attributenlijst
(F) De lexer zag een haakje openen (links) tijdens het ontleden van een attribuut
lijst, maar het overeenkomende haakje sluiten (rechts) is niet gevonden. Jij mag
moet u een backslash-teken toevoegen (of verwijderen) om uw haakjes in evenwicht te brengen. Zien
attributen.

Niet-beëindigd gecomprimeerd geheel getal
(F) Een argument om uit te pakken ("w",...) was incompatibel met het gecomprimeerde gehele getal van BER
formaat en kon niet worden geconverteerd naar een geheel getal. Zie "pack" in perlfunc.

Niet-afgesloten scheidingsteken voor dit document
(F) Dit bericht verschijnt wanneer een here-documentlabel eerst een aanhalingsteken bevat, maar
het laatste aanhalingsteken ontbreekt. Misschien schreef je:

<<"foe

in plaats van:

<<"foe"

Niet-beëindigd \g... patroon in regex; gemarkeerd door <-- HIER in m/%s/
Niet-beëindigd \g{...} patroon in regex; gemarkeerd door <-- HIER in m/%s/
(F) In een reguliere expressie had je een "\g" die niet werd gevolgd door een juiste groep
referentie. In het geval van "\g{" ontbreekt de afsluitende accolade; anders de "\g"
moet worden gevolgd door een geheel getal. Corrigeer het patroon en probeer het opnieuw.

Niet-beëindigde operator <>
(F) De lexer zag een linker hoekbeugel op een plek waar hij een term verwachtte, dus
hij zoekt naar de overeenkomstige haakse beugel en vindt deze niet. Kansen
heb je eerder in de regel enkele benodigde haakjes weggelaten, en bedoelde je echt a
"minder dan".

Onbeëindigd werkwoordpatroonargument in regex; gemarkeerd door <-- HIER in m/%s/
(F) U hebt een patroon gebruikt in de vorm "(*VERB:ARG)", maar u hebt het patroon niet beëindigd
met een ")". Corrigeer het patroon en probeer het opnieuw.

Onbeëindigd werkwoordpatroon in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je hebt een patroon gebruikt in de vorm "(*VERB)", maar je hebt het patroon niet afgesloten met een
")". Corrigeer het patroon en probeer het opnieuw.

Er is geprobeerd om de verbinding los te maken terwijl %d interne referenties nog steeds bestaan
(W untie) Een kopie van het object dat werd geretourneerd door "tie" (of "tied") was nog steeds geldig toen
"losmaken" werd genoemd.

Gebruik: POSIX::%s(%s)
(F) U hebt een POSIX-functie aangeroepen met onjuiste argumenten. Zie "FUNCTIES" in POSIX
voor meer informatie.

Gebruik: Win32::%s(%s)
(F) U hebt een Win32-functie aangeroepen met onjuiste argumenten. Zie Win32 voor meer
informatie.

$[ gebruikt in %s (bedoelde je $] ?)
(W-syntaxis) U hebt $[ gebruikt in een vergelijking, zoals:

als ($[> 5.006) {
...
}

Waarschijnlijk bedoelde je in plaats daarvan $] te gebruiken. $[ is de basis voor het indexeren van arrays. $] is de
Perl-versienummer in decimalen.

Gebruik "%s" in plaats van "%s"
(F) Het tweede genoemde construct is niet langer legaal. Gebruik in plaats daarvan de eerste.

Nutteloze toewijzing aan een tijdelijke
(W misc) Je hebt een lvalue-subroutine toegewezen, maar wat de subroutine retourneerde was a
tijdelijke scalair die op het punt stond te worden weggegooid, dus de toewijzing had geen effect.

Nutteloos (?-%s) - gebruik /%s modifier niet in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp) Je hebt een interne modifier gebruikt, zoals (?-o), die geen betekenis heeft tenzij
verwijderd uit de gehele regexp:

als ($string =~ /(?-o)$patroon/o) { ... }

moet worden geschreven als

als ($string =~ /$patroon/) { ... }

De <-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt.
Zie perlre.

Nutteloze lokalisatie van %s
(W-syntaxis) De lokalisatie van lwaarden zoals "local($x=10)" is legaal, maar in feite
the lokaal() heeft momenteel geen effect. Dit kan op een bepaald moment in de toekomst veranderen, maar
in de tussentijd wordt een dergelijke code afgeraden.

Nutteloos (?%s) - gebruik /%s modifier in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp) Je hebt een interne modifier gebruikt, zoals (?o), die geen betekenis heeft tenzij
toegepast op de gehele regexp:

als ($string =~ /(?o)$patroon/) { ... }

moet worden geschreven als

als ($string =~ /$patroon/o) { ... }

De <-- HIER laat zien waar in de reguliere expressie het probleem is ontdekt.
Zie perlre.

Nutteloos gebruik van attribuut "const"
(W misc) Het attribuut "const" heeft geen effect, behalve op anonieme sluitingsprototypes.
Je hebt het via attributes.pm op een subroutine toegepast. Dit is alleen nuttig binnen een
attribuuthandler voor een anonieme subroutine.

Nutteloos gebruik van de modifier /d in de transliteratie-operator
(W misc) U hebt de modifier /d gebruikt waarbij de zoeklijst dezelfde lengte heeft als de
vervangingslijst. Zie perlop voor meer informatie over de /d modifier.

Nutteloos gebruik van \E
(W overige) Je hebt een \E in een string met dubbele aanhalingstekens zonder een "\U", "\L" of "\Q"
eraan voorafgaan.

Nutteloos gebruik van hebzuchtmodifier '%c' in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp) Je hebt zoiets als dit opgegeven:

qr/a{3}?/
qr/b{1,1}+/

De "?" en "+" hebben geen enkel effect, omdat ze bepalen of er meer of minder overeenkomen
als er een keuze is, en door te specificeren dat het exact overeenkomt met een bepaald getal, is er geen
ruimte over voor een keuze.

Nutteloos gebruik van %s in lege context
(W void) Je hebt iets gedaan zonder bijeffect in een context waar je niets mee doet
de retourwaarde, zoals een instructie die geen waarde uit een blok retourneert, of de
linkerkant van een scalaire komma-operator. Heel vaak wijst dit niet op domheid van jou
deel, maar een onvermogen van Perl om uw programma te parseren zoals u dacht dat het zou doen. Voor
U krijgt dit bijvoorbeeld als u uw C-voorrang verwisselt met Python-voorrang en
zei

$één, $twee = 1, 2;

toen je het wilde zeggen

($één, $twee) = (1, 2);

Een andere veel voorkomende fout is het gebruik van gewone haakjes om een ​​lijstverwijzing te construeren
Als u bijvoorbeeld zegt, moet u vierkante of accolades gebruiken

$matrix = (1,2);

terwijl je dat had moeten zeggen

$matrix = [1,2];

De vierkante haakjes veranderen een lijstwaarde expliciet in een scalaire waarde, while
haakjes niet. Dus wanneer een lijst tussen haakjes wordt geëvalueerd in een scalaire context,
de komma wordt behandeld als de komma-operator van C, die het linkerargument weggooit,
dat is niet wat je wilt. Zie perlref voor meer informatie hierover.

Deze waarschuwing wordt niet gegeven voor numerieke constanten gelijk aan 0 of 1, aangezien dit wel het geval is
vaak gebruikt in uitspraken als

1 terwijl sub_with_side_effects();

Er wordt gewaarschuwd voor tekenreeksconstanten die normaal gesproken resulteren in 0 of 1.

Nutteloos gebruik van (?-p) in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp) De "p"-modifier kan niet worden uitgeschakeld zodra deze is ingesteld. Dat proberen is zinloos.

Nutteloos gebruik van 're'-pragma
(W) Je hebt "re gebruikt;" zonder enige argumenten. Dat is niet erg handig.

Nutteloos gebruik van sortering in scalaire context
(W void) Je hebt sortering in scalaire context gebruikt, zoals in:

mijn $x = sorteer @y;

Dit is niet erg nuttig, en perl optimaliseert dit momenteel.

Nutteloos gebruik van %s zonder waarden
(W-syntaxis) Je hebt de Duwen() or ontschuiven() functie zonder argumenten behalve de
array, zoals "push(@x)" of "unshift(@foo)". Dat zal doorgaans geen enkel effect hebben op de
array, dus volkomen nutteloos. Het is in principe mogelijk dat push(@tied_array)
kan enig effect hebben als de array is gekoppeld aan een klasse die een PUSH-methode implementeert.
Als dat zo is, kunt u dit schrijven als "push(@tied_array,())" om deze waarschuwing te vermijden.

'gebruik' is niet toegestaan ​​in de uitdrukking
(F) Het sleutelwoord "use" wordt herkend en uitgevoerd tijdens het compileren, en retourneert nee
nuttige waarde. Zie perlmod.

Het gebruik van toewijzing aan $[ is verouderd
(D verouderd) De variabele $[ (index van het eerste element in een array) is verouderd.
Zie "$[" in perlvar.

Het gebruik van kale << in de betekenis van <<"" is verouderd
(D verouderd) U wordt nu aangemoedigd om het expliciet geciteerde formulier te gebruiken als u dat wenst
gebruik een lege regel als terminator van het here-document.

Het gebruik van \b{} voor een niet-UTF-8-landinstelling is verkeerd. Uitgaande van een UTF-8-landinstelling
(W-landinstelling) U matcht een reguliere expressie met behulp van landinstellingen en een Unicode
Er wordt aan de grens voldaan, maar de landinstelling is niet Unicode. Dit maakt niet
gevoel. Perl zal doorgaan, uitgaande van een Unicode (UTF-8) landinstelling, maar de resultaten zouden dat wel kunnen
we hebben het mis, behalve als de landinstelling ISO-8859-1 (Latin1) is, waar dit is
bericht is vals en kan worden genegeerd.

Gebruik van chdir('') of chdir(undef) as chdir() deprecated
(D verouderd) chdir() zonder argumenten is gedocumenteerd om te veranderen naar $ENV{HOME} of
$ENV{LOGDIR}. chdir(undef) en chdir('') delen dit gedrag, maar dat is het geval geweest
verouderd. In toekomstige versies zullen ze eenvoudigweg falen.

Zorg ervoor dat u controleert waar u naartoe gaat chdir() is gedefinieerd en niet leeg, anders jij
bevindt u zich mogelijk in uw thuismap.

Het gebruik van de modifier /c is zinloos in s///
(W regexp) Je hebt de modifier /c gebruikt bij een vervanging. De /c-modificator is dat niet
momenteel betekenisvol bij vervangingen.

Het gebruik van de modifier /c is zinloos zonder /g
(W regexp) Je hebt de modifier /c gebruikt met een regex-operand, maar je hebt de /g niet gebruikt
modificator. Momenteel heeft /c alleen betekenis als /g wordt gebruikt. (Dit kan veranderen in de
toekomst.)

Het gebruik van een kommaloze variabelenlijst is verouderd
(D verouderd) De waarden die u aan een indeling geeft, moeten worden gescheiden door komma's, niet alleen
uitgelijnd op een lijn.

gebruik van elk() op hash na invoeging zonder de hash-iterator opnieuw in te stellen resulteert in ongedefinieerd
gedrag
(S intern) Het gedrag van "each()" na het invoegen is niet gedefinieerd; het kan items overslaan,
of bezoek items meerdere keren. Overweeg om "keys()" te gebruiken in plaats van "each()".

Het gebruik van := voor een lege attributenlijst is niet toegestaan
(F) De constructie "mijn $x := 42" werd gebruikt om te parseren als equivalent aan "mijn $x : = 42"
(een lege attributenlijst toepassen op $x). Deze constructie is verouderd in 5.12.0,
en er is nu een syntaxisfout gemaakt, dus ":=" kan worden teruggevorderd als een nieuwe operator in
de toekomst.

Als je een lege attributenlijst nodig hebt, bijvoorbeeld in een codegenerator, voeg dan een spatie toe
vóór de "=.

Gebruik van vrijgekomen waarde in iteratie
(F) Misschien heb je de herhaalde array binnen de lus aangepast? Deze fout is doorgaans
veroorzaakt door code zoals de volgende:

@a = (3,4);
@a = () voor (1,2,@a);

Het is niet de bedoeling dat u arrays wijzigt terwijl ze worden herhaald. Voor snelheid
en om redenen van efficiëntie voert Perl intern geen volledige referentietelling uit
herhaalde items, dus het verwijderen van zo'n item midden in een iteratie veroorzaakt Perl
om een ​​bevrijde waarde te zien.

Het gebruik van *glob{FILEHANDLE} is verouderd
(D verouderd) U wordt nu aangemoedigd om het kortere *glob{IO}-formulier te gebruiken om toegang te krijgen tot het
filehandle-slot binnen een typeglob.

Het gebruik van de modifier /g is zinloos bij het splitsen
(W regexp) U hebt de modifier /g in het patroon gebruikt voor een "split"-operator. Sinds
"split" probeert altijd herhaaldelijk het patroon te matchen, de "/g" heeft geen effect.

Het gebruik van "goto" om in een constructie te springen is verouderd
(D verouderd) Het gebruik van "goto" om van een buitenste bereik naar een binnenste bereik te springen is
verouderd en moet worden vermeden.

Het gebruik van overgenomen AUTOLOAD voor niet-methode %s() is verouderd
(D verouderd) Als (ahem) toevallige functie worden "AUTOLOAD"-subroutines opgezocht
als methoden (met behulp van de @ISA-hiërarchie), zelfs als de subroutines die automatisch moesten worden geladen dat waren
aangeroepen als gewone functies (bijv. "Foo::bar()"), niet als methoden (bijv. "Foo->bar()" of
"$obj->bar()").

Deze bug zal in de toekomst worden verholpen door het opzoeken van methoden alleen voor methoden te gebruiken'
"AUTOLADEN". Er is echter een aanzienlijke basis van bestaande code die mogelijk wordt gebruikt
het oude gedrag. Daarom geeft Perl momenteel als tussenstap een optionele waarschuwing af
wanneer niet-methoden overgeërfde "AUTOLOAD"s gebruiken.

De eenvoudige regel is: overerving werkt niet bij het automatisch laden van niet-methoden. De
Een eenvoudige oplossing voor oude code is: in elke module die vroeger afhankelijk was van overerven
"AUTOLOAD" voor niet-methoden uit een basisklasse met de naam "BaseClass", voer "*AUTOLOAD = uit
\&BaseClass::AUTOLOAD" tijdens het opstarten.

In code die momenteel zegt: "gebruik AutoLoader; @ISA = qw(AutoLoader);" je moet verwijderen
AutoLoader van @ISA en wijzig "gebruik AutoLoader;" om "AutoLoader 'AUTOLOAD' te gebruiken;".

Gebruik van %s in printf-formaat wordt niet ondersteund
(F) U heeft geprobeerd een functie van printf te gebruiken die alleen toegankelijk is vanuit C. Dit
betekent meestal dat er een betere manier is om het in Perl te doen.

Het gebruik van %s is verouderd
(D verouderd) Het aangegeven construct wordt over het algemeen niet langer aanbevolen voor gebruik
omdat er een betere manier is om het te doen, en ook omdat de oude manier slechte kanten heeft
effecten.

Het gebruik van letterlijke controletekens in namen van variabelen is verouderd
Het gebruik van letterlijke, niet-grafische tekens in namen van variabelen is verouderd
(D verouderd) Het gebruik van letterlijke niet-grafische (inclusief besturings)tekens in de broncode
om te verwijzen naar de ^FOO-variabelen, zoals $^X en "${^GLOBAL_PHASE}" is nu verouderd.
(We gebruiken hier "^X" en "^G" voor de leesbaarheid. Ze vertegenwoordigen feitelijk het niet-afdrukbare
besturingstekens, respectievelijk codepunten 0x18 en 0x07; "^A" zou de betekenen
controleteken waarvan het codepunt 0x01 is.) Dit heeft alleen invloed op code als "$\cT", waar
"\cT" is een besturingselement in de broncode; "${"\cT"}" en $^T blijven geldig. Dingen die
zijn niet-controles en ook niet grafisch zijn NO-BREAK SPACE en SOFT HYPHEN, die dat wel waren
voorheen alleen toegestaan ​​om historische redenen.

Gebruik van -l op filehandle%s
(W io) Een filehandle vertegenwoordigt een geopend bestand, en toen u het bestand opende was het al geopend
voorbij elke symlink gegaan waarnaar u vermoedelijk probeert te zoeken. De operatie keerde terug
"ondef". Gebruik in plaats daarvan een bestandsnaam.

Het gebruik van mijn $_ is experimenteel
(S experimenteel::lexical_topic) Lexical $_ is een experimentele functie en het gedrag ervan
kan veranderen of zelfs verwijderd worden in een toekomstige release van perl. Zie de uitleg
onder "$_" in perlvar.

Het gebruik van %s op een handle zonder * is verouderd
(D verouderd) Je hebt 'tie', 'tied' of 'untie' gebruikt voor een scalair, maar die scalair gebeurt
om een ​​typeglob vast te houden, wat betekent dat de filehandle gebonden zal zijn. Als je een stropdas wilt binden
handle, gebruik dan een expliciete * zoals in "tie *$handle".

Dit was een al lang bestaande bug die in Perl 5.16 werd verwijderd, omdat er geen manier was om deze te koppelen
de scalair zelf toen deze een typeglob vasthield, en geen manier om een ​​scalair los te maken die een had gehad
typeglob eraan toegewezen. Als u dit bericht ziet, gebruikt u waarschijnlijk een oudere versie.

Gebruik van referentie "%s" als array-index
(W misc) U hebt geprobeerd een referentie als array-index te gebruiken; dit is waarschijnlijk niet wat jij bent
bedoel, omdat verwijzingen in numerieke context vaak enorme aantallen zijn, en dat is meestal het geval
geeft een programmeerfout aan.

Als je het echt meent, numificeer dan expliciet je referentie, zoals: $array[0+$ref].
Deze waarschuwing wordt echter niet gegeven bij overbelaste objecten, omdat u deze kunt overbelasten
de numificatie- en stringificatieoperatoren en dan weet je vermoedelijk wat je doet
zijn aan het doen.

Het gebruik van staat $_ is experimenteel
(S experimenteel::lexical_topic) Lexical $_ is een experimentele functie en het gedrag ervan
kan veranderen of zelfs verwijderd worden in een toekomstige release van perl. Zie de uitleg
onder "$_" in perlvar.

Het gebruik van besmette argumenten in %s is verouderd
(W taint, verouderd) Je hebt "system()" of "exec()" met meerdere argumenten opgegeven
en minstens één ervan is besmet. Vroeger was dit toegestaan, maar het wordt fataal
fout in een toekomstige versie van perl. Ontsmet je argumenten. Zie perlsec.

Gebruik van niet-geïnitialiseerde waarde%s
(W niet geïnitialiseerd) Er is een ongedefinieerde waarde gebruikt alsof deze al gedefinieerd was. Het was
geïnterpreteerd als een "" of een 0, maar misschien was het een vergissing. Om deze waarschuwing te onderdrukken
wijs een gedefinieerde waarde toe aan uw variabelen.

Om u te helpen erachter te komen wat ongedefinieerd was, zal perl proberen u de naam van het
variabele (indien aanwezig) die niet gedefinieerd was. In sommige gevallen kan het dit niet doen, dus ook
vertelt u in welke bewerking u de ongedefinieerde waarde hebt gebruikt. Houd er echter rekening mee dat perl
optimaliseert uw programma en de bewerking die in de waarschuwing wordt weergegeven, hoeft niet noodzakelijkerwijs te zijn
verschijnen letterlijk in uw programma. "that $foo" wordt bijvoorbeeld meestal geoptimaliseerd in
""that ". $foo", en de waarschuwing zal verwijzen naar de operator "concatenation (.)", zelfs
ook al is er geen "." in uw programma.

"gebruik re 'strikt'" is experimenteel
(S experimenteel::re_strict) De dingen die anders zijn bij een reguliere expressie
patroon is gecompileerd onder 'strikt', kan in toekomstige Perl-releases worden gewijzigd
onverenigbare manieren. Dit betekent dat een patroon dat vandaag wordt samengesteld, dat in de toekomst misschien niet meer zal zijn
Perl-uitgave. Deze waarschuwing is bedoeld om u op dat risico te wijzen.

Gebruik \x{...} voor meer dan twee hexadecimale tekens in regex; gemarkeerd door <-- HIER in m/%s/
(F) In een reguliere expressie zei je zoiets als

(?[ [\xBEEF ] ])

Perl weet niet zeker of je dit bedoelde

(?[ [ \x{RUNDVLEES} ] ])

of als je dit bedoelde

(?[ [ \x{BE} EF ] ])

U moet accolades of spaties toevoegen om het ondubbelzinnig te maken.

Alleen het eerste teken gebruiken dat wordt geretourneerd door \N{} in tekenklasse in regex; gemarkeerd door
<-- HIER in m/%s/
(W regexp) Genoemde Unicode-teken-escapes "(\N{...})" kunnen een uit meerdere tekens bestaand resultaat opleveren
reeks. Ook al zou een karakterklasse slechts bij één karakter moeten passen
input, zal perl het hele ding correct matchen, behalve wanneer de klasse wordt omgekeerd
("[^...]"), of de ontsnapping is het begin- of eindpunt van een bereik. Voor deze,
wat er moet gebeuren is helemaal niet duidelijk. In deze omstandigheden gooit Perl alles weg, behalve
het eerste teken van de geretourneerde reeks, wat waarschijnlijk niet is wat u zoekt.

Gebruik /u voor '%s' in plaats van /%s in regex; gemarkeerd door <-- HIER in m/%s/
(W regexp) U hebt een Unicode-grens ("\b{...}" of "\B{...}") gebruikt in een gedeelte van een
reguliere expressie waarbij de tekensetmodifiers "/a" of "/aa" van kracht zijn.
Deze twee modifiers duiden op een ASCII-interpretatie, en dit heeft geen zin
een Unicode-definitie. De gegenereerde reguliere expressie wordt zo gecompileerd dat de
grens gebruikt alle Unicode. Er wordt geen enkel ander deel van de reguliere expressie beïnvloed.

Het gebruik van !~ met %s heeft geen zin
(F) Het gebruik van de operator "!~" met "s///r", "tr///r" of "y///r" is momenteel gereserveerd
voor toekomstig gebruik, aangezien het exacte gedrag nog niet is vastgesteld. (Gewoon de
Booleaanse tegenovergestelde van de gewijzigde tekenreeks is meestal niet bijzonder nuttig.)

UTF-16-surrogaat U+%X
(S surrogaat) U had een UTF-16-surrogaat in een context waarin deze niet in aanmerking worden genomen
aanvaardbaar. Deze codepunten, tussen U+D800 en U+DFFF (inclusief), worden gebruikt door
Unicode alleen voor UTF-16. Perl staat echter intern alle niet-ondertekende gehele code toe
punten (tot de maximale grootte die beschikbaar is op uw platform), inclusief surrogaten. Maar
deze kunnen problemen veroorzaken bij invoer of uitvoer, wat waarschijnlijk het geval is
bericht vandaan kwam. Als je echt weet wat je doet, kun je dit uitschakelen
waarschuwing door "geen waarschuwingen 'surrogaat';".

Waarde van %s kan "0" zijn; testen met bepaald()
(W misc) In een voorwaardelijke expressie die je hebt gebruikt , <*> (glob), "each()", of
"readdir()" als een Booleaanse waarde. Elk van deze constructies kan de waarde "0" retourneren;
dat zou de voorwaardelijke uitdrukking onwaar maken, wat waarschijnlijk niet het geval is
bedoeld. Wanneer u deze constructies in voorwaardelijke expressies gebruikt, test dan hun waarden
met de operator "gedefinieerd".

Waarde van CLI-symbool "%s" te lang
(W misc) Een waarschuwing eigen aan VMS. Perl probeerde de waarde van een %ENV-element te lezen
uit een CLI-symbooltabel en vond een resulterende tekenreeks langer dan 1024 tekens.
De retourwaarde is afgekapt tot 1024 tekens.

waarden op referentie zijn experimenteel
(S experimenteel::autoderef) "waarden" met een scalair argument zijn experimenteel en mogen
wijzigen of verwijderen in een toekomstige Perl-versie. Als u het risico wilt nemen om te gebruiken
deze functie, schakelt u eenvoudigweg deze waarschuwing uit:

geen waarschuwingen "experimenteel::autoderef";

Variabele "%s" is niet beschikbaar
(W afsluiting) Tijdens het compileren probeert een innerlijke benoemde subroutine of eval dit te doen
een uiterlijk lexicaal vastleggen dat momenteel niet beschikbaar is. Dit kan gebeuren voor een van
twee redenen. Ten eerste kan het buitenste lexicale in een buitenste anoniem worden verklaard
subroutine die nog niet is gemaakt. (Houd er rekening mee dat benoemde subs worden gemaakt op
tijdens het compileren, terwijl tijdens runtime anonieme subs worden gemaakt.) Bijvoorbeeld:

sub { mijn $a; sub f { $a } }

Op het moment dat f wordt gemaakt, kan het de huidige waarde van $a niet vastleggen, aangezien de
anonieme subroutine is nog niet gemaakt. Omgekeerd levert het volgende geen a op
waarschuwing aangezien de anonieme subroutine inmiddels is gemaakt en live is:

sub { mijn $a; eval 'sub f { $a }' }->();

De tweede situatie wordt veroorzaakt doordat een eval toegang krijgt tot een variabele die is verdwenen
reikwijdte, bijvoorbeeld

sub-f {
mijn $a;
sub { evaluatie '$a' }
}
f()->();

Hier, wanneer de '$a' in de eval wordt gecompileerd, is f() momenteel niet aanwezig
uitgevoerd, dus $a kan niet worden vastgelegd.

Variabele "%s" wordt niet geïmporteerd%s
(S overige) Terwijl "gebruik strikt" van kracht was, verwees u naar een globale variabele die u
blijkbaar werd gedacht geïmporteerd uit een andere module, omdat er iets anders van de
dezelfde naam (meestal een subroutine) wordt door die module geëxporteerd. Het betekent meestal dat je zet
het verkeerde grappige teken op de voorkant van uw variabele.

Lookbehind met variabele lengte niet geïmplementeerd in regex m/%s/
(F) Lookbehind is alleen toegestaan ​​voor subexpressies waarvan de lengte vast is en bekend is
tijd compileren. Voor een positieve lookbehind kunt u de regex-constructie "\K" als een manier gebruiken
om de gelijkwaardige functionaliteit te verkrijgen. Zie "(?<=patroon) \K" in perlre.

Er zijn niet voor de hand liggende Unicode-regels onder "/i" die variabel kunnen overeenkomen, maar die u kunt gebruiken
zou het misschien niet denken. De subtekenreeks "ss" kan bijvoorbeeld overeenkomen met het enkele teken
LATIJNSE KLEINE LETTER SHARP S. Er zijn andere reeksen ASCII-tekens die dat wel kunnen
overeenkomen met enkele ligatuurtekens, zoals LATIN SMALL LIGATURE FFI-matching
"qr/ffi/i". Als u vanaf Perl v5.16 alleen om ASCII-overeenkomsten geeft, voegt u de
De "/aa"-modifier voor de regex sluit al deze niet voor de hand liggende overeenkomsten uit en krijgt dus
van dit bericht af. Je kunt ook "use re qw(/aa)" zeggen om "/aa" op alle reguliere bestanden toe te passen
expressies die binnen de reikwijdte ervan zijn gecompileerd. Zie re.

"%s" variabele %s maskeert eerdere aangifte in dezelfde %s
(W misc) Een variabele "mijn", "onze" of "status" is opnieuw gedeclareerd in het huidige bereik of
statement, waardoor alle toegang tot het vorige exemplaar effectief wordt geëlimineerd. Dit is
bijna altijd een typfout. Merk op dat de eerdere variabele nog steeds zal bestaan
tot het einde van de reikwijdte of totdat alle verwijzingen naar de afsluiting ervan zijn vernietigd.

Variabele syntaxis
(A) Je hebt per ongeluk je script doorlopen csh in plaats van Perl. Controleer de #!
regel, of voer uw script zelf handmatig in Perl in.

Variabele "%s" blijft niet gedeeld
(W sluiting) Een binnenste (geneste) genoemd subroutine verwijst naar een lexicale variabele
gedefinieerd in een buitenste benoemde subroutine.

Wanneer de binnenste subroutine wordt aangeroepen, ziet deze de waarde van de buitenste subroutine
variabel zoals het was vóór en tijdens de *eerste* oproep naar de buitenste subroutine; in deze
In dit geval, nadat de eerste oproep naar de buitenste subroutine is voltooid, worden de binnenste en de buitenste subroutine voltooid
subroutines zullen niet langer een gemeenschappelijke waarde voor de variabele delen. Met andere woorden: de
variabele wordt niet langer gedeeld.

Dit probleem kan meestal worden opgelost door de binnenste subroutine anoniem te maken, met behulp van de
"sub {}" syntaxis. Wanneer innerlijke anonieme subs die verwijzen naar variabelen in de buitenste
subroutines worden gemaakt, worden deze automatisch teruggezet naar de huidige waarden daarvan
variabelen.

vectorargument wordt niet ondersteund in alfaversies
(S printf) Het %vd (s)printf-formaat ondersteunt geen versieobjecten met alfadelen.

Werkwoordpatroon '%s' heeft een verplicht argument in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je hebt een werkwoordpatroon gebruikt dat een argument vereist. Geef een argument of vinkje
dat je het juiste werkwoord gebruikt.

Werkwoordpatroon '%s' heeft mogelijk geen argument in regex; gemarkeerd door <-- HIER in m/%s/
(F) Je hebt een werkwoordpatroon gebruikt waarvoor geen argument toegestaan ​​is. Verwijder het argument of
controleer of u het juiste werkwoord gebruikt.

Versienummer moet een constant getal zijn
(P) De poging om een ​​"use Module nn LIST"-instructie te vertalen naar het equivalent daarvan
"BEGIN"-blok heeft een interne inconsistentie met het versienummer gevonden.

Versiereeks '%s' bevat ongeldige gegevens; negeren: '%s'
(W misc) De versiereeks bevat aan het einde ongeldige tekens, namelijk zijnde
buiten beschouwing gelaten.

Waarschuwing: er is iets mis
(W) Je bent geslaagd waarschuwen() een lege string (het equivalent van "warn "") of je noemde het
zonder argumenten en $@ was leeg.

Waarschuwing: kan bestandshandgreep %s niet correct sluiten
(S) Het impliciete dichtbij() gedaan door een Open() kreeg een foutmelding op de dichtbij().
Dit geeft meestal aan dat uw bestandssysteem onvoldoende schijfruimte heeft.

Waarschuwing: kan de bestandshandle niet correct sluiten: %s
Waarschuwing: kan bestandshandle %s niet correct sluiten: %s
(S io) Er is een fout opgetreden toen Perl impliciet een bestandshandle sloot. Dit meestal
geeft aan dat uw bestandssysteem onvoldoende schijfruimte heeft.

Waarschuwing: het gebruik van "%s" zonder haakjes is dubbelzinnig
(Sambigu) Je hebt een unaire operator geschreven, gevolgd door iets dat op a lijkt
binaire operator die ook geïnterpreteerd had kunnen worden als een term of unaire operator.
Als u bijvoorbeeld weet dat de functie rand het standaardargument 1.0 heeft, en
jij schrijft

rand + 5;

je denkt misschien dat je hetzelfde hebt geschreven als

rand() + 5;

maar in werkelijkheid heb je dat wel

rand(+5);

Zet dus tussen haakjes om te zeggen wat je werkelijk bedoelt.

wanneer is experimenteel
(S experimenteel::smartmatch) "wanneer" hangt af van smartmatch, wat experimenteel is.
Bovendien zijn er verschillende speciale gevallen die misschien niet meteen voor de hand liggen, en
hun gedrag kan veranderen of zelfs worden verwijderd in een toekomstige release van perl. Zie de
uitleg onder "Experimentele details over gegeven en wanneer" in perlsyn.

Breed teken in %s
(S utf8) Perl ontmoette een breed teken (>255) terwijl het er geen verwachtte. Deze waarschuwing
is standaard ingeschakeld voor I/O (zoals afdrukken). De eenvoudigste manier om deze waarschuwing te onderdrukken is
eenvoudigweg om de laag ":utf8" aan de uitvoer toe te voegen, bijvoorbeeld "binmode STDOUT, ':utf8'".
Een andere manier om de waarschuwing uit te schakelen is door "geen waarschuwingen 'utf8';" toe te voegen. maar dat is vaak
dichter bij bedrog. Over het algemeen wordt verwacht dat u de filehandle expliciet markeert
met een codering, zie open en "binmode" in perlfunc.

Brede tekens (U+%X) in %s
(W-landinstelling) In een landinstelling van één byte (dat wil zeggen, een niet-UTF-8), een multi-byte
karakter tegenkwam. Perl beschouwt dit teken als de opgegeven Unicode
codepunt. Het combineren van niet-UTF-8-landinstellingen en Unicode is gevaarlijk. Bijna zeker
sommige karakters hebben twee verschillende representaties. Bijvoorbeeld in de ISO
8859-7 (Griekse) landinstelling, het codepunt 0xC3 vertegenwoordigt een hoofdlettergamma. Maar zo ook
doet 0x393. Dit maakt stringvergelijkingen onbetrouwbaar.

Je moet waarschijnlijk uitzoeken hoe dit multi-byte-teken in de war is geraakt met jouw
single-byte locale (of misschien dacht je dat je een UTF-8 locale had, maar Perl
is het daar niet mee eens).

Binnen []-lengte '%c' niet toegestaan
(F) Het aantal in de (uit)paksjabloon mag alleen worden vervangen door "[TEMPLATE]" als:
"SJABLOON" komt altijd overeen met hetzelfde aantal ingepakte bytes waaruit kan worden bepaald
alleen het sjabloon. Dit is niet mogelijk als het een van de codes @, /, U, u, bevat
w of een *-lengte. Ontwerp de sjabloon opnieuw.

schrijven() op gesloten bestandshandle %s
(W gesloten) De filehandle waarnaar u schrijft, is enige tijd geleden gesloten.
Controleer uw controlestroom.

%s "\x%X" wordt niet toegewezen aan Unicode
(S utf8) Bij het inlezen van verschillende coderingen probeert Perl alles in kaart te brengen
Unicode-tekens. De bytes die u inleest, zijn niet legaal in deze codering. Voor
voorbeeld

utf8 "\xE4" wordt niet toegewezen aan Unicode

als je de a-diaereses Latin-1 probeert te lezen als UTF-8.

'X' buiten de tekenreeks
(F) U had een in- en uitpaksjabloon die een relatieve positie specificeerde vóór de
begin van de tekenreeks die wordt (uit)gepakt. Zie "pack" in perlfunc.

'x' buiten de string bij het uitpakken
(F) U had een pakketsjabloon die een relatieve positie specificeerde na het einde van de
string wordt uitgepakt. Zie "pack" in perlfunc.

JE HEBT SET-ID SCRIPTS IN DE KERNEL NOG NIET UITGESCHAKELD!
(F) En dat zul je waarschijnlijk nooit doen, omdat je waarschijnlijk niet over de bronnen beschikt
kernel, en uw leverancier geeft waarschijnlijk niets om wat u wilt. Je beste
je kunt wedden dat je een setuid C-wrapper rond je script plaatst.

Je moet "%s" citeren
(W-syntaxis) U hebt een blootwoord toegewezen als naam van de signaalbehandelaar. Helaas jij
Er is al een subroutine met die naam gedeclareerd, wat betekent dat Perl 5 dat zal proberen
roep de subroutine aan wanneer de opdracht wordt uitgevoerd, wat waarschijnlijk niet is wat u doet
wil. (Als het IS wat je wilt, zet dan een & vooraan.)

Jouw willekeurige getallen zijn niet zo willekeurig
(F) Toen Perl probeerde de willekeurige Seed voor hashes te initialiseren, kon hij er geen krijgen
willekeur uit uw systeem. Dit duidt meestal op iets heel erg mis.

Nullengte \N{} in regex; gemarkeerd door <-- HIER in m/%s/
(F) Benoemde Unicode-teken-escapes ("\N{...}") kunnen een reeks met lengte nul retourneren.
Een dergelijke ontsnapping werd gebruikt in een uitgebreide karakterklasse, dat wil zeggen "(?[...])", wat niet het geval is
toegestaan. Controleer of de juiste escape is gebruikt en de juiste charnames
behandelaar valt onder de reikwijdte. De <-- HIER toont de locatie in de reguliere expressie the
probleem werd ontdekt.

Gebruik perldiag online met behulp van onworks.net-services