FM / perl5

/usr/share/perl5

Name	Size	Mode	Actions
Attribute/	-	0755	rm
B/	-	0755	rm
Class/	-	0755	rm
Compress/	-	0755	rm
Config/	-	0755	rm
CPAN/	-	0755	rm
DBM_Filter/	-	0755	rm
Devel/	-	0755	rm
encoding/	-	0755	rm
ExtUtils/	-	0755	rm
File/	-	0755	rm
Getopt/	-	0755	rm
I18N/	-	0755	rm
IO/	-	0755	rm
IPC/	-	0755	rm
Locale/	-	0755	rm
Math/	-	0755	rm
Memoize/	-	0755	rm
Module/	-	0755	rm
Net/	-	0755	rm
overload/	-	0755	rm
Pod/	-	0755	rm
pod/	-	0755	rm
Search/	-	0755	rm
Term/	-	0755	rm
Text/	-	0755	rm
Thread/	-	0755	rm
Tie/	-	0755	rm
Time/	-	0755	rm
Unicode/	-	0755	rm
unicore/	-	0755	rm
URI/	-	0755	rm
User/	-	0755	rm
vendor_perl/	-	0755	rm
warnings/	-	0755	rm
AnyDBM_File.pm	2618	0644	edit dl rm
AutoLoader.pm	15797	0644	edit dl rm
AutoSplit.pm	19637	0644	edit dl rm
autouse.pm	4238	0644	edit dl rm
base.pm	10961	0644	edit dl rm
Benchmark.pm	31026	0644	edit dl rm
blib.pm	2062	0644	edit dl rm
bytes.pm	3740	0644	edit dl rm
bytes_heavy.pl	758	0644	edit dl rm
charnames.pm	20931	0644	edit dl rm
CORE.pod	3188	0644	edit dl rm
DB.pm	18922	0644	edit dl rm
DBM_Filter.pm	14385	0644	edit dl rm
deprecate.pm	4603	0644	edit dl rm
diagnostics.pm	19299	0644	edit dl rm
DirHandle.pm	2085	0644	edit dl rm
Dumpvalue.pm	17668	0644	edit dl rm
dumpvar.pl	15555	0644	edit dl rm
English.pm	4761	0644	edit dl rm
feature.pm	19003	0644	edit dl rm
fields.pm	9475	0644	edit dl rm
FileCache.pm	5549	0644	edit dl rm
FileHandle.pm	6784	0644	edit dl rm
filetest.pm	4003	0644	edit dl rm
FindBin.pm	4561	0644	edit dl rm
if.pm	3611	0644	edit dl rm
integer.pm	3254	0644	edit dl rm
Internals.pod	2575	0644	edit dl rm
less.pm	3204	0644	edit dl rm
locale.pm	4855	0644	edit dl rm
Memoize.pm	36192	0644	edit dl rm
meta_notation.pm	2117	0644	edit dl rm
NEXT.pm	18985	0644	edit dl rm
open.pm	8512	0644	edit dl rm
overload.pm	53302	0644	edit dl rm
overloading.pm	1808	0644	edit dl rm
perl5db.pl	317094	0644	edit dl rm
PerlIO.pm	14441	0644	edit dl rm
Safe.pm	25364	0644	edit dl rm
SelectSaver.pm	1076	0644	edit dl rm
SelfLoader.pm	17686	0644	edit dl rm
sigtrap.pm	8736	0644	edit dl rm
sort.pm	3911	0644	edit dl rm
strict.pm	4738	0644	edit dl rm
subs.pm	901	0644	edit dl rm
Symbol.pm	4799	0644	edit dl rm
Test.pm	30042	0644	edit dl rm
Thread.pm	8289	0644	edit dl rm
UNIVERSAL.pm	6594	0644	edit dl rm
URI.pm	34954	0644	edit dl rm
utf8.pm	10423	0644	edit dl rm
vars.pm	2458	0644	edit dl rm
vmsish.pm	4313	0644	edit dl rm
warnings.pm	50537	0644	edit dl rm
XSLoader.pm	11252	0644	edit dl rm
_charnames.pm	34151	0644	edit dl rm

Edit: /usr/share/perl5/bytes.pm (3740B)

package bytes;

our $VERSION = '1.07';

$bytes::hint_bits = 0x00000008;

sub import {
    $^H |= $bytes::hint_bits;
}

sub unimport {
    $^H &= ~$bytes::hint_bits;
}

sub AUTOLOAD {
    require "bytes_heavy.pl";
    goto &$AUTOLOAD if defined &$AUTOLOAD;
    require Carp;
    Carp::croak("Undefined subroutine $AUTOLOAD called");
}

sub length (_);
sub chr (_);
sub ord (_);
sub substr ($$;$$);
sub index ($$;$);
sub rindex ($$;$);

1;
__END__

=head1 NAME

bytes - Perl pragma to expose the individual bytes of characters

=head1 NOTICE

Because the bytes pragma breaks encapsulation (i.e. it exposes the innards of
how the perl executable currently happens to store a string), the byte values
that result are in an unspecified encoding.

B<Use of this module for anything other than debugging purposes is
strongly discouraged.>  If you feel that the functions here within
might be useful for your application, this possibly indicates a
mismatch between your mental model of Perl Unicode and the current
reality. In that case, you may wish to read some of the perl Unicode
documentation: L<perluniintro>, L<perlunitut>, L<perlunifaq> and
L<perlunicode>.

=head1 SYNOPSIS

