=encoding euc-jp =head1 NAME =begin original perldeprecation - list Perl deprecations =end original perldeprecation - Perl ���ѻ�ͽ��ΰ��� =head1 DESCRIPTION =begin original The purpose of this document is to document what has been deprecated in Perl, and by which version the deprecated feature will disappear, or, for already removed features, when it was removed. =end original ����ʸ�����Ū�ϡ�Perl �Dz����ѻ�ͽ��ˤʤä������ɤΥС������� �ѻ�ͽ��ε�ǽ�����Ǥ����������뤤�ϴ��˺�����줿��ǽ�ˤĤ��Ƥϡ� ���ĺ�����줿����ʸ�񲽤��뤳�ȤǤ��� =begin original This document will try to discuss what alternatives for the deprecated features are available. =end original ����ʸ��ϡ��ѻ�ͽ��ε�ǽ�ˤĤ��Ƥɤ�����ذƤ����Ѳ�ǽ���ˤĤ��� �������褦�Ȥ��Ƥ��ޤ��� =begin original The deprecated features will be grouped by the version of Perl in which they will be removed. =end original �ѻ�ͽ��ε�ǽ�ϡ���������ͽ��� Perl �ΥС��������� ���롼��ʬ������Ƥ��ޤ��� =head2 Perl 5.34 =begin original There are no deprecations or fatalizations scheduled for Perl 5.34. =end original Perl 5.34 �Ƿײ褵��Ƥ����ѻ�ͽ�����̿Ū���顼���Ϥ���ޤ��� =head2 Perl 5.32 =head3 Constants from lexical variables potentially modified elsewhere (�쥭�������ѿ���������������Ū�ˤɤ�����Ǥ��ѹ���ǽ) =begin original You wrote something like =end original ���Τ褦�˽񤭤ޤ���: my $var; $sub = sub () { $var }; =begin original but $var is referenced elsewhere and could be modified after the C 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 or C, which may or may not modify the variable. =end original ������ $var �Ϥɤ����ǻ��Ȥ���Ƥ��ơ� C ����ɾ�����줿����ѹ�����뤫�⤷��ޤ��� ����ϡ�����Ū��¾�ξ�꤫���ѹ����줿�� (C<$var = 3>)�� �ѿ����ѹ����뤫�⤷��ʤ�������ʤ����⤷��ʤ� C �� C �Τ褦�ʱ黻�Ҥ䥵�֥롼����� �Ϥ���뤳�Ȥˤ��ޤ��� =begin original 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. =end original ����Ū�ˡ�Perl �Ϥ��λ������ѿ����ͤ���ª���ơ� ���֥롼����򥤥�饤�󲽲�ǽ��������Ѥ��ޤ��� �ѿ���¾�ξ����ѹ��Ǥ����硢����ϥ���������ο����񤤤�����ޤ�; ���֥롼����Ϥ����ͤǤϤʤ��ѿ����Τ�Τ���ª���뤫��Ǥ�; ���äơ�������ѿ��ؤ��ѹ��ϥ��֥롼������֤��ͤ�ȿ�Ǥ���ޤ��� =begin original If you intended for the subroutine to be eligible for inlining, then make sure the variable is not referenced elsewhere, possibly by copying it: =end original ���֥롼����򥤥�饤�󲽲�ǽ�ˤ��뤳�Ȥ�տޤ��Ƥ�����ϡ� �����餯���ԡ����뤳�Ȥˤ�äơ��ѿ����ɤ������ ���Ȥ���Ƥ��ʤ��褦�ˤ��Ƥ�������: my $var2 = $var; $sub = sub () { $var2 }; =begin original 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: =end original ���Υ��֥롼������Ĥ����ѿ��ξ�����ѹ���ȿ�Ǥ��륯��������ˤ��������ϡ� ����Ū�� C ���ɲä��Ƥ�������: my $var; $sub = sub () { return $var }; =begin original This usage was deprecated and as of Perl 5.32 is no longer allowed. =end original ���λ���ˡ���ѻ�ͽ��ǡ�Perl 5.32 �ʹߤǤϤ�Ϥ������ޤ��� =head3 Use of strings with code points over 0xFF as arguments to C (C �ΰ����Ȥ��� 0xFF ��Ķ���������֤�ʸ����λ���) =begin original C views its string argument as a sequence of bits. A string containing a code point over 0xFF is nonsensical. This usage is deprecated in Perl 5.28, and was removed in Perl 5.32. =end original C �Ϥ���ʸ���������ӥå���Ȥ��Ƹ��ޤ��� 0xFF ��Ķ���������֤�ޤ�ʸ����ϰ�̣������ޤ��� ���λ���ˡ�� Perl 5.28 ���ѻ�ͽ��ˤʤꡢ Perl 5.32 �Ǻ������ޤ����� =head3 Use of code points over 0xFF in string bitwise operators (�ӥå�ñ��ʸ����黻�ҤǤ� 0xFF ��Ķ���������֤λ���) =begin original The string bitwise operators, C<&>, C<|>, C<^>, and C<~>, treat their operands as strings of bytes. As such, values above 0xFF are nonsensical. Some instances of these have been deprecated since Perl 5.24, and were made fatal in 5.28, but it turns out that in cases where the wide characters did not affect the end result, no deprecation notice was raised, and so remain legal. Now, all occurrences either are fatal or raise a deprecation warning, so that the remaining legal occurrences became fatal in 5.32. =end original �ӥå�ñ��ʸ����黻�� C<&>, C<|>, C<^>, C<~> �ϡ����Υ��ڥ��ɤ� �Х��Ȥ�ʸ����Ȥ��ư����ޤ��� ���ä�0xFF ��Ķ�����ͤϰ�̣������ޤ��� ������������ Perl 5.24 �����ѻ�ͽ��ǡ�5.28 ����̿Ū���顼�ˤʤ�ޤ������� �磻��ʸ�����ǽ���̤˱ƶ���Ϳ���ʤ���硢 �ѻ�ͽ��ٹ�Ͻ��Ϥ��줺�����ä������ʤޤ޻ĤäƤ��뤳�Ȥ�ʬ����ޤ����� ���󡢤���������Ƥ���̿Ū���顼���ѻ�ͽ��ٹ𤬽Ф�褦�ˤʤꡢ �ĤäƤ��������ʾ��� 5.32 ����̿Ū���顼�ˤʤ�ޤ����� =begin original An example of this is =end original �������: "" & "\x{100}" =begin original The wide character is not used in the C<&> operation because the left operand is shorter. This now throws an exception. =end original �磻��ʸ���� C<&> �黻�ǤϻȤ��ޤ���; �����ڥ��ɤϤ��û������Ǥ��� �ɤ���ˤ���������㳰���ꤲ��褦�ˤʤ�ޤ����� =head3 hostname() doesn't accept any arguments (hostname() �ϰ�������ޤ���) =begin original The function C in the L module has always been documented to be called with no arguments. Historically it has not enforced this, and has actually accepted and ignored any arguments. As a result, some users have got the mistaken impression that an argument does something useful. To avoid these bugs, the function is being made strict. Passing arguments was deprecated in Perl 5.28 and became fatal in Perl 5.32. =end original L �⥸�塼��� C �ؿ��ϡ� �����ʤ��ǸƤӽФ����Ⱦ��ʸ�񲽤���Ƥ��ޤ����� ���Ū�ˤϤ���϶�������Ƥ��餺���ºݤ˰���������դ��ơ� ����̵�뤷�Ƥ��ޤ����� ��̤Ȥ��ơ�����������ͭ�ѤǤ���Ȥ����ְ�ä����ݤ� �����Υ桼������Ϳ���Ƥ��ޤ����� �����ΥХ����򤱤뤿��ˡ����δؿ��Ϥ�긷̩�ˤʤ�ޤ����� �������Ϥ��Τ� Perl 5.28 ���ѻ�ͽ��ˤʤꡢ Perl 5.32 ����̿Ū���顼�ˤʤ�ޤ����� =head3 Unescaped left braces in regular expressions (����ɽ����Υ��������פ���ʤ����椫�ä�) =begin original The simple rule to remember, if you want to match a literal C<{> character (U+007B C) in a regular expression pattern, is to escape each literal instance of it in some way. Generally easiest is to precede it with a backslash, like C<\{> or enclose it in square brackets (C<[{]>). If the pattern delimiters are also braces, any matching right brace (C<}>) should also be escaped to avoid confusing the parser, for example, =end original ����ɽ���ѥ�������ǥ�ƥ��� C<{> ʸ�� (U+007B C) �˥ޥå��󥰤�������硢 �Ф���٤�ñ��ʵ�§�ϡ����餫�η��Ǥ��줾��Υ�ƥ��ʼ��Τ� ���������פ��뤳�ȤǤ��� ����Ū�˺Ǥ��ñ����ˡ�ϡ�C<\{> �Τ褦�˵ե���å�������֤��뤫�� �礫�ä��ǰϤ� (C<[{]>) ���ȤǤ��� �ѥ�������ڤ�ʸ�����椫�ä��ʤ顢�㤨�Хѡ����κ�����򤱤뤿��ˡ� �ޥå��󥰤��뱦�椫�ä� (C<}>) �⥨�������פ���٤��Ǥ��� qr{abc\{def\}ghi} =begin original Forcing literal C<{> characters to be escaped will enable the Perl language to be extended in various ways in future releases. To avoid needlessly breaking existing code, the restriction is not enforced in contexts where there are unlikely to ever be extensions that could conflict with the use there of C<{> as a literal. A non-deprecation warning that the left brace is being taken literally is raised in contexts where there could be confusion about it. =end original ��ƥ��� C<{> ʸ���Υ��������פζ����ϡ� Perl ���줬����Υ�꡼�����͡�����ˡ�dz�ĥ�Ǥ���褦�ˤ��뤿��ˤ��ޤ��� ��¸�Υ����ɤ���ɬ�פ˲����Τ��򤱤뤿��ˡ��������¤ϡ� C<{> ���ƥ��Ȥ��ƻȤ����ȤȾ��ͤ����ĥ���ʤ���������ʬ�Ǥ� ��������ޤ��� ���椫�ä�����ƥ��˼���Ƥ���Ȥ������ѻ�ͽ��ٹ�ϡ� ���줬���𤹤뤫���Τ�ʤ�ʸ̮��ȯ�����ޤ��� =begin original Literal uses of C<{> were deprecated in Perl 5.20, and some uses of it started to give deprecation warnings since. These cases were made fatal in Perl 5.26. Due to an oversight, not all cases of a use of a literal C<{> got a deprecation warning. Some cases started warning in Perl 5.26, and were made fatal in Perl 5.30. Other cases started in Perl 5.28, and were made fatal in 5.32. =end original C<{> �Υ�ƥ��ʻ��Ѥ� Perl 5.20 ���ѻ�ͽ��ˤʤꡢ �����λ��ѤˤĤ��ƤϤ��λ������ѻ�ͽ��ٹ𤬽лϤ�Ƥ��ޤ��� �����ξ��� Perl 5.26 ����̿Ū���顼�ˤʤ�ޤ����� ���ᤴ���ˤ�ꡢ���ƤΥ�ƥ��� C<{> �λ��Ѥ��Ф����ѻ�ͽ��ٹ�� �Ф��Ƥ��ޤ���Ǥ����� �����ξ��� Perl 5.26 �Ƿٹ��ϤᡢPerl 5.30 ����̿Ū���顼�ˤʤ�ޤ����� ����¾�ξ��� Perl 5.28 �ǻϤᡢ5.32 ����̿Ū���顼�ˤʤ�ޤ����� =head3 In XS code, use of various macros dealing with UTF-8. (XS �����ɤǡ�UTF-8 �򰷤��͡��ʥޥ����λ���) =begin original The macros below now require an extra parameter than in versions prior to Perl 5.32. The final parameter in each one is a pointer into the string supplied by the first parameter beyond which the input will not be read. This prevents potential reading beyond the end of the buffer. C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, and C. =end original �����Υޥ����� Perl 5.32 ����������ɲäΰ�����ɬ�פˤʤ�ޤ����� ���줾��κǸ�ΰ����ϡ������Ķ�������Ϥ��ɤ߹��ޤ�ʤ����ǽ�ΰ����� ���ꤵ�줿ʸ����ؤΥݥ��󥿤Ǥ��� ����ϥХåե���������Ķ�����ɤ߹����ǽ�����ɤ��ޤ��� C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C. =begin original Since Perl 5.26, this functionality with the extra parameter has been available by using a corresponding macro to each one of these, and whose name is formed by appending C<_safe> to the base name. There is no change to the functionality of those. For example, C corresponds to C, and both now behave identically. All are documented in L and L. =end original Perl 5.26 ���顢�ɲäΰ����ε�ǽ�ϡ� �����Τ��줾����б�����١���̾�� C<_safe> ���ɲä�������̾���Υޥ����� �Ȥ����Ȥˤ�ä����Ѳ�ǽ�Ǥ��� �����ε�ǽ���ѹ��Ϥ���ޤ��� �㤨�С�C �� C ���б����� ������Ʊ�ͤ˿����񤦤褦�ˤʤ�ޤ����� ��������Ƥ� L �� L ��ʸ�񲽤���Ƥ��ޤ��� =begin original This change was originally scheduled for 5.30, but was delayed until 5.32. =end original �����ѹ������� 5.30 �˷ײ褵��Ƥ��ޤ�������5.32 �ޤDZ������ޤ����� =head3 C<< File::Glob::glob() >> was removed (C<< File::Glob::glob() >> �Ϻ������ޤ���) =begin original C<< File::Glob >> has a function called C<< glob >>, which just calls C<< bsd_glob >>. =end original C<< File::Glob >> �ϡ�ñ�� C<< bsd_glob >> ��ƤӽФ��ؿ� C<< glob >> ����äƤ��ޤ��� =begin original C<< File::Glob::glob() >> was deprecated in Perl 5.8. A deprecation message was issued from Perl 5.26 onwards, and the function has now disappeared in Perl 5.30. =end original C<< File::Glob::glob() >> �� Perl 5.8 ���ѻ�ͽ��ˤʤ�ޤ����� �ѻ�ͽ���å������� Perl 5.26 ������Ϥ���Ƥ��ơ� ���δؿ��� Perl 5.30 �Ǿ��Ǥ��ޤ����� =begin original Code using C<< File::Glob::glob() >> should call C<< File::Glob::bsd_glob() >> instead. =end original C<< File::Glob::glob() >> ��ȤäƤ��륳���ɤ������ C<< File::Glob::bsd_glob() >> ��ƤӽФ��٤��Ǥ��� =head2 Perl 5.30 =head3 C<< $* >> is no longer supported (C<< $* >> �Ϥ�Ϥ��б����ޤ���) =begin original Before Perl 5.10, setting C<< $* >> to a true value globally enabled multi-line matching within a string. This relique from the past lost its special meaning in 5.10. Use of this variable will be a fatal error in Perl 5.30, freeing the variable up for a future special meaning. =end original Perl 5.10 ������Ǥϡ�C<< $* >> �˿����ͤ����ꤹ��ȡ� ��Ĥ�ʸ�������ʣ���ԥޥå��󥰤򥰥����Х��ͭ���ˤ��ޤ��� ���β���ΰ�ʪ�� 5.10 �����̤ʰ�̣�򼺤��ޤ����� ��������̤ʰ�̣�Τ�����ѿ�������뤿��ˡ� �����ѿ��λ��Ѥ� Perl 5.30 ����̿Ū���顼�ˤʤ�ޤ��� =begin original To enable multiline matching one should use the C<< /m >> regexp modifier (possibly in combination with C<< /s >>). This can be set on a per match bases, or can be enabled per lexical scope (including a whole file) with C<< use re '/m' >>. =end original ʣ���ԥޥå��󥰤�ͭ���ˤ��뤿��ˤϡ� (�����餯 C<< /s >> ���Ȥ߹�碌��) C<< /m >> ����ɽ�������Ҥ�Ȥ��٤��Ǥ��� ����ϥޥå���������ꤷ���ꡢC<< use re '/m' >> �� (�ե��������Τ�ޤ�) �쥭�����륹������������ꤷ�������ޤ��� =head3 C<< $# >> is no longer supported (C<< $# >> �Ϥ�Ϥ��б����ޤ���) =begin original This variable used to have a special meaning -- it could be used to control how numbers were formatted when printed. This seldom used functionality was removed in Perl 5.10. In order to free up the variable for a future special meaning, its use will be a fatal error in Perl 5.30. =end original �����ѿ������̤ʰ�̣����äƤ��ޤ��� -- print �����Ȥ��ˤ����ĥե����ޥåȤ��뤫�����椹�뤿��˻Ȥ��Ƥ��ޤ����� ���ΤۤȤ�ɻȤ��ʤ���ǽ�� Perl 5.10 �Ǻ������ޤ����� ��������̤ʰ�̣�Τ�����ѿ�������뤿��ˡ� ���λ��Ѥ� Perl 5.30 ����̿Ū���顼�ˤʤ�ޤ��� =begin original To specify how numbers are formatted when printed, one is advised to use C<< printf >> or C<< sprintf >> instead. =end original print �����Ȥ��ˤ����ĥե����ޥåȤ���뤫����ꤹ��ˤϡ� ����� C<< printf >> �� C<< sprintf >> ��Ȥ����Ȥ򴫤�ޤ��� =head3 Assigning non-zero to C<< $[ >> is fatal (C<< $[ >> �ؤ��� 0 ����������̿Ū���顼�ˤʤ�ޤ�) =begin original This variable (and the corresponding C feature and L module) allowed changing the base for array and string indexing operations. =end original �����ѿ� (������б����� C ��ǽ�� L �⥸�塼��) �� �����ʸ�����ź������������ѹ����뤳�Ȥ��Ǥ��ޤ����� =begin original Setting this to a non-zero value has been deprecated since Perl 5.12 and throws a fatal error as of Perl 5.30. =end original ������� 0 ���ͤ����ꤹ��Τ� Perl 5.12 �����ѻ�ͽ��ˤʤꡢ Perl 5.30 ������̿Ū���顼���ꤲ�ޤ��� =head3 C<< File::Glob::glob() >> will disappear (C<< File::Glob::glob() >> �Ͼ��Ǥ��ޤ�) =begin original C<< File::Glob >> has a function called C<< glob >>, which just calls C<< bsd_glob >>. However, its prototype is different from the prototype of C<< CORE::glob >>, and hence, C<< File::Glob::glob >> should not be used. =end original C<< File::Glob >> �ˤ� C<< glob >> �Ȥ����ؿ������ꡢ �����ñ�� C<< bsd_glob >> ��ƤӽФ��ޤ��� �����������Υץ��ȥ����פ� C<< CORE::glob >> �ȰۤʤäƤ���Τǡ� C<< File::Glob::glob >> �ϻȤ��٤��ǤϤ���ޤ��� =begin original C<< File::Glob::glob() >> was deprecated in Perl 5.8. A deprecation message was issued from Perl 5.26 onwards, and the function will disappear in Perl 5.30. =end original C<< File::Glob::glob() >> �� Perl 5.8 ���ѻ�ͽ��ˤʤ�ޤ����� �ѻ�ͽ���å������� Perl 5.26 ������Ϥ����褦�ˤʤꡢ ���δؿ��� Perl 5.30 �Ǿ��Ǥ��ޤ��� =begin original Code using C<< File::Glob::glob() >> should call C<< File::Glob::bsd_glob() >> instead. =end original C<< File::Glob::glob() >> ��ȤäƤ��륳���ɤ������ C<< File::Glob::bsd_glob() >> ��ƤӽФ��٤��Ǥ��� =head3 Unescaped left braces in regular expressions (for 5.30) (����ɽ����Υ��������פ���ʤ����椫�ä�(5.30 ��)) =begin original See L above. =end original ���Ҥ� L �� ���Ȥ��Ƥ��������� =head3 Unqualified C (��������ʤ� C) =begin original Use of C instead of C was deprecated in Perl 5.8, and an unqualified C will no longer be available in Perl 5.30. =end original C ������� C �λ��Ѥ� Perl 5.8 ���ѻ�ͽ��ˤʤꡢ ��������ʤ� C �� Perl 5.30 �����ѤǤ��ʤ��ʤ�ޤ��� =begin original See L. =end original L �򻲾Ȥ��Ƥ��������� =head3 Using my() in false conditional. (���ξ��� my() ��Ȥ�) =begin original There has been a long-standing bug in Perl that causes a lexical variable not to be cleared at scope exit when its declaration includes a false conditional. Some people have exploited this bug to achieve a kind of static variable. To allow us to fix this bug, people should not be relying on this behavior. =end original Perl �ˤϡ���������ξ���ޤ�Ǥ����硢�������פ�Ф�Ȥ��� �쥭�������ѿ������ꥢ����ʤ��Ȥ���Ĺǯ�ΥХ�������ޤ��� �����ο͡��Ϥ�������Ū�ѿ���ã�����뤿��ˤ��ΥХ����Ѥ��Ƥ��ޤ����� �䤿�������ΥХ������Ǥ���褦�ˡ��͡��Ϥ��ο����񤤤� ��¸���ʤ��٤��Ǥ��� =begin original Instead, it's recommended one uses C variables to achieve the same effect: =end original ����ˡ�Ʊ�����̤�ã�����뤿��� C �ѿ���Ȥ����Ȥ򴫤�ޤ�: use 5.10.0; sub count {state $counter; return ++ $counter} say count (); # Prints 1 say count (); # Prints 2 =begin original C variables were introduced in Perl 5.10. =end original C �ѿ��� Perl 5.10 ��Ƴ������ޤ����� =begin original Alternatively, you can achieve a similar static effect by declaring the variable in a separate block outside the function, e.g., =end original ���뤤�ϡ��ؿ��γ�¦���̤Υ֥��å�������ѿ���������뤳�Ȥ� �����褦����Ū�ʸ��̤������ޤ�: sub f { my $x if 0; return $x++ } =begin original becomes =end original ����ϼ��Τ褦�ˤʤ�ޤ�: { my $x; sub f { return $x++ } } =begin original The use of C in a false conditional has been deprecated in Perl 5.10, and became a fatal error in Perl 5.30. =end original ���ξ��Ǥ� C �λ��Ѥ� Perl 5.10 ���ѻ�ͽ��ˤʤꡢ Perl 5.30 ����̿Ū���顼�ˤʤ�ޤ����� =head3 Reading/writing bytes from/to :utf8 handles. (:utf8 �ϥ�ɥ���Ф���Х����ɤ߽�) =begin original The sysread(), recv(), syswrite() and send() operators are deprecated on handles that have the C<:utf8> layer, either explicitly, or implicitly, eg., with the C<:encoding(UTF-16LE)> layer. =end original (����Ū���뤤�� C<:encoding(UTF-16LE)> �ؤΤ褦�˰���Ū�ɤ���Ǥ�) C<:utf8> �ؤ���ĥϥ�ɥ���Ф��� sysread(), recv(), syswrite(), send() �黻�Ҥ��ѻ�ͽ��Ǥ��� =begin original Both sysread() and recv() currently use only the C<:utf8> flag for the stream, ignoring the actual layers. Since sysread() and recv() do no UTF-8 validation they can end up creating invalidly encoded scalars. =end original sysread() �� recv() ��ξ���Ϻ��ΤȤ��� C<:utf8> �ե饰�� ���ȥ꡼��Τ�������˻Ȥ����ºݤ��ؤ�̵�뤷�ޤ��� sysread() �� recv() �� UTF-8 ���ڤ�Ԥ�ʤ��Τǡ� �����˥��󥳡��ɤ��줿��������뤳�Ȥˤʤ뤫���Τ�ޤ��� =begin original Similarly, syswrite() and send() use only the C<:utf8> flag, otherwise ignoring any layers. If the flag is set, both write the value UTF-8 encoded, even if the layer is some different encoding, such as the example above. =end original Ʊ�ͤˡ�syswrite() �� send() �� C<:utf8> �ե饰�Τߤ�Ȥ��� ����¾���ؤ�̵�뤷�ޤ��� �ե饰�����ꤵ��Ƥ���ȡ������ϡ����Ȥ��ؤ����Ҥ���Τ褦�� �ۤʤä����󥳡��ǥ��󥰤ξ��Ǥ⡢UTF-8 ���󥳡��ɤ��줿�ͤ�񤭹��ߤޤ��� =begin original Ideally, all of these operators would completely ignore the C<:utf8> state, working only with bytes, but this would result in silently breaking existing code. To avoid this a future version of perl will throw an exception when any of sysread(), recv(), syswrite() or send() are called on handle with the C<:utf8> layer. =end original ����Ū�ˤϡ������α黻�����Ƥϴ����� C<:utf8> �ξ��֤�̵�뤷�ơ� �Х��Ȥ��Ф��ƤΤ�ư������Ǥ����� ����ϴ�¸�Υ����ɤ���ۤ˲������Ȥˤʤ�ޤ��� ������򤱤뤿��ˡ�����ΥС������� Perl �Ǥ� sysread(), recv(), syswrite(), send() �� C<:utf8> �ؤ���ä� �ϥ�ɥ�ǸƤӽФ������㳰���ꤲ��ͽ��Ǥ��� =begin original In Perl 5.30, it will no longer be possible to use sysread(), recv(), syswrite() or send() to read or send bytes from/to :utf8 handles. =end original Perl 5.30 �ǡ�:utf8 �ϥ�ɥ�ǥХ��Ȥ��ɤ߽񤭤��뤿��� sysread(), recv(), syswrite(), send() ��Ȥ����ȤϤǤ��ʤ��ʤ�ޤ��� =head3 Use of unassigned code point or non-standalone grapheme for a delimiter. (���ڤ�ʸ���Ȥ���̤���������֤�����Ω���Ǥλ���) =begin original 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 example, there can be a base character, like "R" and an accent, like a circumflex "^", that appear to be a single character when displayed, with the circumflex hovering over the "R". =end original ���Ǥϡ�����Υͥ��ƥ��֥��ԡ������ˤȤä�ʸ���Τ褦�˸������ΤǤ��� Unicode (���ä� Perl) �Ǥϡ� ���Ǥϼºݤˤϸߤ��˴����ʽ��Ǥ�������뤤���Ĥ������ܤ��� ʸ�����⤷��ޤ��� �㤨�С�"R" �Τ褦�ʴ���ʸ���ȶ��ޥ�������� "^" �Τ褦�� ��������Ȥ��⤷��ޤ���; �����ɽ�������Ȥ��ˤ� "R" �ξ�˶��ޥ�������Ȥ�����ñ���ʸ���Ȥʤ�ޤ��� =begin original As of Perl 5.30, use of delimiters which are non-standalone graphemes is fatal, in order to move the language to be able to accept multi-character graphemes as delimiters. =end original Perl 5.30 ���顢����Ω���Ǥζ��ڤ�ʸ���Ȥ��Ƥλ��Ѥ���̿Ū���顼�Ǥ�; �����ʣ��ʸ�����Ǥ���ڤ�ʸ���Ȥ��Ƽ����������褦�˸���� ư��������Ǥ��� =begin original Also, as of Perl 5.30, delimiters which are unassigned code points but that may someday become assigned are prohibited. Otherwise, code that works today would fail to compile if the currently unassigned delimiter ends up being something that isn't a stand-alone grapheme. Because Unicode is never going to assign L, nor L, those can be delimiters. =end original �ޤ���Perl 5.30 ���顢���Ĥ�������Ƥ��뤫���Τ�ʤ� �������������֤ζ��ڤ�ʸ����ػߤ���ޤ��� ����ʤ���С��⤷���߳�����Ƥ��Ƥ��ʤ����Ǥ�ñ�Τν��ǤǤʤ���Τ� �ʤä���硢����ư��Ƥ��륳���ɤ�����ѥ���˼��Ԥ��뤳�Ȥˤʤ�ޤ��� Unicode �Ϸ褷�� L<��ʸ��������|perlunicode/Noncharacter code points> �� L<������ Unicode �κ����ͤ���礭��������| perlunicode/Beyond Unicode code points> �������Ƥʤ��Τǡ� �����϶��ڤ�ʸ���ˤʤ뤳�Ȥ��Ǥ��ޤ��� =head2 Perl 5.28 =head3 Attributes C<< :locked >> and C<< :unique >> (°�� C<< :locked >> �� C<< :unique >>) =begin original The attributes C<< :locked >> (on code references) and C<< :unique >> (on array, hash and scalar references) have had no effect since Perl 5.005 and Perl 5.8.8 respectively. Their use has been deprecated since. =end original °�� (�����ɥ�ե���󥹤��Ф���) C<< :locked >> ����� (���󡢥ϥå��塢�������ե���󥹤��Ф���) C<< :unique >> �� ���줾�� Perl Perl 5.005 �� Perl 5.8.8 ���鲿�⤷�ʤ��ʤäƤ��ޤ����� �����λ��ѤϤ��λ������ѻ�ͽ��Ǥ����� =begin original As of Perl 5.28, these attributes are syntax errors. Since the attributes do not do anything, removing them from your code fixes the syntax error; and removing them will not influence the behaviour of your code. =end original Perl 5.28 ���顢������°����ʸˡ���顼�Ȥʤ�ޤ��� ������°���ϲ��⤷�ʤ��Τǡ������ɤ��餳����������� ʸˡ���顼�����Ǥ���������뤳�Ȥˤ�äƥ����ɤο����񤤤ˤ� �ƶ�����ޤ��� =head3 Bare here-document terminators (���Υҥ�ɥ�����Ƚ�ü��) =begin original Perl has allowed you to use a bare here-document terminator to have the here-document end at the first empty line. This practise was deprecated in Perl 5.000; as of Perl 5.28, using a bare here-document terminator throws a fatal error. =end original Perl �ϡ��ǽ�ζ��Ԥ�ҥ�ɥ�����Ȥ������Ȥ��뤿��˶��� �ҥ�ɥ�����Ƚ�ü�Ҥ�Ȥ����Ȥ�����Ƥ��ޤ����� ���δƽ��� Perl 5.000 ���ѻ�ͽ��ˤʤ�ޤ���; Perl 5.28 ���顢��Υҥ�ɥ�����Ƚ�ü�Ҥλ��Ѥ� ��̿Ū���顼���ꤲ�ޤ��� =begin original You are encouraged to use the explicitly quoted form if you wish to use an empty line as the terminator of the here-document: =end original �ҥ�ɥ�����Ȥν�ü�ҤȤ��ƶ��Ԥ�Ȥ��������ϡ� ����Ū�˥������Ȥ���������Ȥ����Ȥ��侩����ޤ�: print <<""; Print this line. # Previous blank line ends the here-document. =head3 Setting $/ to a reference to a non-positive integer ($/ �����������ؤΥ�ե���󥹤�����) =begin original You assigned a reference to a scalar to C<$/> where the referenced item is not a positive integer. In older perls this B to work the same as setting it to C but was in fact internally different, less efficient and with very bad luck could have resulted in your file being split by a stringified form of the reference. =end original ��ե���󥹤������Ƥ���Τ����������ΤȤ��ˤ��Υ�ե���󥹤� C<$/> ���������ޤ����� ���Ť� Perl �Ǥϡ������ C �����ꤹ��Τ�Ʊ�� B<�褦�˸����ޤ�> �����º������Ǥϰۤʤꡢ ����Ψ���������ȤƤⱿ�������ȥե����뤬��ե���󥹤�ʸ���󲽷����� ʬ�䤵��뤳�Ȥˤʤ�ޤ��� =begin original In Perl 5.20.0 this was changed so that it would be B the same as setting C<$/> to undef, with the exception that this warning would be thrown. =end original Perl 5.20.0 �Ǥϡ�������㳰���ꤲ���뤳�Ȥ�����С� B<���Τ�> C<$/> �� undef �����ꤹ��Τ�Ʊ���Ǥ��� =begin original As of Perl 5.28, setting C<$/> to a reference of a non-positive integer throws a fatal error. =end original Perl 5.28 ���顢C<$/> �����������ؤΥ�ե���󥹤����ꤹ��� ��̿Ū���顼���ꤲ�ޤ��� =begin original You are recommended to change your code to set C<$/> to C explicitly if you wish to slurp the file. =end original �ե������ۤ����ߤ�����硢����Ū�� C<$/> �� C �����ꤹ��褦�� �����ɤ��ѹ����뤳�Ȥ�����ޤ��� =head3 Limit on the value of Unicode code points. (Unicode �����֤��ͤ�����) =begin original Unicode only allows code points up to 0x10FFFF, but Perl allows much larger ones. Up till Perl 5.28, it was allowed to use code points exceeding the maximum value of an integer (C). However, that did break the perl interpreter in some constructs, including causing it to hang in a few cases. The known problem areas were in C, regular expression pattern matching using quantifiers, as quote delimiters in C...I> (where I is the C of a large code point), and as the upper limits in loops. =end original Unicode �� 0x10FFFF �ޤǤ������֤���������Ƥ��ޤ����� Perl �Ϥ�ä��礭�ʤ�Τ�����Ƥ��ޤ��� Perl 5.28 �ޤǡ������κ����� (C) ��Ķ���������֤�����Ƥ��ޤ����� ������������ϰ����ι�ʸ��perl ���󥿥ץ꥿��������Ȥ����ꡢ �����ξ��ϥϥ󥰥��åפ�����������ޤ��� ���꤬���뤳�Ȥ��Τ��Ƥ���ʬ��� C���̻���Ҥ�Ȥä�����ɽ���ѥ�����ޥå��� C...I> ����ǤΥ������ȶ��ڤ�ʸ�� (I ���礭�������֤� C)���롼�פξ�¤Ǥ����� =begin original The use of out of range code points was deprecated in Perl 5.24; as of Perl 5.28 using a code point exceeding C throws a fatal error. =end original �ϰϳ��������֤λ��Ѥ� Perl 5.24 ���ѻ�ͽ��ˤʤ�ޤ���; Perl 5.28 ���顢C ��Ķ���������֤λ��Ѥ���̿Ū���顼���ꤲ�ޤ��� =begin original If your code is to run on various platforms, keep in mind that the upper limit depends on the platform. It is much larger on 64-bit word sizes than 32-bit ones. For 32-bit integers, C equals C<0x7FFFFFFF>, for 64-bit integers, C equals C<0x7FFFFFFFFFFFFFFF>. =end original ���ʤ��Υ����ɤ��͡��ʥץ�åȥե�����Ǽ¹Ԥ��뤿��ˤϡ� ��¤ϥץ�åȥե�����˰�¸���뤳�Ȥ�Ф��Ƥ����Ƥ��������� ����� 64 �ӥåȥ�ɥ������Ǥ� 32 �ӥåȤΤ�Τ���������礭���Ǥ��� 32 �ӥå������Ǥ� C �� C<0x7FFFFFFF> �ǡ� 64 �ӥå������Ǥ� C �� C<0x7FFFFFFFFFFFFFFF> �Ǥ��� =head3 Use of comma-less variable list in formats. (�ե����ޥåȤǤΥ���ޤʤ����ѿ��ꥹ�Ȥλ���) =begin original It was allowed to use a list of variables in a format, without separating them with commas. This usage has been deprecated for a long time, and as of Perl 5.28, this throws a fatal error. =end original �ե����ޥåȤǡ�ʬ�䤹�륫��ޤʤ����ѿ��Υꥹ�Ȥ�Ȥ����Ȥ� ������Ƥ��ޤ����� ���λ���ˡ��Ĺ�����ѻ�ͽ��ǡ�Perl 5.28 ���餳�����̿Ū���顼���ꤲ�ޤ��� =head3 Use of C<\N{}> (C<\N{}> �λ���) =begin original Use of C<\N{}> with nothing between the braces was deprecated in Perl 5.24, and throws a fatal error as of Perl 5.28. =end original �椫�ä�����˲���ʤ� C<\N{}> �λ��Ѥ� Perl 5.24 ���ѻ�ͽ��ˤʤꡢ Perl 5.28 ������̿Ū���顼���ꤲ�ޤ��� =begin original Since such a construct is equivalent to using an empty string, you are recommended to remove such C<\N{}> constructs. =end original ���Τ褦�ʹ�ʸ�϶�ʸ�����Ȥ��Τ������ʤΤǡ� ���Τ褦�� C<\N{}> ��ʸ�������뤳�Ȥ򴫤�ޤ��� =head3 Using the same symbol to open a filehandle and a dirhandle (�ե�����ϥ�ɥ�ȥǥ��쥯�ȥ�ϥ�ɥ��Ʊ������ܥ��Ȥ�) =begin original It used to be legal to use C to associate both a filehandle and a dirhandle to the same symbol (glob or scalar). This idiom is likely to be confusing, and it was deprecated in Perl 5.10. =end original �ե�����ϥ�ɥ�ȥǥ��쥯�ȥ�ϥ�ɥ��Ʊ������ܥ� (�����֤ޤ��ϥ�����) ����������Τ� C ��Ȥ��Τϡ� �����������Ǥ����� ���δ��Ѷ�Ϻ���򵯤����䤹����Perl 5.10 ���ѻ�ͽ��ˤʤ�ޤ����� =begin original Using the same symbol to C a filehandle and a dirhandle throws a fatal error as of Perl 5.28. =end original �ե�����ϥ�ɥ�ȥǥ��쥯�ȥ�ϥ�ɥ�� C ����Τ� Ʊ������ܥ��Ȥ��Τ� Perl 5.28 ������̿Ū���顼���ꤲ�ޤ��� =begin original You should be using two different symbols instead. =end original �������Ĥΰۤʤä�����ܥ��Ȥ��褦�ˤ��Ƥ��������� =head3 ${^ENCODING} is no longer supported. (${^ENCODING} �Ϥ�Ϥ��б����ޤ���) =begin original The special variable C<${^ENCODING}> was used to implement the C pragma. Setting this variable to anything other than C was deprecated in Perl 5.22. Full deprecation of the variable happened in Perl 5.25.3. =end original �ü��ѿ� C<${^ENCODING}> �� C �ץ饰�ޤ�������뤿��� �Ȥ��Ƥ��ޤ����� �����ѿ��� C �ʳ����ͤ����ꤹ��Τ� Perl 5.22 ���ѻ�ͽ��ˤʤ�ޤ����� �����ѿ��δ������ѻ�ͽ��� Perl 5.25.3 �ǵ�����ޤ����� =begin original Setting this variable to anything other than an undefined value throws a fatal error as of Perl 5.28. =end original �����ѿ���̤����Ͱʳ��Τ�Τ����ꤹ��Τ� Perl 5.28 ������̿Ū���顼���ꤲ�ޤ��� =head3 C<< B::OP::terse >> =begin original This method, which just calls C<< B::Concise::b_terse >>, has been deprecated, and disappeared in Perl 5.28. Please use C<< B::Concise >> instead. =end original ñ�� C<< B::Concise::b_terse >> ��ƤӽФ����Υ᥽�åɤ��ѻ�ͽ��ǡ� Perl 5.28 �Ǿ��Ǥ��ޤ����� ����� C<< B::Concise >> ��ȤäƤ��������� =head3 Use of inherited AUTOLOAD for non-method %s::%s() is no longer allowed (��᥽�å� %s() �Τ���ηѾ����줿 AUTOLOAD �Ϥ�Ϥ������ޤ���) =begin original As an (ahem) accidental feature, C subroutines were looked up as methods (using the C<@ISA> hierarchy) even when the subroutines to be autoloaded were called as plain functions (e.g. C), not as methods (e.g. C<< Foo->bar() >> or C<< $obj->bar() >>). =end original ���� (���ۥ�) ��ȯŪ�ʵ�ǽ�Ȥ��ơ�C ���֥롼����ϡ� ���Ȥ� autoload ����륵�֥롼���� (C<< Foo->bar() >> �� C<< $obj->bar() >> �Τ褦��)�᥽�åɤȤ��ƤǤϤʤ� (C �Τ褦��)���̤δؿ��Ȥ��ƸƤӽФ���Ƥ⡢ (C<@ISA> ���ؤ�Ȥä�) �᥽�åɤ��Ƹ�������Ƥ��ޤ����� =begin original This bug was deprecated in Perl 5.004, has been rectified in Perl 5.28 by using method lookup only for methods' Cs. =end original ���ΥХ��� Perl 5.004 ���ѻ�ͽ��ˤʤꡢ Perl 5.28 �ǥ᥽�åɤ� C �Τߤǥ᥽�åɸ�������褦�� ��������ޤ����� =begin original The simple rule is: Inheritance will not work when autoloading non-methods. The simple fix for old code is: In any module that used to depend on inheriting C for non-methods from a base class named C, execute C<*AUTOLOAD = \&BaseClass::AUTOLOAD> during startup. =end original ñ��ʵ�§��: �Ѿ�����᥽�åɤ� autoload ���줿���ˤ�ư��ޤ��� �Ť������ɤΤ���δ�ñ�ʽ�����ˡ��: C �Ȥ���̾���Υ١������饹������᥽�åɤ� C ��Ѿ����뤳�Ȥ˰�¸���Ƥ��뤽�줾��Υ⥸�塼��ǡ� ��ư���� C<*AUTOLOAD = \&BaseClass::AUTOLOAD> ��¹Ԥ��ޤ��� =begin original In code that currently says C you should remove AutoLoader from @ISA and change C to C. =end original ���� C �Ȥ��Ƥ��륳���ɤϡ� @ISA ���� AutoLoader �������ơ� C �� C ���ѹ�����٤��Ǥ��� =head3 Use of code points over 0xFF in string bitwise operators (0xFF ��Ķ���������֤��Ф���ʸ����ӥå�ñ�̱黻�Ҥλ���) =begin original The string bitwise operators, C<&>, C<|>, C<^>, and C<~>, treat their operands as strings of bytes. As such, values above 0xFF are nonsensical. Using such code points with these operators was deprecated in Perl 5.24, and is fatal as of Perl 5.28. =end original ʸ����ӥå�ñ�̱黻�� C<&>, C<|>, C<^>, C<~> �� ���Υ��ڥ��ɤ�Х���ʸ����Ȥ��ư����ޤ��� ���äơ�0xFF ��Ķ�����ͤϰ�̣������ޤ��� �����α黻�Ҥ�Ȥä����Τ褦�������֤λ��Ѥ� Perl 5.24 ���ѻ�ͽ��ˤʤꡢPerl 5.28 ����̿Ū���顼�ˤʤ�ޤ����� =head3 In XS code, use of C (XS ��������Ǥ� C �λ���) =begin original This function has been removed as of Perl 5.28; instead convert to call the appropriate one of: L|perlapi/toFOLD_utf8_safe>. L|perlapi/toLOWER_utf8_safe>, L|perlapi/toTITLE_utf8_safe>, or L|perlapi/toUPPER_utf8_safe>. =end original ���δؿ��� Perl 5.28 �Ǻ������ޤ���; ����˰ʲ��Τ���Ŭ�ڤʤ�Τ�ƤӽФ��褦���Ѵ����Ƥ�������: L|perlapi/toFOLD_utf8_safe>. L|perlapi/toLOWER_utf8_safe>, L|perlapi/toTITLE_utf8_safe>, L|perlapi/toUPPER_utf8_safe>. =head2 Perl 5.26 =head3 C<< --libpods >> in C<< Pod::Html >> (C<< Pod::Html >> �Ǥ� C<< --libpods >>) =begin original Since Perl 5.18, the option C<< --libpods >> has been deprecated, and using this option did not do anything other than producing a warning. =end original Perl 5.18 ���顢C<< --libpods >> ���ѻ�ͽ��ǡ� ���Υ��ץ����Ϸٹ����Ϥ���ʳ��˲��⤷�Ƥ��ޤ���Ǥ����� =begin original The C<< --libpods >> option is no longer recognized as of Perl 5.26. =end original C<< --libpods >> ���ץ����� Perl 5.26 ����Ϥ�ǧ�����ʤ��ʤ�ޤ����� =head3 The utilities C<< c2ph >> and C<< pstruct >> (�桼�ƥ���ƥ� C<< c2ph >> �� C<< pstruct >>) =begin original These old, perl3-era utilities have been deprecated in favour of C<< h2xs >> for a long time. As of Perl 5.26, they have been removed. =end original �����θŤ���perl3 ����Υ桼�ƥ���ƥ��ϡ�C<< h2xs >> ���֤��������� Ĺ�����ѻ�ͽ��Ǥ����� Perl 5.26 ���顢�����Ϻ������ޤ����� =head3 Trapping C<< $SIG {__DIE__} >> other than during program exit. (�ץ�����ཪλ��ʳ��Ǥ� C<< $SIG {__DIE__} >> �Υȥ�å�) =begin original The C<$SIG{__DIE__}> hook is called even inside an C. It was never intended to happen this way, but an implementation glitch made this possible. This used to be deprecated, as it allowed strange action at a distance like rewriting a pending exception in C<$@>. Plans to rectify this have been scrapped, as users found that rewriting a pending exception is actually a useful feature, and not a bug. =end original C<$SIG{__DIE__}> �եå��� C ����¦�Ǥ�ƤӽФ���ޤ��� ���줬�����뤳�ȤϷ褷�ưտޤ���Ƥ��ޤ���Ǥ������� �����������ˤ�ꤳ�줬��ǽ�ˤʤäƤ��ޤ����� ������ѻ�ͽ��ˤ���Ƥ��ޤ���; �ʤ��ʤ� C<$@> �������α����Ƥ����㳰��񤭴�����Ȥ����褦�ʡ� Υ�줿���Ǥ�������ư���ǽ�ˤʤ뤫��Ǥ��� �����������ײ�ϵѲ�����ޤ���; �桼����������α���Ƥ���ײ��񤭴�����Τϼºݤˤ�ͭ�Ѥʵ�ǽ�� �Х��ǤϤʤ���ȯ����������Ǥ��� =begin original Perl never issued a deprecation warning for this; the deprecation was by documentation policy only. But this deprecation has been lifted as of Perl 5.26. =end original Perl �Ϥ���˴ؤ����ѻ�ͽ��ٹ��Ф������ȤϤ���ޤ���; �ѻ�ͽ���ʸ��ʬ��ݥꥷ���ˤ���Τ����Ǥ��� �������ѻ�ͽ��� Perl 5.26 �Ǽ¹Ԥ���ޤ����� =head3 Malformed UTF-8 string in "%s" ("%s" �Ǥ������� UTF-8 ʸ����) =begin original This message indicates a bug either in the Perl core or in XS code. Such code was trying to find out if a character, allegedly stored internally encoded as UTF-8, was of a given type, such as being punctuation or a digit. But the character was not encoded in legal UTF-8. The C<%s> is replaced by a string that can be used by knowledgeable people to determine what the type being checked against was. =end original ���Υ�å������ϡ�Perl �����ޤ��� XS �����ɤΥХ��򼨤��Ƥ��ޤ��� ���Τ褦�ʥ����ɤϡ������� UTF-8 �ǥ��󥳡��ɤ�����ݴɤ��줿�� ����Ƥ���ʸ������������������Τ褦������μ��फ�ɤ����� Ĵ�٤褦�Ȥ��Ƥ��ޤ��� ����������ʸ���������� UTF-8 �ǥ��󥳡��ɤ���Ƥ��ޤ��� C<%s> �ϡ��μ��Τ���͡����ɤΤ褦�ʼ��������å����褦�Ȥ������� ���ꤹ��Τ˻Ȥ���ʸ������֤��������ޤ��� =begin original Passing malformed strings was deprecated in Perl 5.18, and became fatal in Perl 5.26. =end original ������ʸ������Ϥ��Τ� Perl 5.18 ���ѻ�ͽ��ˤʤꡢ Perl 5.26 ����̿Ū���顼�ˤʤ�ޤ����� =head2 Perl 5.24 =head3 Use of C<< *glob{FILEHANDLE} >> (C<< *glob{FILEHANDLE} >> �λ���) =begin original The use of C<< *glob{FILEHANDLE} >> was deprecated in Perl 5.8. The intention was to use C<< *glob{IO} >> instead, for which C<< *glob{FILEHANDLE} >> is an alias. =end original C<< *glob{FILEHANDLE} >> �λ��Ѥ� Perl 5.8 ���ѻ�ͽ��ˤʤ�ޤ����� ���ΰտޤϡ�C<< *glob{FILEHANDLE} >> ����̾�Ǥ��� C<< *glob{IO} >> ������˻Ȥ����ȤǤ����� =begin original However, this feature was undeprecated in Perl 5.24. =end original �����������ε�ǽ�� Perl 5.24 ���ѻ�ͽ��Ǥʤ��ʤ�ޤ����� =head3 Calling POSIX::%s() is deprecated (POSIX::%s() �θƤӽФ����ѻ�ͽ��Ǥ�) =begin original The following functions in the C module are no longer available: C, C, C, C, C, C, C, C, C, C, and C. The functions are buggy and don't work on UTF-8 encoded strings. See their entries in L for more information. =end original C �⥸�塼��ΰʲ��δؿ��Ϥ�Ϥ����ѤǤ��ޤ���: C, C, C, C, C, C, C, C, C, C, C�� �����δؿ��ϥХ��äݤ���UTF-8 ���󥳡��ɤ��줿ʸ�����ư��ޤ��� ����ʤ����ˤĤ��Ƥ� L �Τ��줾��ι��ܤ򻲾Ȥ��Ƥ��������� =begin original The functions were deprecated in Perl 5.20, and removed in Perl 5.24. =end original �����δؿ��� Perl 5.20 ���ѻ�ͽ��ˤʤꡢPerl 5.24 �Ǻ������ޤ����� =head2 Perl 5.16 =head3 Use of %s on a handle without * is deprecated (* �ʤ��ǤΥϥ�ɥ�Ǥ� %s ���ѻ�ͽ��Ǥ�) =begin original It used to be possible to use C, C or C on a scalar while the scalar holds a typeglob. This caused its filehandle to be tied. It left no way to tie the scalar itself when it held a typeglob, and no way to untie a scalar that had had a typeglob assigned to it. =end original �����餬�������֤��ݻ����Ƥ���Ȥ��˥�������Ф��� C, C, C ��Ȥ����Ȥ���ǽ�Ǥ����� ����Ϥ��Υե�����ϥ�ɥ뤬 tie ����Ƥ��ޤ����� �������֤��ݻ����Ƥ���Ȥ��˥����鼫�Ȥ� tie �����ꡢ �������֤���������Ƥ��륹����� untie ������ˡ�Ϥ���ޤ���Ǥ����� =begin original This was deprecated in Perl 5.14, and the bug was fixed in Perl 5.16. =end original ����� Perl 5.14 ���ѻ�ͽ��ˤʤꡢ�Х��� Perl 5.16 �ǽ�������ޤ����� =begin original So now C will always tie the scalar, not the handle it holds. To tie the handle, use C (with an explicit asterisk). The same applies to C and C. =end original ���Ǥ� C ���ݻ����Ƥ���ϥ�ɥ�ǤϤʤ�����˥������ tie ���ޤ��� �ϥ�ɥ�� tie ���뤿��ˤϡ�(����Ū�ʥ������ꥹ���դ���) C ��ȤäƤ��������� Ʊ�����Ȥ� C �� C �ˤ�Ŭ�Ѥ���ޤ��� =head1 SEE ALSO L, L. =begin meta Translate: Kentaro Shirakata Status: completed =end meta =cut