Result:
found more than 693 distributions - search limited to the first 2001 files matching your query
( run in 1.750 )
Char-EUCJP
view release on metacpan or search on metacpan
lib/Eeucjp.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Eeucjp::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-EUCTW
view release on metacpan or search on metacpan
lib/Eeuctw.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Eeuctw::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-GB18030
view release on metacpan or search on metacpan
lib/Egb18030.pm view on Meta::CPAN
return wantarray ? (-M _,@_) : -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return wantarray ? ($M,@_) : $M;
}
}
lib/Egb18030.pm view on Meta::CPAN
return wantarray ? (-A _,@_) : -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return wantarray ? ($A,@_) : $A;
}
}
lib/Egb18030.pm view on Meta::CPAN
return wantarray ? (-C _,@_) : -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return wantarray ? ($C,@_) : $C;
}
}
lib/Egb18030.pm view on Meta::CPAN
return -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return $M;
}
}
lib/Egb18030.pm view on Meta::CPAN
return -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return $A;
}
}
lib/Egb18030.pm view on Meta::CPAN
return -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return $C;
}
}
lib/Egb18030.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Egb18030::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
lib/Egb18030.pm view on Meta::CPAN
Egb18030::O(*), Egb18030::O_() File or directory is owned by this real user
Egb18030::p(*), Egb18030::p_() Entry is a named pipe (a "fifo")
Egb18030::b(*), Egb18030::b_() Entry is a block-special file (like a mountable disk)
Egb18030::c(*), Egb18030::c_() Entry is a character-special file (like an I/O device)
Egb18030::u(*), Egb18030::u_() File or directory is setuid
Egb18030::g(*), Egb18030::g_() File or directory is setgid
Egb18030::k(*), Egb18030::k_() File or directory has the sticky bit set
------------------------------------------------------------------------------
The tests -T and -B takes a try at telling whether a file is text or binary.
But people who know a lot about filesystems know that there's no bit (at least
lib/Egb18030.pm view on Meta::CPAN
In scalar context, this subroutine returns a Boolean value that indicates whether
the call succeeded. In list context, it returns a 13-element list giving the
statistics for a file, either the file opened via FILEHANDLE or DIRHANDLE, or
named by $expr. It's typically used as followes:
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
$atime,$mtime,$ctime,$blksize,$blocks) = Egb18030::stat($expr);
Not all fields are supported on all filesystem types; unsupported fields return
0. Here are the meanings of the fields:
lib/Egb18030.pm view on Meta::CPAN
have a value greater than one
1 for MacOS
4 $uid Numeric user ID of file's owner
zero for MSWin32
zero for MacOS
5 $gid Numeric group ID of file's owner
zero for MSWin32
zero for MacOS
6 $rdev The device identifier (special files only)
drive number for MSWin32
NULL for MacOS
Char-GBK
view release on metacpan or search on metacpan
lib/Egbk.pm view on Meta::CPAN
return wantarray ? (-M _,@_) : -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return wantarray ? ($M,@_) : $M;
}
}
lib/Egbk.pm view on Meta::CPAN
return wantarray ? (-A _,@_) : -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return wantarray ? ($A,@_) : $A;
}
}
lib/Egbk.pm view on Meta::CPAN
return wantarray ? (-C _,@_) : -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return wantarray ? ($C,@_) : $C;
}
}
lib/Egbk.pm view on Meta::CPAN
return -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return $M;
}
}
lib/Egbk.pm view on Meta::CPAN
return -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return $A;
}
}
lib/Egbk.pm view on Meta::CPAN
return -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return $C;
}
}
lib/Egbk.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Egbk::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
lib/Egbk.pm view on Meta::CPAN
Egbk::O(*), Egbk::O_() File or directory is owned by this real user
Egbk::p(*), Egbk::p_() Entry is a named pipe (a "fifo")
Egbk::b(*), Egbk::b_() Entry is a block-special file (like a mountable disk)
Egbk::c(*), Egbk::c_() Entry is a character-special file (like an I/O device)
Egbk::u(*), Egbk::u_() File or directory is setuid
Egbk::g(*), Egbk::g_() File or directory is setgid
Egbk::k(*), Egbk::k_() File or directory has the sticky bit set
------------------------------------------------------------------------------
The tests -T and -B takes a try at telling whether a file is text or binary.
But people who know a lot about filesystems know that there's no bit (at least
lib/Egbk.pm view on Meta::CPAN
In scalar context, this subroutine returns a Boolean value that indicates whether
the call succeeded. In list context, it returns a 13-element list giving the
statistics for a file, either the file opened via FILEHANDLE or DIRHANDLE, or
named by $expr. It's typically used as followes:
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
$atime,$mtime,$ctime,$blksize,$blocks) = Egbk::stat($expr);
Not all fields are supported on all filesystem types; unsupported fields return
0. Here are the meanings of the fields:
lib/Egbk.pm view on Meta::CPAN
have a value greater than one
1 for MacOS
4 $uid Numeric user ID of file's owner
zero for MSWin32
zero for MacOS
5 $gid Numeric group ID of file's owner
zero for MSWin32
zero for MacOS
6 $rdev The device identifier (special files only)
drive number for MSWin32
NULL for MacOS
Char-Greek
view release on metacpan or search on metacpan
lib/Egreek.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Egreek::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-HP15
view release on metacpan or search on metacpan
lib/Ehp15.pm view on Meta::CPAN
return wantarray ? (-M _,@_) : -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return wantarray ? ($M,@_) : $M;
}
}
lib/Ehp15.pm view on Meta::CPAN
return wantarray ? (-A _,@_) : -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return wantarray ? ($A,@_) : $A;
}
}
lib/Ehp15.pm view on Meta::CPAN
return wantarray ? (-C _,@_) : -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return wantarray ? ($C,@_) : $C;
}
}
lib/Ehp15.pm view on Meta::CPAN
return -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return $M;
}
}
lib/Ehp15.pm view on Meta::CPAN
return -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return $A;
}
}
lib/Ehp15.pm view on Meta::CPAN
return -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return $C;
}
}
lib/Ehp15.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Ehp15::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
lib/Ehp15.pm view on Meta::CPAN
Ehp15::O(*), Ehp15::O_() File or directory is owned by this real user
Ehp15::p(*), Ehp15::p_() Entry is a named pipe (a "fifo")
Ehp15::b(*), Ehp15::b_() Entry is a block-special file (like a mountable disk)
Ehp15::c(*), Ehp15::c_() Entry is a character-special file (like an I/O device)
Ehp15::u(*), Ehp15::u_() File or directory is setuid
Ehp15::g(*), Ehp15::g_() File or directory is setgid
Ehp15::k(*), Ehp15::k_() File or directory has the sticky bit set
------------------------------------------------------------------------------
The tests -T and -B takes a try at telling whether a file is text or binary.
But people who know a lot about filesystems know that there's no bit (at least
lib/Ehp15.pm view on Meta::CPAN
In scalar context, this subroutine returns a Boolean value that indicates whether
the call succeeded. In list context, it returns a 13-element list giving the
statistics for a file, either the file opened via FILEHANDLE or DIRHANDLE, or
named by $expr. It's typically used as followes:
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
$atime,$mtime,$ctime,$blksize,$blocks) = Ehp15::stat($expr);
Not all fields are supported on all filesystem types; unsupported fields return
0. Here are the meanings of the fields:
lib/Ehp15.pm view on Meta::CPAN
have a value greater than one
1 for MacOS
4 $uid Numeric user ID of file's owner
zero for MSWin32
zero for MacOS
5 $gid Numeric group ID of file's owner
zero for MSWin32
zero for MacOS
6 $rdev The device identifier (special files only)
drive number for MSWin32
NULL for MacOS
Char-Hebrew
view release on metacpan or search on metacpan
lib/Ehebrew.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Ehebrew::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-INFORMIXV6ALS
view release on metacpan or search on metacpan
lib/Einformixv6als.pm view on Meta::CPAN
return wantarray ? (-M _,@_) : -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return wantarray ? ($M,@_) : $M;
}
}
lib/Einformixv6als.pm view on Meta::CPAN
return wantarray ? (-A _,@_) : -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return wantarray ? ($A,@_) : $A;
}
}
lib/Einformixv6als.pm view on Meta::CPAN
return wantarray ? (-C _,@_) : -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return wantarray ? ($C,@_) : $C;
}
}
lib/Einformixv6als.pm view on Meta::CPAN
return -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return $M;
}
}
lib/Einformixv6als.pm view on Meta::CPAN
return -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return $A;
}
}
lib/Einformixv6als.pm view on Meta::CPAN
return -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return $C;
}
}
lib/Einformixv6als.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Einformixv6als::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
lib/Einformixv6als.pm view on Meta::CPAN
Einformixv6als::O(*), Einformixv6als::O_() File or directory is owned by this real user
Einformixv6als::p(*), Einformixv6als::p_() Entry is a named pipe (a "fifo")
Einformixv6als::b(*), Einformixv6als::b_() Entry is a block-special file (like a mountable disk)
Einformixv6als::c(*), Einformixv6als::c_() Entry is a character-special file (like an I/O device)
Einformixv6als::u(*), Einformixv6als::u_() File or directory is setuid
Einformixv6als::g(*), Einformixv6als::g_() File or directory is setgid
Einformixv6als::k(*), Einformixv6als::k_() File or directory has the sticky bit set
------------------------------------------------------------------------------
The tests -T and -B takes a try at telling whether a file is text or binary.
But people who know a lot about filesystems know that there's no bit (at least
lib/Einformixv6als.pm view on Meta::CPAN
In scalar context, this subroutine returns a Boolean value that indicates whether
the call succeeded. In list context, it returns a 13-element list giving the
statistics for a file, either the file opened via FILEHANDLE or DIRHANDLE, or
named by $expr. It's typically used as followes:
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
$atime,$mtime,$ctime,$blksize,$blocks) = Einformixv6als::stat($expr);
Not all fields are supported on all filesystem types; unsupported fields return
0. Here are the meanings of the fields:
lib/Einformixv6als.pm view on Meta::CPAN
have a value greater than one
1 for MacOS
4 $uid Numeric user ID of file's owner
zero for MSWin32
zero for MacOS
5 $gid Numeric group ID of file's owner
zero for MSWin32
zero for MacOS
6 $rdev The device identifier (special files only)
drive number for MSWin32
NULL for MacOS
Char-JIS8
view release on metacpan or search on metacpan
lib/Ejis8.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Ejis8::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-KOI8R
view release on metacpan or search on metacpan
lib/Ekoi8r.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Ekoi8r::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-KOI8U
view release on metacpan or search on metacpan
lib/Ekoi8u.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Ekoi8u::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-KPS9566
view release on metacpan or search on metacpan
lib/Ekps9566.pm view on Meta::CPAN
return wantarray ? (-M _,@_) : -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return wantarray ? ($M,@_) : $M;
}
}
lib/Ekps9566.pm view on Meta::CPAN
return wantarray ? (-A _,@_) : -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return wantarray ? ($A,@_) : $A;
}
}
lib/Ekps9566.pm view on Meta::CPAN
return wantarray ? (-C _,@_) : -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return wantarray ? ($C,@_) : $C;
}
}
lib/Ekps9566.pm view on Meta::CPAN
return -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return $M;
}
}
lib/Ekps9566.pm view on Meta::CPAN
return -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return $A;
}
}
lib/Ekps9566.pm view on Meta::CPAN
return -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return $C;
}
}
lib/Ekps9566.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Ekps9566::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
lib/Ekps9566.pm view on Meta::CPAN
Ekps9566::O(*), Ekps9566::O_() File or directory is owned by this real user
Ekps9566::p(*), Ekps9566::p_() Entry is a named pipe (a "fifo")
Ekps9566::b(*), Ekps9566::b_() Entry is a block-special file (like a mountable disk)
Ekps9566::c(*), Ekps9566::c_() Entry is a character-special file (like an I/O device)
Ekps9566::u(*), Ekps9566::u_() File or directory is setuid
Ekps9566::g(*), Ekps9566::g_() File or directory is setgid
Ekps9566::k(*), Ekps9566::k_() File or directory has the sticky bit set
------------------------------------------------------------------------------
The tests -T and -B takes a try at telling whether a file is text or binary.
But people who know a lot about filesystems know that there's no bit (at least
lib/Ekps9566.pm view on Meta::CPAN
In scalar context, this subroutine returns a Boolean value that indicates whether
the call succeeded. In list context, it returns a 13-element list giving the
statistics for a file, either the file opened via FILEHANDLE or DIRHANDLE, or
named by $expr. It's typically used as followes:
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
$atime,$mtime,$ctime,$blksize,$blocks) = Ekps9566::stat($expr);
Not all fields are supported on all filesystem types; unsupported fields return
0. Here are the meanings of the fields:
lib/Ekps9566.pm view on Meta::CPAN
have a value greater than one
1 for MacOS
4 $uid Numeric user ID of file's owner
zero for MSWin32
zero for MacOS
5 $gid Numeric group ID of file's owner
zero for MSWin32
zero for MacOS
6 $rdev The device identifier (special files only)
drive number for MSWin32
NULL for MacOS
Char-Latin1
view release on metacpan or search on metacpan
lib/Elatin1.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Elatin1::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Latin10
view release on metacpan or search on metacpan
lib/Elatin10.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Elatin10::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Latin2
view release on metacpan or search on metacpan
lib/Elatin2.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Elatin2::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Latin3
view release on metacpan or search on metacpan
lib/Elatin3.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Elatin3::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Latin4
view release on metacpan or search on metacpan
lib/Elatin4.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Elatin4::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Latin5
view release on metacpan or search on metacpan
lib/Elatin5.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Elatin5::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Latin6
view release on metacpan or search on metacpan
lib/Elatin6.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Elatin6::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Latin7
view release on metacpan or search on metacpan
lib/Elatin7.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Elatin7::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Latin8
view release on metacpan or search on metacpan
lib/Elatin8.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Elatin8::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Latin9
view release on metacpan or search on metacpan
lib/Elatin9.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Elatin9::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-OldUTF8
view release on metacpan or search on metacpan
lib/Eoldutf8.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Eoldutf8::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Sjis
view release on metacpan or search on metacpan
lib/Esjis.pm view on Meta::CPAN
return wantarray ? (-M _,@_) : -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return wantarray ? ($M,@_) : $M;
}
}
lib/Esjis.pm view on Meta::CPAN
return wantarray ? (-A _,@_) : -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return wantarray ? ($A,@_) : $A;
}
}
lib/Esjis.pm view on Meta::CPAN
return wantarray ? (-C _,@_) : -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return wantarray ? ($C,@_) : $C;
}
}
lib/Esjis.pm view on Meta::CPAN
return -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return $M;
}
}
lib/Esjis.pm view on Meta::CPAN
return -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return $A;
}
}
lib/Esjis.pm view on Meta::CPAN
return -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return $C;
}
}
lib/Esjis.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Esjis::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
lib/Esjis.pm view on Meta::CPAN
Esjis::O(*), Esjis::O_() File or directory is owned by this real user
Esjis::p(*), Esjis::p_() Entry is a named pipe (a "fifo")
Esjis::b(*), Esjis::b_() Entry is a block-special file (like a mountable disk)
Esjis::c(*), Esjis::c_() Entry is a character-special file (like an I/O device)
Esjis::u(*), Esjis::u_() File or directory is setuid
Esjis::g(*), Esjis::g_() File or directory is setgid
Esjis::k(*), Esjis::k_() File or directory has the sticky bit set
------------------------------------------------------------------------------
The tests -T and -B takes a try at telling whether a file is text or binary.
But people who know a lot about filesystems know that there's no bit (at least
lib/Esjis.pm view on Meta::CPAN
In scalar context, this subroutine returns a Boolean value that indicates whether
the call succeeded. In list context, it returns a 13-element list giving the
statistics for a file, either the file opened via FILEHANDLE or DIRHANDLE, or
named by $expr. It's typically used as followes:
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
$atime,$mtime,$ctime,$blksize,$blocks) = Esjis::stat($expr);
Not all fields are supported on all filesystem types; unsupported fields return
0. Here are the meanings of the fields:
lib/Esjis.pm view on Meta::CPAN
have a value greater than one
1 for MacOS
4 $uid Numeric user ID of file's owner
zero for MSWin32
zero for MacOS
5 $gid Numeric group ID of file's owner
zero for MSWin32
zero for MacOS
6 $rdev The device identifier (special files only)
drive number for MSWin32
NULL for MacOS
Char-TIS620
view release on metacpan or search on metacpan
lib/Etis620.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Etis620::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-UHC
view release on metacpan or search on metacpan
lib/Euhc.pm view on Meta::CPAN
return wantarray ? (-M _,@_) : -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return wantarray ? ($M,@_) : $M;
}
}
lib/Euhc.pm view on Meta::CPAN
return wantarray ? (-A _,@_) : -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return wantarray ? ($A,@_) : $A;
}
}
lib/Euhc.pm view on Meta::CPAN
return wantarray ? (-C _,@_) : -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return wantarray ? ($C,@_) : $C;
}
}
lib/Euhc.pm view on Meta::CPAN
return -M _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $M = ($^T - $mtime) / (24*60*60);
return $M;
}
}
lib/Euhc.pm view on Meta::CPAN
return -A _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $A = ($^T - $atime) / (24*60*60);
return $A;
}
}
lib/Euhc.pm view on Meta::CPAN
return -C _;
}
else {
my $fh = gensym();
if (_open_r($fh, $_)) {
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = CORE::stat $fh;
close($fh) or die "Can't close file: $_: $!";
my $C = ($^T - $ctime) / (24*60*60);
return $C;
}
}
lib/Euhc.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Euhc::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
lib/Euhc.pm view on Meta::CPAN
Euhc::O(*), Euhc::O_() File or directory is owned by this real user
Euhc::p(*), Euhc::p_() Entry is a named pipe (a "fifo")
Euhc::b(*), Euhc::b_() Entry is a block-special file (like a mountable disk)
Euhc::c(*), Euhc::c_() Entry is a character-special file (like an I/O device)
Euhc::u(*), Euhc::u_() File or directory is setuid
Euhc::g(*), Euhc::g_() File or directory is setgid
Euhc::k(*), Euhc::k_() File or directory has the sticky bit set
------------------------------------------------------------------------------
The tests -T and -B takes a try at telling whether a file is text or binary.
But people who know a lot about filesystems know that there's no bit (at least
lib/Euhc.pm view on Meta::CPAN
In scalar context, this subroutine returns a Boolean value that indicates whether
the call succeeded. In list context, it returns a 13-element list giving the
statistics for a file, either the file opened via FILEHANDLE or DIRHANDLE, or
named by $expr. It's typically used as followes:
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
$atime,$mtime,$ctime,$blksize,$blocks) = Euhc::stat($expr);
Not all fields are supported on all filesystem types; unsupported fields return
0. Here are the meanings of the fields:
lib/Euhc.pm view on Meta::CPAN
have a value greater than one
1 for MacOS
4 $uid Numeric user ID of file's owner
zero for MSWin32
zero for MacOS
5 $gid Numeric group ID of file's owner
zero for MSWin32
zero for MacOS
6 $rdev The device identifier (special files only)
drive number for MSWin32
NULL for MacOS
Char-USASCII
view release on metacpan or search on metacpan
lib/Eusascii.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Eusascii::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-UTF2
view release on metacpan or search on metacpan
lib/Eutf2.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Eutf2::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Windows1252
view release on metacpan or search on metacpan
lib/Ewindows1252.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Ewindows1252::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
Char-Windows1258
view release on metacpan or search on metacpan
lib/Ewindows1258.pm view on Meta::CPAN
leave out the chomp, in which case $shell would have a newline on the end of it.
open(PASSWD, "/etc/passwd");
while (<PASSWD>) {
chomp; # remove trailing newline.
($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
Ewindows1258::split(/:/);
...
}
Here's how process each word of each line of each file of input to create a
( run in 1.750 second using v1.01-cache-2.11-cpan-ceb78f64989 )