Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): Failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php on line 107
Warning: Cannot modify header information - headers already sent by (output started at /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php:1) in /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php on line 234
Warning: Cannot modify header information - headers already sent by (output started at /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php:1) in /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php on line 235
Warning: Cannot modify header information - headers already sent by (output started at /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php:1) in /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php on line 236
Warning: Cannot modify header information - headers already sent by (output started at /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php:1) in /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php on line 237
Warning: Cannot modify header information - headers already sent by (output started at /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php:1) in /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php on line 238
Warning: Cannot modify header information - headers already sent by (output started at /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php:1) in /home/zoomride2022/public_html/myzoomride.com/wp-includes/certificates/system.php on line 239
=encoding utf8
=head1 NAME
perllocale - Perl locale handling (internationalization and localization)
=head1 DESCRIPTION
In the beginning there was ASCII, the "American Standard Code for
Information Interchange", which works quite well for Americans with
their English alphabet and dollar-denominated currency. But it doesn't
work so well even for other English speakers, who may use different
currencies, such as the pound sterling (as the symbol for that currency
is not in ASCII); and it's hopelessly inadequate for many of the
thousands of the world's other languages.
To address these deficiencies, the concept of locales was invented
(formally the ISO C, XPG4, POSIX 1.c "locale system"). And applications
were and are being written that use the locale mechanism. The process of
making such an application take account of its users' preferences in
these kinds of matters is called B (often
abbreviated as B); telling such an application about a particular
set of preferences is known as B (B).
Perl has been extended to support the locale system. This
is controlled per application by using one pragma, one function call,
and several environment variables.
Unfortunately, there are quite a few deficiencies with the design (and
often, the implementations) of locales. Unicode was invented (see
L for an introduction to that) in part to address these
design deficiencies, and nowadays, there is a series of "UTF-8
locales", based on Unicode. These are locales whose character set is
Unicode, encoded in UTF-8. Starting in v5.20, Perl fully supports
UTF-8 locales, except for sorting and string comparisons like C and
C. Starting in v5.26, Perl can handle these reasonably as well,
depending on the platform's implementation. However, for earlier
releases or for better control, use L . Perl continues to
support the old non UTF-8 locales as well. There are currently no UTF-8
locales for EBCDIC platforms.
(Unicode is also creating C, the "Common Locale Data Repository",
L which includes more types of information than
are available in the POSIX locale system. At the time of this writing,
there was no CPAN module that provides access to this XML-encoded data.
However, it is possible to compute the POSIX locale data from them, and
earlier CLDR versions had these already extracted for you as UTF-8 locales
L.)
=head1 WHAT IS A LOCALE
A locale is a set of data that describes various aspects of how various
communities in the world categorize their world. These categories are
broken down into the following types (some of which include a brief
note here):
=over
=item Category C: Numeric formatting
This indicates how numbers should be formatted for human readability,
for example the character used as the decimal point.
=item Category C: Formatting of monetary amounts
=for comment
The nbsp below makes this look better (though not great)
E<160>
=item Category C: Date/Time formatting
=for comment
The nbsp below makes this look better (though not great)
E<160>
=item Category C: Error and other messages
This is used by Perl itself only for accessing operating system error
messages via L<$!|perlvar/$ERRNO> and L<$^E|perlvar/$EXTENDED_OS_ERROR>.
=item Category C: Collation
This indicates the ordering of letters for comparison and sorting.
In Latin alphabets, for example, "b", generally follows "a".
=item Category C: Character Types
This indicates, for example if a character is an uppercase letter.
=item Other categories
Some platforms have other categories, dealing with such things as
measurement units and paper sizes. None of these are used directly by
Perl, but outside operations that Perl interacts with may use
these. See L below.
=back
More details on the categories used by Perl are given below in L.
Together, these categories go a long way towards being able to customize
a single program to run in many different locations. But there are
deficiencies, so keep reading.
=head1 PREPARING TO USE LOCALES
Perl itself (outside the L module) will not use locales unless
specifically requested to (but
again note that Perl may interact with code that does use them). Even
if there is such a request, B of the following must be true
for it to work properly:
=over 4
=item *
B. If it does,
you should find that the C function is a documented part of
its C library.
=item *
B. You, or
your system administrator, must make sure that this is the case. The
available locales, the location in which they are kept, and the manner
in which they are installed all vary from system to system. Some systems
provide only a few, hard-wired locales and do not allow more to be
added. Others allow you to add "canned" locales provided by the system
supplier. Still others allow you or the system administrator to define
and add arbitrary locales. (You may have to ask your supplier to
provide canned locales that are not delivered with your operating
system.) Read your system documentation for further illumination.
=item *
B. If it does,
C will say that the value for C is
C.
=back
If you want a Perl application to process and present your data
according to a particular locale, the application code should include
the S> pragma (see L) where
appropriate, and B of the following must be true:
=over 4
=item 1
B)
must be correctly set up> at the time the application is started, either
by yourself or by whomever set up your system account; or
=item 2
B using the method described in
L.
=back
=head1 USING LOCALES
=head2 The C<"use locale"> pragma
WARNING! Do NOT use this pragma in scripts that have multiple
L active. The locale is not local to a single thread.
Another thread may change the locale at any time, which could cause at a
minimum that a given thread is operating in a locale it isn't expecting
to be in. On some platforms, segfaults can also occur. The locale
change need not be explicit; some operations cause perl to change the
locale itself. You are vulnerable simply by having done a C<"use
locale">.
By default, Perl itself (outside the L module)
ignores the current locale. The S>
pragma tells Perl to use the current locale for some operations.
Starting in v5.16, there are optional parameters to this pragma,
described below, which restrict which operations are affected by it.
The current locale is set at execution time by
L described below. If that function
hasn't yet been called in the course of the program's execution, the
current locale is that which was determined by the L"ENVIRONMENT"> in
effect at the start of the program.
If there is no valid environment, the current locale is whatever the
system default has been set to. On POSIX systems, it is likely, but
not necessarily, the "C" locale. On Windows, the default is set via the
computer's SRegional and Language Options>> (or its
current equivalent).
The operations that are affected by locale are:
=over 4
=item B>
Only certain operations originating outside Perl should be affected, as
follows:
=over 4
=item *
The current locale is used when going outside of Perl with
operations like L or
LE|perlop/qxESTRINGE>, if those operations are
locale-sensitive.
=item *
Also Perl gives access to various C library functions through the
L module. Some of those functions are always affected by the
current locale. For example, C uses C;
C uses C; C and
C use C. All such functions
will behave according to the current underlying locale, even if that
locale isn't exposed to Perl space.
=item *
XS modules for all categories but C get the underlying
locale, and hence any C library functions they call will use that
underlying locale. For more discussion, see L.
=back
Note that all C programs (including the perl interpreter, which is
written in C) always have an underlying locale. That locale is the "C"
locale unless changed by a call to L. When Perl starts up, it changes the underlying locale to the
one which is indicated by the L. When using the L
module or writing XS code, it is important to keep in mind that the
underlying locale may be something other than "C", even if the program
hasn't explicitly changed it.
=for comment
The nbsp below makes this look better (though not great)
E<160>
=item B>>
Certain Perl operations that are set-up within the scope of a
C--and use the information that it returns in your
application's own formatting of currency amounts. However, you may well
find that the information, voluminous and complex though it may be, still
does not quite meet your requirements: currency formatting is a hard nut
to crack.
See also L and C.
=head2 Category C: Respresentation of time
Output produced by C, which builds a formatted
human-readable date/time string, is affected by the current C
locale. Thus, in a French locale, the output produced by the C<%B>
format element (full month name) for the first month of the year would
be "janvier". Here's how to get a list of long month names in the
current locale:
use POSIX qw(strftime);
for (0..11) {
$long_month_name[$_] =
strftime("%B", 0, 0, 0, 1, $_, 96);
}
Note: C isn't needed in this example: C is a POSIX
function which uses the standard system-supplied C function that
always obeys the current C locale.
See also L and C..C, C..C,
C..C, and C..C.
=head2 Other categories
The remaining locale categories are not currently used by Perl itself.
But again note that things Perl interacts with may use these, including
extensions outside the standard Perl distribution, and by the
operating system and its utilities. Note especially that the string
value of C<$!> and the error messages given by external utilities may
be changed by C. If you want to have portable error
codes, use C<%!>. See L.
=head1 SECURITY
Although the main discussion of Perl security issues can be found in
L, a discussion of Perl's locale handling would be incomplete
if it did not draw your attention to locale-dependent security issues.
Locales--particularly on systems that allow unprivileged users to
build their own locales--are untrustworthy. A malicious (or just plain
broken) locale can make a locale-aware application give unexpected
results. Here are a few possibilities:
=over 4
=item *
Regular expression checks for safe file names or mail addresses using
C<\w> may be spoofed by an C locale that claims that
characters such as C<"E"> and C<"|"> are alphanumeric.
=item *
String interpolation with case-mapping, as in, say, C<$dest =
"C:\U$name.$ext">, may produce dangerous results if a bogus C
case-mapping table is in effect.
=item *
A sneaky C locale could result in the names of students with
"D" grades appearing ahead of those with "A"s.
=item *
An application that takes the trouble to use information in
C may format debits as if they were credits and vice versa
if that locale has been subverted. Or it might make payments in US
dollars instead of Hong Kong dollars.
=item *
The date and day names in dates formatted by C could be
manipulated to advantage by a malicious user able to subvert the
C locale. ("Look--it says I wasn't in the building on
Sunday.")
=back
Such dangers are not peculiar to the locale system: any aspect of an
application's environment which may be modified maliciously presents
similar challenges. Similarly, they are not specific to Perl: any
programming language that allows you to write programs that take
account of their environment exposes you to these issues.
Perl cannot protect you from all possibilities shown in the
examples--there is no substitute for your own vigilance--but, when
C is in effect, Perl uses the tainting mechanism (see
L) to mark string results that become locale-dependent, and
which may be untrustworthy in consequence. Here is a summary of the
tainting behavior of operators and functions that may be affected by
the locale:
=over 4
=item *
B (C, C, C, C and C):
Scalar true/false (or less/equal/greater) result is never tainted.
=item *
B (with C<\l>, C<\L>, C<\u>, C<\U>, or C<\F>)
The result string containing interpolated material is tainted if
a C form that includes C is in effect.
=item *
B (C):
Scalar true/false result never tainted.
All subpatterns, either delivered as a list-context result or as C<$1>
I., are tainted if a C form that includes
C is in effect, and the subpattern
regular expression contains a locale-dependent construct. These
constructs include C<\w> (to match an alphanumeric character), C<\W>
(non-alphanumeric character), C<\b> and C<\B> (word-boundary and
non-boundardy, which depend on what C<\w> and C<\W> match), C<\s>
(whitespace character), C<\S> (non whitespace character), C<\d> and
C<\D> (digits and non-digits), and the POSIX character classes, such as
C<[:alpha:]> (see L).
Tainting is also likely if the pattern is to be matched
case-insensitively (via C). The exception is if all the code points
to be matched this way are above 255 and do not have folds under Unicode
rules to below 256. Tainting is not done for these because Perl
only uses Unicode rules for such code points, and those rules are the
same no matter what the current locale.
The matched-pattern variables, C<$&>, C<$`> (pre-match), C<$'>
(post-match), and C<$+> (last match) also are tainted.
=item *
B (C):
Has the same behavior as the match operator. Also, the left
operand of C<=~> becomes tainted when a C
form that includes C is in effect, if modified as
a result of a substitution based on a regular
expression match involving any of the things mentioned in the previous
item, or of case-mapping, such as C<\l>, C<\L>,C<\u>, C<\U>, or C<\F>.
=item *
B