use bytes;
    ... chr(...);       # or bytes::chr
    ... index(...);     # or bytes::index
    ... length(...);    # or bytes::length
    ... ord(...);       # or bytes::ord
    ... rindex(...);    # or bytes::rindex
    ... substr(...);    # or bytes::substr
    no bytes;

=head1 DESCRIPTION

Perl's characters are stored internally as sequences of one or more bytes.
This pragma allows for the examination of the individual bytes that together
comprise a character.

Originally the pragma was designed for the loftier goal of helping incorporate
Unicode into Perl, but the approach that used it was found to be defective,
and the one remaining legitimate use is for debugging when you need to
non-destructively examine characters' individual bytes.  Just insert this
pragma temporarily, and remove it after the debugging is finished.

The original usage can be accomplished by explicit (rather than this pragma's
implicit) encoding using the L<Encode> module:

use Encode qw/encode/;

my $utf8_byte_string   = encode "UTF8",   $string;
    my $latin1_byte_string = encode "Latin1", $string;

Or, if performance is needed and you are only interested in the UTF-8
representation:

utf8::encode(my $utf8_byte_string = $string);

C<no bytes> can be used to reverse the effect of C<use bytes> within the
current lexical scope.

As an example, when Perl sees C<$x = chr(400)>, it encodes the character
in UTF-8 and stores it in C<$x>. Then it is marked as character data, so,
for instance, C<length $x> returns C<1>. However, in the scope of the
C<bytes> pragma, C<$x> is treated as a series of bytes - the bytes that make
up the UTF8 encoding - and C<length $x> returns C<2>:

$x = chr(400);
 print "Length is ", length $x, "\n";     # "Length is 1"
 printf "Contents are %vd\n", $x;         # "Contents are 400"
 {
     use bytes; # or "require bytes; bytes::length()"
     print "Length is ", length $x, "\n"; # "Length is 2"
     printf "Contents are %vd\n", $x;     # "Contents are 198.144 (on
                                          # ASCII platforms)"
 }

C<chr()>, C<ord()>, C<substr()>, C<index()> and C<rindex()> behave similarly.

For more on the implications, see L<perluniintro> and L<perlunicode>.

C<bytes::length()> is admittedly handy if you need to know the
B<byte length> of a Perl scalar.  But a more modern way is:

use Encode 'encode';
   length(encode('UTF-8', $scalar))

=head1 LIMITATIONS

C<bytes::substr()> does not work as an I<lvalue()>.

=head1 SEE ALSO

L<perluniintro>, L<perlunicode>, L<utf8>, L<Encode>

=cut

package bytes; our $VERSION = '1.07'; $bytes::hint_bits = 0x00000008; sub import { $^H |= $bytes::hint_bits; } sub unimport { $^H &= ~$bytes::hint_bits; } sub AUTOLOAD { require "bytes_heavy.pl"; goto &$AUTOLOAD if defined &$AUTOLOAD; require Carp; Carp::croak("Undefined subroutine $AUTOLOAD called"); } sub length (_); sub chr (_); sub ord (_); sub substr ($$;$$); sub index ($$;$); sub rindex ($$;$); 1; __END__ =head1 NAME bytes - Perl pragma to expose the individual bytes of characters =head1 NOTICE Because the bytes pragma breaks encapsulation (i.e. it exposes the innards of how the perl executable currently happens to store a string), the byte values that result are in an unspecified encoding. B If you feel that the functions here within might be useful for your application, this possibly indicates a mismatch between your mental model of Perl Unicode and the current reality. In that case, you may wish to read some of the perl Unicode documentation: L, L, L and L. =head1 SYNOPSIS use bytes; ... chr(...); # or bytes::chr ... index(...); # or bytes::index ... length(...); # or bytes::length ... ord(...); # or bytes::ord ... rindex(...); # or bytes::rindex ... substr(...); # or bytes::substr no bytes; =head1 DESCRIPTION Perl's characters are stored internally as sequences of one or more bytes. This pragma allows for the examination of the individual bytes that together comprise a character. Originally the pragma was designed for the loftier goal of helping incorporate Unicode into Perl, but the approach that used it was found to be defective, and the one remaining legitimate use is for debugging when you need to non-destructively examine characters' individual bytes. Just insert this pragma temporarily, and remove it after the debugging is finished. The original usage can be accomplished by explicit (rather than this pragma's implicit) encoding using the L module: use Encode qw/encode/; my $utf8_byte_string = encode "UTF8", $string; my $latin1_byte_string = encode "Latin1", $string; Or, if performance is needed and you are only interested in the UTF-8 representation: utf8::encode(my $utf8_byte_string = $string); C can be used to reverse the effect of C within the current lexical scope. As an example, when Perl sees C<$x = chr(400)>, it encodes the character in UTF-8 and stores it in C<$x>. Then it is marked as character data, so, for instance, C returns C<1>. However, in the scope of the C pragma, C<$x> is treated as a series of bytes - the bytes that make up the UTF8 encoding - and C returns C<2>: $x = chr(400); print "Length is ", length $x, "\n"; # "Length is 1" printf "Contents are %vd\n", $x; # "Contents are 400" { use bytes; # or "require bytes; bytes::length()" print "Length is ", length $x, "\n"; # "Length is 2" printf "Contents are %vd\n", $x; # "Contents are 198.144 (on # ASCII platforms)" } C, C, C, C and C behave similarly. For more on the implications, see L and L. C is admittedly handy if you need to know the B of a Perl scalar. But a more modern way is: use Encode 'encode'; length(encode('UTF-8', $scalar)) =head1 LIMITATIONS C does not work as an I. =head1 SEE ALSO L, L, L, L =cut