to check the return value of your socket() call? See
L<perlfunc/accept>.
+=item Aliasing via reference is experimental
+
+(S experimental::refaliasing) This warning is emitted if you use
+a reference constructor on the left-hand side of an assignment to
+alias one variable to another. Simply suppress the warning if you
+want to use the feature, but know that in doing so you are taking
+the risk of using an experimental feature which may change or be
+removed in a future Perl version:
+
+ no warnings "experimental::refaliasing";
+ use feature "refaliasing";
+ \$x = \$y;
+
=item Allocation too large: %x
(X) You can't allocate more than 64K on an MS-DOS machine.
that expected a numeric value instead. If you're fortunate the message
will identify which operator was so unfortunate.
+Note that for the C<Inf> and C<NaN> (infinity and not-a-number) the
+definition of "numeric" is somewhat unusual: the strings themselves
+(like "Inf") are considered numeric, and anything following them is
+considered non-numeric.
+
=item Argument list not closed for PerlIO layer "%s"
(W layer) When pushing a layer with arguments onto the Perl I/O
(X) A general assertion failed. The file in question must be examined.
+=item Assigned value is not a reference
+
+(F) You tried to assign something that was not a reference to an lvalue
+reference (e.g., C<\$x = $y>). If you meant to make $x an alias to $y, use
+C<\$x = \$y>.
+
+=item Assigned value is not %s reference
+
+(F) You tried to assign a reference to a reference constructor, but the
+two references were not of the same type. You cannot alias a scalar to
+an array, or an array to a hash; the two types must match.
+
+ \$x = \@y; # error
+ \@x = \%y; # error
+ $y = [];
+ \$x = $y; # error; did you mean \$y?
+
=item Assigning non-zero to $[ is no longer possible
(F) When the "array_base" feature is disabled (e.g., under C<use v5.16;>)
(P) An internal request asked to add a hash entry to something that
wasn't a symbol table entry.
+=item Bad symbol for scalar
+
+(P) An internal request asked to add a scalar entry to something that
+wasn't a symbol table entry.
+
=item Bareword found in conditional
(W bareword) The compiler found a bareword where it expected a
(P) When starting a new thread or returning values from a thread, Perl
encountered an invalid data type.
+=item Both or neither range ends should be Unicode in regex; marked by
+<-- HERE in m/%s/
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+In a bracketed character class in a regular expression pattern, you
+had a range which has exactly one end of it specified using C<\N{}>, and
+the other end is specified using a non-portable mechanism. Perl treats
+the range as a Unicode range, that is, all the characters in it are
+considered to be the Unicode characters, and which may be different code
+points on some platforms Perl runs on. For example, C<[\N{U+06}-\x08]>
+is treated as if you had instead said C<[\N{U+06}-\N{U+08}]>, that is it
+matches the characters whose code points in Unicode are 6, 7, and 8.
+But that C<\x08> might indicate that you meant something different, so
+the warning gets raised.
+
=item Buffer overflow in prime_env_iter: %s
(W internal) A warning peculiar to VMS. While Perl was preparing to
(D deprecated) You called a function whose use is deprecated. See
the function's name in L<POSIX> for details.
+=item Cannot chr %f
+
+(F) You passed an invalid number (like an infinity or not-a-number) to C<chr>.
+
+=item Cannot compress %f in pack
+
+(F) You tried compressing an infinity or not-a-number as an unsigned
+integer with BER, which makes no sense.
+
=item Cannot compress integer in pack
-(F) An argument to pack("w",...) was too large to compress. The BER
-compressed integer format can only be used with positive integers, and you
-attempted to compress Infinity or a very large number (> 1e308).
+(F) An argument to pack("w",...) was too large to compress.
+The BER compressed integer format can only be used with positive
+integers, and you attempted to compress a very large number (> 1e308).
See L<perlfunc/pack>.
=item Cannot compress negative numbers in pack
(S io) You tried to apply an encoding that did not exist to a filehandle,
either with open() or binmode().
+=item Cannot pack %f with '%c'
+
+(F) You tried converting an infinity or not-a-number to an integer,
+which makes no sense.
+
+=item Cannot printf %f with '%c'
+
+(F) You tried printing an infinity or not-a-number as a character (%c),
+which makes no sense. Maybe you meant '%s', or just stringifying it?
+
=item Cannot set tied @DB::args
(F) C<caller> tried to set C<@DB::args>, but found it tied. Tying C<@DB::args>
characters and Perl was unable to create a unique filename during
inplace editing with the B<-i> switch. The file was ignored.
+=item Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".
+
+(W locale) You are 1) running under "C<use locale>"; 2) the current
+locale is not a UTF-8 one; 3) you tried to do the designated case-change
+operation on the specified Unicode character; and 4) the result of this
+operation would mix Unicode and locale rules, which likely conflict.
+Mixing of different rule types is forbidden, so the operation was not
+done; instead the result is the indicated value, which is the best
+available that uses entirely Unicode rules. That turns out to almost
+always be the original character, unchanged.
+
+It is generally a bad idea to mix non-UTF-8 locales and Unicode, and
+this issue is one of the reasons why. This warning is raised when
+Unicode rules would normally cause the result of this operation to
+contain a character that is in the range specified by the locale,
+0..255, and hence is subject to the locale's rules, not Unicode's.
+
+If you are using locale purely for its characteristics related to things
+like its numeric and time formatting (and not C<LC_CTYPE>), consider
+using a restricted form of the locale pragma (see L<perllocale/The "use
+locale" pragma>) like "S<C<use locale ':not_characters'>>".
+
+Note that failed case-changing operations done as a result of
+case-insensitive C</i> regular expression matching will show up in this
+warning as having the C<fc> operation (as that is what the regular
+expression engine calls behind the scenes.)
+
=item Can't do waitpid with flags
(F) This machine doesn't have either waitpid() or wait4(), so only
functioning as a class, but that package doesn't define that particular
method, nor does any of its base classes. See L<perlobj>.
+=item Can't locate object method "%s" via package "%s" (perhaps you forgot
+to load "%s"?)
+
+(F) You called a method on a class that did not exist, and the method
+could not be found in UNIVERSAL. This often means that a method
+requires a package that has not been loaded.
+
=item Can't locate package %s for @%s::ISA
(W syntax) The @ISA array contained the name of another package that
(F) Subroutines meant to be used in lvalue context should be declared as
such. See L<perlsub/"Lvalue subroutines">.
+=item Can't modify reference to %s in %s assignment
+
+(F) Only a limited number of constructs can be used as the argument to a
+reference constructor on the left-hand side of an assignment, and what
+you used was not one of them. See L<perlref/Assigning to References>.
+
+=item Can't modify reference to localized parenthesized array in list
+assignment
+
+(F) Assigning to C<\local(@array)> or C<\(local @array)> is not supported, as
+it is not clear exactly what it should do. If you meant to make @array
+refer to some other array, use C<\@array = \@other_array>. If you want to
+make the elements of @array aliases of the scalars referenced on the
+right-hand side, use C<\(@array) = @scalar_refs>.
+
+=item Can't modify reference to parenthesized hash in list assignment
+
+(F) Assigning to C<\(%hash)> is not supported. If you meant to make %hash
+refer to some other hash, use C<\%hash = \%other_hash>. If you want to
+make the elements of %hash into aliases of the scalars referenced on the
+right-hand side, use a hash slice: C<\@hash{@keys} = @those_scalar_refs>.
+
=item Can't msgrcv to read-only var
(F) The target of a msgrcv must be modifiable to be used as a receive
(P) An error peculiar to VMS. Perl thought stdin was a pipe, and tried
to reopen it to accept binary data. Alas, it failed.
+=item Can't represent character for Ox%X on this platform
+
+(F) There is a hard limit to how big a character code point can be due
+to the fundamental properties of UTF-8, especially on EBCDIC
+platforms. The given code point exceeds that. The only work-around is
+to not use such a large code point.
+
=item Can't reset %ENV on this system
(F) You called C<reset('E')> or similar, which tried to reset
=item Can't use %s for loop variable
-(F) Only a simple scalar variable may be used as a loop variable on a
-foreach.
+(P) The parser got confused when trying to parse a C<foreach> loop.
=item Can't use global %s in "%s"
discouraged, and will generate the warning (when enabled)
L</""\c%c" is more clearly written simply as "%s"">.
-=item Character in 'C' format overflow in pack
-
-(W pack) You tried converting an infinity or not-a-number to an
-unsigned character, which makes no sense. Perl behaved as if you
-tried to pack 0xFF.
-
-=item Character in 'c' format overflow in pack
-
-(W pack) You tried converting an infinity or not-a-number to a
-signed character, which makes no sense. Perl behaved as if you
-tried to pack 0xFF.
-
=item Character in 'C' format wrapped in pack
(W pack) You said
(D deprecated, regexp) The \C character class is deprecated, and will
become a compile-time error in a future release of perl (tentatively
-v5.24). This construct allows you to match a single byte of what makes up
-a multi-byte single UTF8 character, and breaks encapsulation. It is
-currently also very buggy. If you really need to process the individual
+v5.24). This construct allows you to match a single byte of what makes
+up a multi-byte single UTF8 character, and breaks encapsulation. It is
+currently also very buggy. If you really need to process the individual
bytes, you probably want to convert your string to one where each
underlying byte is stored as a character, with utf8::encode().
usually indicates a syntax error in dereferencing the constant value.
See L<perlsub/"Constant Functions"> and L<constant>.
+=item Constants from lexical variables potentially modified elsewhere are
+deprecated
+
+(D deprecated) You wrote something like
+
+ my $var;
+ $sub = sub () { $var };
+
+but $var is referenced elsewhere and could be modified after the C<sub>
+expression is evaluated. Either it is explicitly modified elsewhere
+(C<$var = 3>) or it is passed to a subroutine or to an operator like
+C<printf> or C<map>, which may or may not modify the variable.
+
+Traditionally, Perl has captured the value of the variable at that
+point and turned the subroutine into a constant eligible for inlining.
+In those cases where the variable can be modified elsewhere, this
+breaks the behavior of closures, in which the subroutine captures
+the variable itself, rather than its value, so future changes to the
+variable are reflected in the subroutine's return value.
+
+This usage is deprecated, because the behavior is likely to change
+in a future version of Perl.
+
+If you intended for the subroutine to be eligible for inlining, then
+make sure the variable is not referenced elsewhere, possibly by
+copying it:
+
+ my $var2 = $var;
+ $sub = sub () { $var2 };
+
+If you do want this subroutine to be a closure that reflects future
+changes to the variable that it closes over, add an explicit C<return>:
+
+ my $var;
+ $sub = sub () { return $var };
+
=item Constant subroutine %s redefined
(W redefine)(S) You redefined a subroutine which had previously
character name specified in the C<\N{...}> escape. Perhaps you
forgot to load the corresponding L<overload> pragma?.
+=item :const is experimental
+
+(S experimental::const_attr) The "const" attribute is experimental.
+If you want to use the feature, disable the warning with C<no warnings
+'experimental::const_attr'>, but know that in doing so you are taking
+the risk that your code may break in a future Perl version.
+
+=item :const is not permitted on named subroutines
+
+(F) The "const" attribute causes an anonymous subroutine to be run and
+its value captured at the time that it is cloned. Named subroutines are
+not cloned like this, so the attribute does not make sense on them.
+
=item Copy method did not return a reference
(F) The method which overloads "=" is buggy. See
have some other C<(?...)> construct inside your character class. See
L<perlrecharclass/Extended Bracketed Character Classes>.
+=item Experimental aliasing via reference not enabled
+
+(F) To do aliasing via references, you must first enable the feature:
+
+ no warnings "experimental::refaliasing";
+ use feature "refaliasing";
+ \$x = \$y;
+
=item Experimental subroutine signatures not enabled
(F) To use subroutine signatures, you must first enable them:
in any future release of perl. See the explanation under
L<perlsyn/Experimental Details on given and when>.
-=item Global symbol "%s" requires explicit package name
+=item Global symbol "%s" requires explicit package name (did you forget to
+declare "my %s"?)
(F) You've said "use strict" or "use strict vars", which indicates
that all variables must either be lexically scoped (using "my" or "state"),
(F) The parser has given up trying to parse the program after 10 errors.
Further error messages would likely be uninformative.
+=item Having more than one /%c regexp modifier is deprecated
+
+(D deprecated, regexp) You used the indicated regular expression pattern
+modifier at least twice in a string of modifiers. It is deprecated to
+do this with this particular modifier, to allow future extensions to the
+Perl language.
+
=item Hexadecimal float: exponent overflow
(W overflow) The hexadecimal floating point has a larger exponent
S<<-- HERE> in m/%s/
(W regexp) Named Unicode character escapes (C<\N{...}>) may return a
-zero-length sequence. When such an escape is used in a character class
-its behaviour is not well defined. Check that the correct escape has
-been used, and the correct charname handler is in scope.
+zero-length sequence. When such an escape is used in a character
+class its behavior is not well defined. Check that the correct
+escape has been used, and the correct charname handler is in scope.
=item Illegal binary digit %s
not valid character numbers, so it returns the Unicode replacement
character (U+FFFD).
-=item Invalid number (%f) in chr
-
-(W utf8) You passed an invalid number (like an infinity or
-not-a-number) to C<chr>. Those are not valid character numbers,
-so it return the Unicode replacement character (U+FFFD).
-
=item invalid option -D%c, use -D'' to see choices
(S debugging) Perl was called with invalid debugger flags. Call perl
(F) Your machine doesn't implement the sockatmark() functionality,
neither as a system call nor an ioctl call (SIOCATMARK).
+=item "%s" is more clearly written simply as "%s" in regex; marked by <-- HERE in m/%s/
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+You specified a character that has the given plainer way of writing it,
+and which is also portable to platforms running with different character
+sets.
+
=item $* is no longer supported
(D deprecated, syntax) The special variable C<$*>, deprecated in older
form of C<open> does not support pipes, such as C<open($pipe, '|-', @args)>.
Use the two-argument C<open($pipe, '|prog arg1 arg2...')> form instead.
+=item %s: loadable library and perl binaries are mismatched (got handshake key %p, needed %p)
+
+(P) A dynamic loading library C<.so> or C<.dll> was being loaded into the
+process that was built against a different build of perl than the
+said library was compiled against. Reinstalling the XS module will
+likely fix this error.
+
+=item Locale '%s' may not work well.%s
+
+(W locale) You are using the named locale, which is a non-UTF-8 one, and
+which Perl has determined is not fully compatible with Perl. The second
+C<%s> gives a reason.
+
+By far the most common reason is that the locale has characters in it
+that are represented by more than one byte. The only such locales that
+Perl can handle are the UTF-8 locales. Most likely the specified locale
+is a non-UTF-8 one for an East Asian language such as Chinese or
+Japanese. If the locale is a superset of ASCII, the ASCII portion of it
+may work in Perl.
+
+Some essentially obsolete locales that aren't supersets of ASCII, mainly
+those in ISO 646 or other 7-bit locales, such as ASMO 449, can also have
+problems, depending on what portions of the ASCII character set get
+changed by the locale and are also used by the program.
+The warning message lists the determinable conflicting characters.
+
+Note that not all incompatibilities are found.
+
+If this happens to you, there's not much you can do except switch to use a
+different locale or use L<Encode> to translate from the locale into
+UTF-8; if that's impracticable, you have been warned that some things
+may break.
+
+This message is output once each time a bad locale is switched into
+within the scope of C<S<use locale>>, or on the first possibly-affected
+operation if the C<S<use locale>> inherits a bad one. It is not raised
+for any operations from the L<POSIX> module.
+
=item localtime(%f) failed
(W overflow) You called C<localtime> with a number that it could not handle:
other cases where we can statically determine that arguments to
functions are missing, e.g. for the L<perlfunc/pack> function.
+=item Ranges of ASCII printables should be some subset of "0-9", "A-Z", or
+"a-z" in regex; marked by <-- HERE in m/%s/
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+Stricter rules help to find typos and other errors. Perhaps you didn't
+even intend a range here, if the C<"-"> was meant to be some other
+character, or should have been escaped (like C<"\-">). If you did
+intend a range, the one that was used is not portable between ASCII and
+EBCDIC platforms, and doesn't have an obvious meaning to a casual
+reader.
+
+ [3-7] # OK; Obvious and portable
+ [d-g] # OK; Obvious and portable
+ [A-Y] # OK; Obvious and portable
+ [A-z] # WRONG; Not portable; not clear what is meant
+ [a-Z] # WRONG; Not portable; not clear what is meant
+ [%-.] # WRONG; Not portable; not clear what is meant
+ [\x41-Z] # WRONG; Not portable; not obvious to non-geek
+
+(You can force portability by specifying a Unicode range, which means that
+the endpoints are specified by
+L<C<\N{...}>|perlrecharclass/Character Ranges>, but the meaning may
+still not be obvious.)
+The stricter rules require that ranges that start or stop with an ASCII
+character that is not a control have all their endpoints be the literal
+character, and not some escape sequence (like C<"\x41">), and the ranges
+must be all digits, or all uppercase letters, or all lowercase letters.
+
+=item Ranges of digits should be from the same group in regex; marked by
+<-- HERE in m/%s/
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+Stricter rules help to find typos and other errors. You included a
+range, and at least one of the end points is a decimal digit. Under the
+stricter rules, when this happens, both end points should be digits in
+the same group of 10 consecutive digits.
+
=item Missing argument to -%c
(F) The argument to the indicated command line switch must follow
(F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
+=item Missing right brace on \N{}
+
=item Missing right brace on \N{} or unescaped left brace after \N
(F) C<\N> has two meanings.
(F) Lexically scoped subroutines are not yet implemented. Don't try
that yet.
+=item "my" subroutine %s can't be in a package
+
+(F) Lexically scoped subroutines aren't in a package, so it doesn't make
+sense to try to declare one with a package qualifier on the front.
+
=item "my %s" used in sort comparison
(W syntax) The package variables $a and $b are used for sort comparisons.
it throwing an exception, use C<maybe::next::method>
or C<next::can>. See L<mro>.
+=item Non-finite repeat count does nothing
+
+(W numeric) You tried to execute the
+L<C<x>|perlop/Multiplicative Operators> repetition operator C<Inf> (or
+C<-Inf>) or C<NaN> times, which doesn't make sense.
+
=item Non-hex character in regex; marked by S<<-- HERE> in m/%s/
(F) In a regular expression, there was a non-hexadecimal character where
imagine. The sole exceptions to this are that zero padding will
take place when going past the end of the string when either
C<sysread()>ing a file, or when seeking past the end of a scalar opened
-for I/O (in anticipation of future reads and to imitate the behaviour
+for I/O (in anticipation of future reads and to imitate the behavior
with real files).
=item %s() on unopened %s
=item panic: pad_free po
-(P) An invalid scratch pad offset was detected internally.
+(P) A zero scratch pad offset was detected internally. An attempt was
+made to free a target that had not been allocated to begin with.
=item panic: pad_reset curpad, %p!=%p
=item panic: pad_sv po
-(P) An invalid scratch pad offset was detected internally.
+(P) A zero scratch pad offset was detected internally. Most likely
+an operator needed a target but that target had not been allocated
+for whatever reason.
=item panic: pad_swipe curpad, %p!=%p
command-line switch. (This output goes to STDOUT unless you've
redirected it with select().)
-=item (perhaps you forgot to load "%s"?)
+=item Perl API version %s of %s does not match %s
-(F) This is an educated guess made in conjunction with the message
-"Can't locate object method \"%s\" via package \"%s\"". It often means
-that a method requires a package that has not been loaded.
+(F) The XS module in question was compiled against a different incompatible
+version of Perl than the one that has loaded the XS module.
=item Perl folding rules are not up-to-date for 0x%X; please use the perlbug
utility to report; in regex; marked by S<<-- HERE> in m/%s/
parentheses is useless, since it will be replaced by the prototype
from the attribute before it's ever used.
-=item \p{} uses Unicode rules, not locale rules
-
-(W) You compiled a regular expression that contained a Unicode property
-match (C<\p> or C<\P>), but the regular expression is also being told to
-use the run-time locale, not Unicode. Instead, use a POSIX character
-class, which should know about the locale's rules.
-(See L<perlrecharclass/POSIX Character Classes>.)
-
-Even if the run-time locale is ISO 8859-1 (Latin1), which is a subset of
-Unicode, some properties will give results that are not valid for that
-subset.
-
-Here are a couple of examples to help you see what's going on. If the
-locale is ISO 8859-7, the character at code point 0xD7 is the "GREEK
-CAPITAL LETTER CHI". But in Unicode that code point means the
-"MULTIPLICATION SIGN" instead, and C<\p> always uses the Unicode
-meaning. That means that C<\p{Alpha}> won't match, but C<[[:alpha:]]>
-should. Only in the Latin1 locale are all the characters in the same
-positions as they are in Unicode. But, even here, some properties give
-incorrect results. An example is C<\p{Changes_When_Uppercased}> which
-is true for "LATIN SMALL LETTER Y WITH DIAERESIS", but since the upper
-case of that character is not in Latin1, in that locale it doesn't
-change when upper cased.
-
=item push on reference is experimental
(S experimental::autoderef) C<push> with a scalar argument is experimental
(W regexp) Minima should be less than or equal to maxima. If you really
want your regexp to match something 0 times, just put {0}.
-=item Quantifier unexpected on zero-length expression in regex; marked by <--
-HERE in m/%s/
+=item Quantifier unexpected on zero-length expression in regex m/%s/
(W regexp) You applied a regular expression quantifier in a place where
it makes no sense, such as on a zero-width assertion. Try putting the
"abc" provided that it is followed by three repetitions of "xyz" is
C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>.
-The <-- HERE shows whereabouts in the regular expression the problem was
-discovered.
-
=item Range iterator outside integer range
(F) One (or both) of the numeric arguments to the range operator ".."
=item Redundant argument in %s
(W redundant) You called a function with more arguments than other
-arguments you supplied indicated would be needed. Currently only
+arguments you supplied indicated would be needed. Currently only
emitted when a printf-type format required fewer arguments than were
supplied, but might be used in the future for e.g. L<perlfunc/pack>.
(W closed) The socket you're sending to got itself closed sometime
before now. Check your control flow.
+=item Sequence "\c{" invalid
+
+(F) These three characters may not appear in sequence in a
+double-quotish context. This message is raised only on non-ASCII
+platforms (a different error message is output on ASCII ones). If you
+were intending to specify a control character with this sequence, you'll
+have to use a different way to specify it.
+
=item Sequence (? incomplete in regex; marked by S<<-- HERE> in m/%s/
(F) A regular expression ended with an incomplete extension (?. The
forget to check the return value of your socket() call? See
L<perlfunc/setsockopt>.
+=item Setting ${^ENCODING} is deprecated
+
+(D deprecated) You assigned a non-C<undef> value to C<${^ENCODING}>.
+This is deprecated; see C<L<perlvar/${^ENCODING}>> for details.
+
=item Setting $/ to a reference to %s as a form of slurp is deprecated, treating as undef
-(W deprecated) You assigned a reference to a scalar to C<$/> where the
+(D deprecated) You assigned a reference to a scalar to C<$/> where the
referenced item is not a positive integer. In older perls this B<appeared>
to work the same as setting it to C<undef> but was in fact internally
different, less efficient and with very bad luck could have resulted in
instead, which does return. To suppress this warning, put the exec() in
a block by itself.
+=item "state" subroutine %s can't be in a package
+
+(F) Lexically scoped subroutines aren't in a package, so it doesn't make
+sense to try to declare one with a package qualifier on the front.
+
=item "state %s" used in sort comparison
(W syntax) The package variables $a and $b are used for sort comparisons.
eval "sub name { ... }";
}
+=item Subroutine "%s" will not stay shared
+
+(W closure) An inner (nested) I<named> subroutine is referencing a "my"
+subroutine defined in an outer named subroutine.
+
+When the inner subroutine is called, it will see the value of the outer
+subroutine's lexical subroutine as it was before and during the *first*
+call to the outer subroutine; in this case, after the first call to the
+outer subroutine is complete, the inner and outer subroutines will no
+longer share a common value for the lexical subroutine. In other words,
+it will no longer be shared. This will especially make a difference
+if the lexical subroutines accesses lexical variables declared in its
+surrounding scope.
+
+This problem can usually be solved by making the inner subroutine
+anonymous, using the C<sub {}> syntax. When inner anonymous subs that
+reference lexical subroutines in outer subroutines are created, they
+are automatically rebound to the current values of such lexical subs.
+
=item Substitution loop
(P) The substitution was looping infinitely. (Obviously, a substitution
The <-- HERE shows whereabouts in the regular expression the problem was
discovered. See L<perlre>.
+=item Switch (?(condition)... not terminated in regex; marked by
+S<<-- HERE> in m/%s/
+
+(F) You omitted to close a (?(condition)...) block somewhere
+in the pattern. Add a closing parenthesis in the appropriate
+position. See L<perlre>.
+
=item switching effective %s is not implemented
(F) While under the C<use filetest> pragma, we cannot switch the real
marked by <-- HERE in m/%s/
(D deprecated, regexp) You used a literal C<"{"> character in a regular
-expression pattern. You should change to use C<"\{"> instead, because a
+expression pattern. You should change to use C<"\{"> instead, because a
future version of Perl (tentatively v5.26) will consider this to be a
syntax error. If the pattern delimiters are also braces, any matching
right brace (C<"}">) should also be escaped to avoid confusing the parser,
The <-- HERE shows whereabouts in the regular expression the problem was
discovered. See L<perlre>.
+=item Useless use of attribute "const"
+
+(W misc) The "const" attribute has no effect except
+on anonymous closure prototypes. You applied it to
+a subroutine via L<attributes.pm|attributes>. This is only useful
+inside an attribute handler for an anonymous subroutine.
+
=item Useless use of /d modifier in transliteration operator
(W misc) You have used the /d modifier where the searchlist has the
=item Use of literal control characters in variable names is deprecated
-(D deprecated) Using literal control characters in the source to refer
-to the ^FOO variables, like C<$^X> and C<${^GLOBAL_PHASE}> is now
-deprecated. This only affects code like C<$\cT>, where \cT is a control in
-the source code: C<${"\cT"}> and C<$^T> remain valid.
+=item Use of literal non-graphic characters in variable names is deprecated
+
+(D deprecated) Using literal non-graphic (including control)
+characters in the source to refer to the ^FOO variables, like C<$^X> and
+C<${^GLOBAL_PHASE}> is now deprecated. (We use C<^X> and C<^G> here for
+legibility. They actually represent the non-printable control
+characters, code points 0x18 and 0x07, respectively; C<^A> would mean
+the control character whose code point is 0x01.) This only affects
+code like C<$\cT>, where C<\cT> is a control in the source code; C<${"\cT"}> and
+C<$^T> remain valid. Things that are non-controls and also not graphic
+are NO-BREAK SPACE and SOFT HYPHEN, which were previously only allowed
+for historical reasons.
=item Use of -l on filehandle%s
C<concatenation (.)> operator, even though there is no C<.> in
your program.
+=item "use re 'strict'" is experimental
+
+(S experimental::re_strict) The things that are different when a regular
+expression pattern is compiled under C<'strict'> are subject to change
+in future Perl releases in incompatible ways. This means that a pattern
+that compiles today may not in a future Perl release. This warning is
+to alert you to that risk.
+
=item Use \x{...} for more than two hex characters in regex; marked by
S<<-- HERE> in m/%s/
=item Using !~ with %s doesn't make sense
(F) Using the C<!~> operator with C<s///r>, C<tr///r> or C<y///r> is
-currently reserved for future use, as the exact behaviour has not
+currently reserved for future use, as the exact behavior has not
been decided. (Simply returning the boolean opposite of the
modified string is usually not particularly useful.)
the close(). This usually indicates your file system ran out of disk
space.
+=item Warning: unable to close filehandle properly: %s
+
+=item Warning: unable to close filehandle %s properly: %s
+
+(S io) An error occurred when Perl implicitly closed a filehandle. This
+usually indicates your file system ran out of disk space.
+
=item Warning: Use of "%s" without parentheses is ambiguous
(S ambiguous) You wrote a unary operator followed by something that
cheating. In general, you are supposed to explicitly mark the
filehandle with an encoding, see L<open> and L<perlfunc/binmode>.
+=item Wide character (U+%X) in %s
+
+(W locale) While in a single-byte locale (I<i.e.>, a non-UTF-8
+one), a multi-byte character was encountered. Perl considers this
+character to be the specified Unicode code point. Combining non-UTF8
+locales and Unicode is dangerous. Almost certainly some characters
+will have two different representations. For example, in the ISO 8859-7
+(Greek) locale, the code point 0xC3 represents a Capital Gamma. But so
+also does 0x393. This will make string comparisons unreliable.
+
+You likely need to figure out how this multi-byte character got mixed up
+with your single-byte locale (or perhaps you thought you had a UTF-8
+locale, but Perl disagrees).
+
=item Within []-length '%c' not allowed
(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]>
https://perl5.git.perl.org / perl5.git / blobdiff