do so. Such arrays are not even supposed to be accessible to
Perl code, but are only used internally.
-=item Cannot yet reorder sv_catpvfn() arguments from va_list
+=item Cannot yet reorder sv_vcatpvfn() arguments from va_list
-(F) Some XS code tried to use C<sv_catpvfn()> or a related function with a
+(F) Some XS code tried to use C<sv_vcatpvfn()> or a related function with a
format string that specifies explicit indexes for some of the elements, and
using a C-style variable-argument list (a C<va_list>). This is not currently
supported. XS authors wanting to do this must instead construct a C array
(S inplace) The creation of the new file failed for the indicated
reason.
-=item Can't do inplace edit without backup
-
-(F) You're on a system such as MS-DOS that gets confused if you try
-reading from a deleted (but still opened) file. You have to say
-C<-i.bak>, or some such.
-
=item Can't do inplace edit: %s would not be unique
(S inplace) Your filesystem does not support filenames longer than 14
subroutine or package before the current location. You can use an empty
"sub foo;" or "package FOO;" to enter a "forward" declaration.
-=item dump() better written as CORE::dump(). dump() will no longer be available in Perl 5.30
-
-(D deprecated, misc) You used the obsolescent C<dump()> built-in function,
-without fully qualifying it as C<CORE::dump()>. Maybe it's a typo.
+=item dump() must be written as CORE::dump() as of Perl 5.30
-Use of a unqualified C<dump()> was deprecated in Perl 5.8.0, and this
-will not be available in Perl 5.30.
+(F) You used the obsolete C<dump()> built-in function. That was deprecated in
+Perl 5.8.0. As of Perl 5.30 it must be written in fully qualified format:
+C<CORE::dump()>.
See L<perlfunc/dump>.
=item Empty \%c in regex; marked by S<<-- HERE> in m/%s/
+=item Empty \%c{}
+
=item Empty \%c{} in regex; marked by S<<-- HERE> in m/%s/
-(F) C<\p> and C<\P> are used to introduce a named Unicode property, as
-described in L<perlunicode> and L<perlre>. You used C<\p> or C<\P> in
-a regular expression without specifying the property name.
+(F) You used something like C<\b{}>, C<\B{}>, C<\o{}>, C<\p>, C<\P>, or
+C<\x> without specifying anything for it to operate on.
+
+Unfortunately, for backwards compatibility reasons, an empty C<\x> is
+legal outside S<C<use re 'strict'>> and expands to a NUL character.
+
+=item Empty (?) without any modifiers in regex; marked by <-- HERE in m/%s/
+
+(W regexp) (only under C<S<use re 'strict'>>)
+C<(?)> does nothing, so perhaps this is a typo.
=item ${^ENCODING} is no longer supported
(F) Named Unicode character escapes (C<\N{...}>) may return a
multi-character sequence. Even though a character class is
supposed to match just one character of input, perl will match the
-whole thing correctly, except when the class is inverted (C<[^...]>),
-or the escape is the beginning or final end point of a range. The
-mathematically logical behavior for what matches when inverting
-is very different from what people expect, so we have decided to
-forbid it. Similarly unclear is what should be generated when the
-C<\N{...}> is used as one of the end points of the range, such as in
+whole thing correctly, except under certain conditions. These currently
+are
- [\x{41}-\N{ARABIC SEQUENCE YEH WITH HAMZA ABOVE WITH AE}]
-
-What is meant here is unclear, as the C<\N{...}> escape is a sequence
-of code points, so this is made an error.
-
-=item \N{NAME} must be resolved by the lexer in regex; marked by
-S<<-- HERE> in m/%s/
+=over 4
-(F) When compiling a regex pattern, an unresolved named character or
-sequence was encountered. This can happen in any of several ways that
-bypass the lexer, such as using single-quotish context, or an extra
-backslash in double-quotish:
+=item When the class is inverted (C<[^...]>)
- $re = '\N{SPACE}'; # Wrong!
- $re = "\\N{SPACE}"; # Wrong!
- /$re/;
+The mathematically logical behavior for what matches when inverting
+is very different from what people expect, so we have decided to
+forbid it.
-Instead, use double-quotes with a single backslash:
+=item The escape is the beginning or final end point of a range
- $re = "\N{SPACE}"; # ok
- /$re/;
+Similarly unclear is what should be generated when the
+C<\N{...}> is used as one of the end points of the range, such as in
-The lexer can be bypassed as well by creating the pattern from smaller
-components:
+ [\x{41}-\N{ARABIC SEQUENCE YEH WITH HAMZA ABOVE WITH AE}]
- $re = '\N';
- /${re}{SPACE}/; # Wrong!
+What is meant here is unclear, as the C<\N{...}> escape is a sequence
+of code points, so this is made an error.
-It's not a good idea to split a construct in the middle like this, and
-it doesn't work here. Instead use the solution above.
+=item In a regex set
-Finally, the message also can happen under the C</x> regex modifier when the
-C<\N> is separated by spaces from the C<{>, in which case, remove the spaces.
+The syntax S<C<(?[ ])>> in a regular expression yields a list of
+single code points, none can be a sequence.
- /\N {SPACE}/x; # Wrong!
- /\N{SPACE}/x; # ok
+=back
=item No %s allowed while running setuid
not recognized. Say C<kill -l> in your shell to see the valid signal
names on your system.
+=item No Unicode property value wildcard matches:
+
+(W regexp) You specified a wildcard for a Unicode property value, but
+there is no property value in the current Unicode release that matches
+it. Check your spelling.
+
=item Not a CODE reference
(F) Perl was trying to evaluate a reference to a code value (that is, a
of Perl. Check the #! line, or manually feed your script into Perl
yourself.
-=item (?[...]) not valid in locale in regex; marked by S<<-- HERE> in m/%s/
-
-(F) C<(?[...])> cannot be used within the scope of a C<S<use locale>> or with
-an C</l> regular expression modifier, as that would require deferring
-to run-time the calculation of what it should evaluate to, and it is
-regex compile-time only.
-
=item no UTC offset information; assuming local time is UTC
(S) A warning peculiar to VMS. Perl was unable to find the local
a number. This happens, for example with C<\o{}>, with no number between
the braces.
+=item Numeric format result too large
+
+(F) The length of the result of a numeric format supplied to sprintf()
+or printf() would have been too large for the underlying C function to
+report. This limit is typically 2GB.
+
=item Octal number > 037777777777 non-portable
(W portable) The octal number you specified is larger than 2**32-1
(F) The function indicated isn't implemented on this architecture,
according to the probings of Configure.
+=item The private_use feature is experimental
+
+(S experimental::private_use) This feature is actually a hook for future
+use.
+
=item The regex_sets feature is experimental
(S experimental::regex_sets) This warning is emitted if you
past the symlink to get to the real file. Use an actual filename
instead.
+=item The Unicode property wildcards feature is experimental
+
+(S experimental::uniprop_wildcards) This feature is experimental
+and its behavior may in any future release of perl. See
+L<perlunicode/Wildcards in Property Values>.
+
=item The 'unique' attribute may only be applied to 'our' variables
(F) This attribute was never supported on C<my> or C<sub> declarations.
subroutine has been aliased, the subroutine's original name will be shown,
regardless of what name the caller used.
+=item Too many nested open parens in regex; marked by <-- HERE in m/%s/
+
+(F) You have exceeded the number of open C<"("> parentheses that haven't
+been matched by corresponding closing ones. This limit prevents eating
+up too much memory. It is initially set to 1000, but may be changed by
+setting C<${^RE_COMPILE_RECURSION_LIMIT}> to some other value. This may
+need to be done in a BEGIN block before the regular expression pattern
+is compiled.
+
=item Too many )'s
(A) You've accidentally run your script through B<csh> instead of Perl.
raised by default even if warnings are not enabled, and currently
the only way to do that in Perl is to mark it as serious.
+=item Unicode property wildcard not terminated
+
+(F) A Unicode property wildcard looks like a delimited regular
+expression pattern (all within the braces of the enclosing C<\p{...}>.
+The closing delimtter to match the opening one was not found. If the
+opening one is escaped by preceding it with a backslash, the closing one
+must also be so escaped.
+
=item Unicode surrogate U+%X is illegal in UTF-8
(S surrogate) You had a UTF-16 surrogate in a context where they are
operators treat their operands as strings of bytes, and values beyond
0xFF are nonsensical in this context.
-This became fatal in Perl 5.28.
+Certain instances became fatal in Perl 5.28; others in perl 5.32.
-=item Use of strings with code points over 0xFF as arguments to C<vec>
-is deprecated. This will be a fatal error in Perl 5.32
+=item Use of strings with code points over 0xFF as arguments to vec is forbidden
-(D deprecated) You tried to use L<C<vec>|perlfunc/vec EXPR,OFFSET,BITS>
+(F) You tried to use L<C<vec>|perlfunc/vec EXPR,OFFSET,BITS>
on a string containing a code point over 0xFF, which is nonsensical here.
-Such usage will be a fatal error in Perl 5.32.
+This became fatal in Perl 5.32.
=item Use of tainted arguments in %s is deprecated
arguments. See L<perlsec>.
=item Use of unassigned code point or non-standalone grapheme for a
-delimiter will be a fatal error starting in Perl 5.30
+delimiter is not allowed
-(D deprecated)
+(F)
A grapheme is what appears to a native-speaker of a language to be a
character. In Unicode (and hence Perl) a grapheme may actually be
several adjacent characters that together form a complete grapheme. For
that circumflex to be delimiters of strings, patterns, I<etc>. When
displayed, the circumflex would look like it belongs to the character
just to the left of it. In order to move the language to be able to
-accept graphemes as delimiters, we have to deprecate the use of
+accept graphemes as delimiters, we cannot allow the use of
delimiters which aren't graphemes by themselves. Also, a delimiter must
already be assigned (or known to be never going to be assigned) to try
to future-proof code, for otherwise code that works today would fail to
L<non-character code points|perlunicode/Noncharacter code points>, nor
L<code points that are above the legal Unicode maximum|
perlunicode/Beyond Unicode code points>, those can be delimiters, and
-their use won't raise this warning.
+their use is legal.
=item Use of uninitialized value%s
=item Variable length lookbehind not implemented in regex m/%s/
-(F) Lookbehind is allowed only for subexpressions whose length is fixed and
+(F) B<This message no longer should be raised as of Perl 5.30.> It is
+retained in this document as a convenience for people using an earlier
+Perl version.
+
+In Perl 5.30 and earlier, lookbehind is allowed
+only for subexpressions whose length is fixed and
known at compile time. For positive lookbehind, you can use the C<\K>
regex construct as a way to get the equivalent functionality. See
L<(?<=pattern) and \K in perlre|perlre/\K>.
https://perl5.git.perl.org / perl5.git / blobdiff