Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

POSIX::isdigit() returns 1 for the empty string #11148

Closed
p5pRT opened this issue Feb 22, 2011 · 37 comments
Closed

POSIX::isdigit() returns 1 for the empty string #11148

p5pRT opened this issue Feb 22, 2011 · 37 comments

Comments

@p5pRT
Copy link

p5pRT commented Feb 22, 2011

Migrated from rt.perl.org#84680 (status was 'resolved')

Searchable as RT84680$

@p5pRT
Copy link
Author

p5pRT commented Feb 22, 2011

From perlbug@cg.cjb.net

Created by perlbug@cg.cjb.net

POSIX​::isdigit() returns 1 for the empty string which is
obviously wrong​:

$ perl -MPOSIX -e 'print isdigit(""), "\n"'
1
$

That's probably because RETVAL is initialised to 1 in POSIX.xs
regardless of the string length (which is the case in all is*()
functions ...).

Verified with Perl 5.8.8, 5.10.1 and 5.12.3

Perl Info

Flags:
     category=library
     severity=medium
     module=POSIX

Site configuration information for perl 5.12.3:

Configured by xx at Tue Feb 22 16:50:33 CET 2011.

Summary of my perl5 (revision 5 version 12 subversion 3) configuration:

   Platform:
     osname=linux, osvers=2.6.34.7-66.fc13.i686.pae, archname=i686-linux
     uname='linux xx 2.6.34.7-66.fc13.i686.pae #1 smp wed dec 15 
07:21:49 utc 2010 i686 i686 i386 gnulinux '
     config_args='-de -Dprefix=/tmp/perl-5.12.3'
     hint=recommended, useposix=true, d_sigaction=define
     useithreads=undef, usemultiplicity=undef
     useperlio=define, d_sfio=undef, uselargefiles=define, usesocks=undef
     use64bitint=undef, use64bitall=undef, uselongdouble=undef
     usemymalloc=n, bincompat5005=undef
   Compiler:
     cc='cc', ccflags ='-fno-strict-aliasing -pipe -fstack-protector 
-I/usr/local/include -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64',
     optimize='-O2',
     cppflags='-fno-strict-aliasing -pipe -fstack-protector 
-I/usr/local/include'
     ccversion='', gccversion='4.4.5 20101112 (Red Hat 4.4.5-2)', 
gccosandvers=''
     intsize=4, longsize=4, ptrsize=4, doublesize=8, byteorder=1234
     d_longlong=define, longlongsize=8, d_longdbl=define, longdblsize=12
     ivtype='long', ivsize=4, nvtype='double', nvsize=8, Off_t='off_t', 
lseeksize=8
     alignbytes=4, prototype=define
   Linker and Libraries:
     ld='cc', ldflags =' -fstack-protector -L/usr/local/lib'
     libpth=/usr/local/lib /lib /usr/lib
     libs=-lnsl -ldl -lm -lcrypt -lutil -lc
     perllibs=-lnsl -ldl -lm -lcrypt -lutil -lc
     libc=/lib/libc-2.12.2.so, so=so, useshrplib=false, libperl=libperl.a
     gnulibc_version='2.12.2'
   Dynamic Linking:
     dlsrc=dl_dlopen.xs, dlext=so, d_dlsymun=undef, ccdlflags='-Wl,-E'
     cccdlflags='-fPIC', lddlflags='-shared -O2 -L/usr/local/lib 
-fstack-protector'

Locally applied patches:



@INC for perl 5.12.3:
     /tmp/perl-5.12.3/lib/site_perl/5.12.3/i686-linux
     /tmp/perl-5.12.3/lib/site_perl/5.12.3
     /tmp/perl-5.12.3/lib/5.12.3/i686-linux
     /tmp/perl-5.12.3/lib/5.12.3
     .


Environment for perl 5.12.3:
     HOME=/home/xx
     LANG=en_US.UTF-8
     LANGUAGE (unset)
     LD_LIBRARY_PATH (unset)
     LOGDIR (unset)
 
PATH=/usr/kerberos/sbin:/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/home/xx/bin
     PERL_BADLANG (unset)
     SHELL=/bin/bash

@p5pRT
Copy link
Author

p5pRT commented Feb 24, 2011

From Mark@Overmeer.net

* Robert Lang (perlbug-followup@​perl.org) [110224 08​:33]​:

# New Ticket Created by Robert Lang
# Please include the string​: [perl #84680]
# in the subject line of all future correspondence about this issue.
# <URL​: http​://rt.perl.org/rt3/Ticket/Display.html?id=84680 >

This is a bug report for perl from perlbug@​cg.cjb.net,
generated with the help of perlbug 1.39 running under perl 5.12.3.

-----------------------------------------------------------------
[Please describe your issue here]

POSIX​::isdigit() returns 1 for the empty string which is
obviously wrong​:

$ perl -MPOSIX -e 'print isdigit(""), "\n"'
1
$

That's probably because RETVAL is initialised to 1 in POSIX.xs
regardless of the string length (which is the case in all is*()
functions ...).

Although POSIX.pod says​:

  isdigit This is identical to the C function, except that it can apply
  to a single character or to a whole string.

that is not true. There is very little the same as in the C function
with the same name.

The real way the implementation should be described is more like​:

  isdigit Returns false if the string only contains digits.

All these "isXXXX" functions are implemented that way.
Of course, with the correct description in the POD, this result is
logical​: the empty string does not contain any conflicting characters.

  * DO NOT USE POSIX​::isdigit() but regexes *
--
Regards,
  MarkOv


  Mark Overmeer MSc MARKOV Solutions
  Mark@​Overmeer.net solutions@​overmeer.net
http​://Mark.Overmeer.net http​://solutions.overmeer.net

@p5pRT
Copy link
Author

p5pRT commented Feb 24, 2011

The RT System itself - Status changed from 'new' to 'open'

@p5pRT
Copy link
Author

p5pRT commented Feb 24, 2011

From Mark@Overmeer.net

* Mark Overmeer (mark@​overmeer.net) [110224 09​:25]​:

* Robert Lang (perlbug-followup@​perl.org) [110224 08​:33]​:

# <URL​: http​://rt.perl.org/rt3/Ticket/Display.html?id=84680 >

The real way the implementation should be described is more like​:
isdigit Returns false if the string only contains digits.

Second attempt

  isdigit

  Returns true when all the bytes in the scalar are values in the
  digits range of the effective character-set. Does not respect
  the utf8 flag. Does not work with multi-byte character-sets.

I hope people will accept my (massive) patches to POSIX.pod for 5.14
--
Regards,

  MarkOv


  Mark Overmeer MSc MARKOV Solutions
  Mark@​Overmeer.net solutions@​overmeer.net
http​://Mark.Overmeer.net http​://solutions.overmeer.net

@p5pRT
Copy link
Author

p5pRT commented Feb 24, 2011

From @ikegami

On Thu, Feb 24, 2011 at 4​:42 AM, Mark Overmeer <mark@​overmeer.net> wrote​:

* Mark Overmeer (mark@​overmeer.net) [110224 09​:25]​:

The real way the implementation should be described is more like​:
isdigit Returns false if the string only contains digits.

Second attempt

isdigit

  Returns true when all the bytes in the scalar are values in the
  digits range of the effective character\-set\. Does not respect
  the utf8 flag\. Does not work with multi\-byte character\-sets\.

What does "not respect the UTF8 flag mean"? Does it mean there's an $x where

utf8​::downgrade($dx = $x);
utf8​::upgrade($ux = $x);
islower($dx) != islower($ux)

If so, we should fix it rather than documented it.

@p5pRT
Copy link
Author

p5pRT commented Feb 25, 2011

From @smpeters

On Tue, Feb 22, 2011 at 10​:27 AM, Robert Lang <perlbug-followup@​perl.org>wrote​:

# New Ticket Created by Robert Lang
# Please include the string​: [perl #84680]
# in the subject line of all future correspondence about this issue.
# <URL​: http​://rt.perl.org/rt3/Ticket/Display.html?id=84680 >

This is a bug report for perl from perlbug@​cg.cjb.net,
generated with the help of perlbug 1.39 running under perl 5.12.3.

-----------------------------------------------------------------
[Please describe your issue here]

POSIX​::isdigit() returns 1 for the empty string which is
obviously wrong​:

$ perl -MPOSIX -e 'print isdigit(""), "\n"'
1
$

That's probably because RETVAL is initialised to 1 in POSIX.xs
regardless of the string length (which is the case in all is*()
functions ...).

Verified with Perl 5.8.8, 5.10.1 and 5.12.3

Thanks for the report. I do have a fix ready for this, but before I commit
this, this technically effects all the ifXXX() functions. Also, in the
ext/POSIX/t/posix.t we have...

# metaphysical question : what should be returned for an empty string ?
# anyway this shouldn't segfault (bug #24554)
ok( POSIX​::isalnum(''), 'isalnum empty string' );
ok( POSIX​::isalnum(undef),'isalnum undef' );

For this following basic C program...

#include <ctype.h>
#include <stdio.h>

int
main() {
  char* aiieee = "";
  int crr_aaack = isdigit(foo);
  printf("%d\n", crr_aaack);
}

Linux core dumps while MAC OS X prints 0. Trying...

char aiieee = '';

instead fails to compile. If I'm following the spirit of C, then I'm
thinking passing an empty string or undef to the isXXX() functions should
return 0.

Steve Peters
steve@​fisharerojo.org

@p5pRT
Copy link
Author

p5pRT commented Feb 25, 2011

From Mark@Overmeer.net

* Steve Peters (steve@​fisharerojo.org) [110225 04​:05]​:

On Tue, Feb 22, 2011 at 10​:27 AM, Robert Lang <perlbug-followup@​perl.org>wrote​:

$ perl -MPOSIX -e 'print isdigit(""), "\n"'

Thanks for the report. I do have a fix ready for this, but before I commit
this, this technically effects all the ifXXX() functions. Also, in the
ext/POSIX/t/posix.t we have...

The change in C is simple, of course, but it will break existing
implementations. This is a flaw in the docs, not in the code.
--
Regards,
  MarkOv


  Mark Overmeer MSc MARKOV Solutions
  Mark@​Overmeer.net solutions@​overmeer.net
http​://Mark.Overmeer.net http​://solutions.overmeer.net

@p5pRT
Copy link
Author

p5pRT commented Feb 25, 2011

From perlbug@cg.cjb.net

"Returns true when all the bytes in the scalar are values in the
digits range" should read "Returns true *if and only if* all the bytes
in the scalar are values in the digit range". Anything else is
counter-inutitive given the name isdigit.

Shouldn't be too hard to initialise RETVAL = len ? 1 : 0 or something.

BTW, I didn't receive any mail from your RT when you replied.

@p5pRT
Copy link
Author

p5pRT commented Feb 25, 2011

From @smpeters

On Fri, Feb 25, 2011 at 1​:02 AM, Mark Overmeer <mark@​overmeer.net> wrote​:

* Steve Peters (steve@​fisharerojo.org) [110225 04​:05]​:

On Tue, Feb 22, 2011 at 10​:27 AM, Robert Lang <perlbug-followup@​perl.org
wrote​:

$ perl -MPOSIX -e 'print isdigit(""), "\n"'

Thanks for the report. I do have a fix ready for this, but before I
commit
this, this technically effects all the ifXXX() functions. Also, in the
ext/POSIX/t/posix.t we have...

The change in C is simple, of course, but it will break existing
implementations. This is a flaw in the docs, not in the code.

Occasionally, people depend on the behavior of bugs, like people that
depending on Carp being accidentally pulled in with "use warnings". That
makes it no less of a bug to be fixed. As the behavior of the function is
not documented regarding what happens when an empty string or undef is
passed in, we still have room to define it. I'll be sure to add the
documentation fix as well.

Also, looking into the history of the code, it did at one time do exactly
what Linux did when passed an empty string. It core dumped.

Steve Peters
steve@​fisharerojo.org

@p5pRT
Copy link
Author

p5pRT commented Feb 25, 2011

From perlbug@cg.cjb.net

On Thu Feb 24 23​:03​:14 2011, Mark@​Overmeer.net wrote​:

This is a flaw in the docs, not in the code.

Just to make sure I get this right​: You are saying you want the publicly
available Perl docs to state explicitly that "We know that Perl contains
greenhorn mistakes but we are not going to fix them"? Pity.

@p5pRT
Copy link
Author

p5pRT commented Feb 25, 2011

From @Abigail

On Thu, Feb 24, 2011 at 10​:59​:23PM +0100, Robert Lang wrote​:

"Returns true when all the bytes in the scalar are values in the
digits range" should read "Returns true *if and only if* all the bytes
in the scalar are values in the digit range". Anything else is
counter-inutitive given the name isdigit.

Note that both descriptions do not contradict isdigit("") == 1. After all,
the string does not contain any byte that isn't in the digit range.

Now, where I someone who doesn't frequent p5p, I'd go "Bytes? WTF? I thought
this was Perl, not C".

I bet the average Perl programmer will assume, even after reading the above
descriptions, for isdigit($str) to be equivalent of $str =~ /^\d+$/ (or
perhaps /^\d$/). Some of them while thinking \d is equivalent to [0-9].

Is there a reason the description uses vague terms like "digits range",
instead of 0-9?

Abigail

@p5pRT
Copy link
Author

p5pRT commented Feb 25, 2011

From @Leont

On Fri, Feb 25, 2011 at 5​:52 PM, Abigail <abigail@​abigail.be> wrote​:

Is there a reason the description uses vague terms like "digits range",
instead of 0-9?

Because according to POSIX «The isdigit() function shall test whether
c is a character of class digit in the program's current locale».

Leon

@p5pRT
Copy link
Author

p5pRT commented Feb 25, 2011

From @Abigail

On Fri, Feb 25, 2011 at 06​:03​:54PM +0100, Leon Timmermans wrote​:

On Fri, Feb 25, 2011 at 5​:52 PM, Abigail <abigail@​abigail.be> wrote​:

Is there a reason the description uses vague terms like "digits range",
instead of 0-9?

Because according to POSIX «The isdigit() function shall test whether
c is a character of class digit in the program's current locale».

But surely, something like "digits 0-9 (unless your locale defines other
digits)" or "digits 0-9 (or what is defined by your locale)" is clearer?
Many people don't use locales, or don't even know what they are - does it
hurt to mention the general case first, and be explicite about the exception
instead of using a phrase that will leave many puzzled (and many to assume
something else than intended)?

Abigail

@p5pRT
Copy link
Author

p5pRT commented Feb 25, 2011

From @smpeters

On Fri, Feb 25, 2011 at 1​:16 PM, Abigail <abigail@​abigail.be> wrote​:

On Fri, Feb 25, 2011 at 06​:03​:54PM +0100, Leon Timmermans wrote​:

On Fri, Feb 25, 2011 at 5​:52 PM, Abigail <abigail@​abigail.be> wrote​:

Is there a reason the description uses vague terms like "digits range",
instead of 0-9?

Because according to POSIX «The isdigit() function shall test whether
c is a character of class digit in the program's current locale».

But surely, something like "digits 0-9 (unless your locale defines other
digits)" or "digits 0-9 (or what is defined by your locale)" is clearer?
Many people don't use locales, or don't even know what they are - does it
hurt to mention the general case first, and be explicite about the
exception
instead of using a phrase that will leave many puzzled (and many to assume
something else than intended)?

Abigail

It certainly never hurts to clarify. I'll clear that up as well.

Steve Peters
steve@​fisharerojo.org

@p5pRT
Copy link
Author

p5pRT commented Feb 5, 2013

From @jkeenan

On Fri Feb 25 11​:34​:59 2011, stmpeters wrote​:

On Fri, Feb 25, 2011 at 1​:16 PM, Abigail <abigail@​abigail.be> wrote​:

On Fri, Feb 25, 2011 at 06​:03​:54PM +0100, Leon Timmermans wrote​:

On Fri, Feb 25, 2011 at 5​:52 PM, Abigail <abigail@​abigail.be>
wrote​:

Is there a reason the description uses vague terms like "digits
range",
instead of 0-9?

Because according to POSIX �The isdigit() function shall test
whether
c is a character of class digit in the program's current locale�.

But surely, something like "digits 0-9 (unless your locale defines
other
digits)" or "digits 0-9 (or what is defined by your locale)" is
clearer?
Many people don't use locales, or don't even know what they are -
does it
hurt to mention the general case first, and be explicite about the
exception
instead of using a phrase that will leave many puzzled (and many to
assume
something else than intended)?

Abigail

It certainly never hurts to clarify. I'll clear that up as well.

Steve Peters
steve@​fisharerojo.org

ext/POSIX/lib/POSIX.pod currently states with respect to 'isdigit'​:

#####
=item isdigit

This is identical to the C function, except that it can apply to
a single character or to a whole string. Note that locale settings
may affect what characters are considered C<isdigit> (unlikely, but
still possible). Does not work on Unicode characters code point 256
or higher. Consider using regular expressions and the C</[[​:digit​:]]/>
construct instead, or the C</\d/> construct.
#####

Is that sufficient to resolve the issues raised in this RT and enable us
to close this ticket?

Thank you very much.
Jim Keenan

@p5pRT
Copy link
Author

p5pRT commented Feb 5, 2013

From @khwilliamson

On Mon Feb 04 19​:10​:08 2013, jkeenan wrote​:

On Fri Feb 25 11​:34​:59 2011, stmpeters wrote​:

On Fri, Feb 25, 2011 at 1​:16 PM, Abigail <abigail@​abigail.be> wrote​:

On Fri, Feb 25, 2011 at 06​:03​:54PM +0100, Leon Timmermans wrote​:

On Fri, Feb 25, 2011 at 5​:52 PM, Abigail <abigail@​abigail.be>
wrote​:

Is there a reason the description uses vague terms like "digits
range",
instead of 0-9?

Because according to POSIX �The isdigit() function shall test
whether
c is a character of class digit in the program's current locale�.

But surely, something like "digits 0-9 (unless your locale defines
other
digits)" or "digits 0-9 (or what is defined by your locale)" is
clearer?
Many people don't use locales, or don't even know what they are -
does it
hurt to mention the general case first, and be explicite about the
exception
instead of using a phrase that will leave many puzzled (and many to
assume
something else than intended)?

Abigail

It certainly never hurts to clarify. I'll clear that up as well.

Steve Peters
steve@​fisharerojo.org

ext/POSIX/lib/POSIX.pod currently states with respect to 'isdigit'​:

#####
=item isdigit

This is identical to the C function, except that it can apply to
a single character or to a whole string. Note that locale settings
may affect what characters are considered C<isdigit> (unlikely, but
still possible). Does not work on Unicode characters code point 256
or higher. Consider using regular expressions and the C</[[​:digit​:]]/>
construct instead, or the C</\d/> construct.
#####

Is that sufficient to resolve the issues raised in this RT and enable us
to close this ticket?

Thank you very much.
Jim Keenan

I'm trying to understand the thread above, and don't. Why can't we
change the behavior as the OP requested?

--
Karl Williamson

@p5pRT
Copy link
Author

p5pRT commented Feb 5, 2013

From Mark@Overmeer.net

* James E Keenan via RT (perlbug-followup@​perl.org) [130205 03​:10]​:

On Fri Feb 25 11​:34​:59 2011, stmpeters wrote​:

On Fri, Feb 25, 2011 at 06​:03​:54PM +0100, Leon Timmermans wrote​:

On Fri, Feb 25, 2011 at 5​:52 PM, Abigail <abigail@​abigail.be>
wrote​:

Is there a reason the description uses vague terms like "digits
range",
instead of 0-9?

ext/POSIX/lib/POSIX.pod currently states with respect to 'isdigit'​:

#####
=item isdigit

This is identical to the C function, except that it can apply to
a single character or to a whole string. Note that locale settings
may affect what characters are considered C<isdigit> (unlikely, but
still possible). Does not work on Unicode characters code point 256
or higher. Consider using regular expressions and the C</[[​:digit​:]]/>
construct instead, or the C</\d/> construct.
#####

Is that sufficient to resolve the issues raised in this RT and enable us
to close this ticket?

This description is really broken in many, many ways. I even gave
a presentation about this at YAPC​::EU.

I have a new version for the whole POSIX.pm manual-page attached. It has
been read by a few core members (like RJBS and David Golden) in older
versions, with positive remarks. But, as non-core and non-native speaker,
I hessitate posting it... Can you take that from me to include in core?
--
Regards,

  MarkOv


  Mark Overmeer MSc MARKOV Solutions
  Mark@​Overmeer.net solutions@​overmeer.net
http​://Mark.Overmeer.net http​://solutions.overmeer.net

@p5pRT
Copy link
Author

p5pRT commented Feb 5, 2013

From Mark@Overmeer.net

=head1 NAME

POSIX - Additional operating system access

=head1 SYNOPSIS

  use POSIX ();
  use POSIX qw(setsid);
  use POSIX qw(​:errno_h :fcntl_h);

  printf "EINTR is %d\n", EINTR;

  $sess_id = POSIX​::setsid();

  $fd = POSIX​::open($path, O_CREAT|O_EXCL|O_WRONLY, 0644);
  # note​: that's a filedescriptor, *NOT* a filehandle

=head1 DESCRIPTION

The POSIX standards specify a common interface to operating system.
POSIX 1003.1-2008, published by I<The Open Group>, lists nearly 1200
functions which are supported on many platforms. Quite a number of these
functions are provided by perl itself (in Perl I<Core>), often with the
same name but more powerful. A few dozen are provided by this C<POSIX>
module. Some additional functions are available via CPAN modules.

The first section describes POSIX functions from the 1003.1 specification.
The second section describes some classes for signal objects, TTY objects,
and other miscellaneous objects. The remaining sections list various
constants and macros in an organization which roughly follows IEEE Std
1003.1b-1993.

=head2 General warnings

POSIX is a standard with a long history, deeply tied into the Operating
System. This means that you will encounter (sometimes large, often small)
differences when used on different platforms. Perl's core and modules
often attempt to hide differences, but is not always succesful.

I<Everything is exported by default> with the exception of any POSIX
functions with the same name as a built-in Perl function, such as
C<abs>, C<alarm>, C<rmdir>, C<write>, etc.., which will be exported
only if you ask for them explicitly. This is an unfortunate backwards
compatibility feature. You can stop the exporting by saying C<use
POSIX ()> and then use the fully qualified names (ie. C<POSIX​::SEEK_END>),
or by giving an explicit import list. If you do neither, and opt for the
default, C<use POSIX;> will import I<553 symbols>.

This document gives a condensed list of the useful functions provided
by this module. Consult your operating system's manpages for general
information about their functionality.

=head1 MISTAKES, BUGS and other problems

This C<POSIX> module is ancient. On CPAN, you can find the module
L<POSIX​::1003> with manual page C<POSIX​::Overview>, which is an attempt
to provide a more complete overview on how the POSIX interface is
available in Perl.

The functionality of this C<POSIX> module is kept as it has been
for two decades, not to break existing applications. On the other
hand​: there are many problems with this module.

You may take a look at L<POSIX​::Overview> whether there are ways to
achieve the desired functionality. The L<POSIX​::1003> set of
modules export the same (and more) functions and constants without
the here described problems of this POSIX module.

=head2 Not implemented

The following functions can be imported, but will croak as "not
implemented" or "not implementable" when called. They will (very
probably) never get implemented in this module.

  atexit atof atoi atol bsearch calloc div execl execle execlp
  execv execve execvp fprintf fputc fputs fread free freopen
  fscanf fwrite labs ldiv longjmp malloc memchr memcmp memcpy
  memmove memset offsetof putc putchar puts qsort rand realloc
  scanf setjmp siglongjmp sigsetjmp srand sscanf strcat strchr
  strcmp strcpy strcspn strlen strncat strncmp strncpy strpbrk
  strrchr strspn strtok vfprintf vprintf vsprintf

The following functions croak while pointing you to implementations
with the same name​:

  clearerr fclose fdopen feof ferror fflush fgetc fgetpos fgets
  fileno fopen fseek fsetpos fsync ftell setbuf setvbuf tmpfile
  ungetc

But there are about 800 more functions in POSIX which are also not
implemented in this module but never got implemented to croak nor
documented. They also do not work, of course.

=head2 Avoidable wrappers

The following functions are exported by C<POSIX>, but are simply
calling a function with the same name from CORE. The only (and major)
difference between the exported function and the version in CORE, is
that the exported versions do not have a prototype on them.

Provided CORE function wrappers without prototype​:

  abs alarm atan2 chdir chmod chown closedir cos exit exp
  fcntl fork getc getgrgid getgrnam getlogin getpgrp getppid
  getpwnam getpwuid gmtime link localtime log mkdir readdir
  rename rewinddir rmdir sin sprintf sqrt stat system time
  umask unlink wait waitpid

Please do not use these for new code, because it will confuse other
programmers who do expect prototypes on those functions. For instance,
These two programs will exit with a different value​:

  use POSIX qw(exit);
  ...zillion lines of code.... ...zillion lines of code....
  exit 3 + 3; exit 3 + 3;

=head2 Incompatible, but close

The following have the same name as C functions or macro's but work
on byte streams (interpreted in locale), not Perl's concept of strings
(no idea what utf-8 means, for instance) Practically unusable.

  tolower toupper isalnum isalpha iscntrl isdigit isgraph islower isprint
  ispunct isspace isupper isxdigit mblen mbstowcs mbtowc strcfrm strcoll
  wcstombs wctomb

=head2 Mess-up the parameters

Be warned that a few functions, when imported, change the way that
your program is interpreted. For instance, the C<open> provided by
POSIX works with file I<descriptors>, where the standard open works
with file I<handles>. But also, some of these functions do usually have
default arguments which disappear when you import the names from POSIX.
These may be a cause of nasty bugs. B<Be very careful!>

  chmod chown chown cos gmtime isatty kill localtime log mkdir open
  opendir pipe printf read rmdir sin sleep sqrt stat system tan
  times umask unlink utime utime waitpid write

=head2 Useless functions

Provided, but useless functions (although there will always be a
few people who find a use for them)

  mblen mbstowcs mbtowc strcoll strxfrm wcstombs wctomb

=head1 FUNCTIONS

The following functions are provided. Please read the specifics about
their functionality in the related manual-page on your platform.

=over 8

=item _exit

Stop the process without executing the usual clean destruction of a
Perl program. This may be needed in programs using threads or C<fork()>
to keep one processes clean-up from disturbing other.

On some systems, file-handles do not get flushed. Leaving a program with
C<_exit> is blunt and should not be used without further reading about
of the implications on your platform.

=item abort

Call the SIGABRT handler and leave the program. See L<perlipc>.

=item access

Determines the accessibility of a file. Returns C<undef> on failure.
Note that, between the C<access()> call and the operation you are preparing
for, the permissions might change​: a classic I<race condition>.

  use POSIX qw(access R_OK);
  if(access( "/", R_OK)) {
  print "have read permission\n";
  }

See module L<filetest>.

=item acos

The arcus cosine of its numerical argument.

=item asctime

Returns a string of the form

  "Fri Jun 2 18​:22​:13 2000\n"

and it is called thusly

  $a = asctime($sec, $min, $hour, $mday, $mon, $year,
  $wday, $yday, $isdst);
  print asctime localtime;

See C<mktime()> for an explanation on the parameters.

=item asin

The arcus sine of its numerical argument.

=item assert

Croaks with C<Carp​::croak()> when the parameter is false.

=item atan

The arcus tangent of its numerical argument.

=item ceil

Returns the smallest integer value greater than or equal
to the given numerical.

=item clock

Returning the amount of spent processor time by this process in
CLOCKS_PER_SEC.

=item close

Close the file descriptor, such as those obtained by calling
C<POSIX​::open>. Returns C<undef> on failure. See also L<perlfunc/close>.

  use POSIX qw(O_RDONLY);
  $fd = POSIX​::open("foo", O_RDONLY);
  POSIX​::close($fd);

=item cosh

The hyperbolic cosine of its numeric argument.

=item creat

Create a new file, returning a file descriptor. Use C<POSIX​::close>
to close the file. See also L<perlfunc/sysopen> and its C<O_CREAT> flag.

  $fd = POSIX​::creat( "foo", 0611 );
  POSIX​::close( $fd );

=item ctermid

Generates the path name for the controlling terminal.

  $path = POSIX​::ctermid();

=item ctime

Equivalent to C<asctime(localtime($t))>.

=item cuserid

Get the login name of the owner of the current process.

  $name = cuserid();

=item difftime

Returns the time difference (in seconds) between two times (as returned
by C<time()>), see C<time()>.

=item dup

Duplicate a file descriptor. Returns C<undef> on failure.

=item dup2

Duplicate a file descriptor to an explicit file descriptor.
Returns C<undef> on failure.

=item errno

Returns the value of errno.
This identical to the numerical values of the C<$!>, see L<perlvar/$ERRNO>.

  $errno = errno();
  $errno = $! + 0;

=item floor

The largest integer value less than or equal to the numerical argument.

=item fmod

Returns the remainder a division​:

  $r = fmod($x, $y);

=item fpathconf

Retrieves limitation information about a file or directory. This
uses file descriptors; see C<pathconf()> when you have a file handle
and for an example. Returns C<undef> on failure.

=item frexp

Return the mantissa and exponent of a floating-point number.

  ($mantissa, $exponent) = POSIX​::frexp( 1.234e56 );

=item fstat

Get file status via a file descriptor. The data structure returned is
the same as for Perl's builtin C<stat> function.

  use POSIX qw(O_RDONLY fstat);
  $fd = POSIX​::open( "foo", RDONLY );
  @​stats = fstat( $fd );

=item getcwd

Returns the path to the current working directory.
See also L<Cwd>.

=item getgroups

Returns the ids of the user's supplementary groups​: all unique
values from builtin variable C<$)>. See L<perlvar/$GID>.

=item gets

Returns one line from C<STDIN>. See L<perlfunc/readline>.

=item getuid

Same as C<$)>.

=item geteuid

Same as C<< $> >>

=item getgid

Same as C<$(>

=item getegid

Same as C<< $< >>

=item isalnum

Returns true when all bytes in the stringified parameter match
C<[[​:alnum​:]]>.

As all of the next functions, the match is aware of the locale, but does
ignore the existence of Perl's utf-8 strings. You can much better use
character classes in regular expressions. See L<perunicode>.

=item isalpha

Returns true when all bytes in the stringified parameter match
C<[[​:alpha​:]]>

=item iscntrl

Returns true when all bytes in the stringified parameter match
C<[[​:cntrl​:]]>

=item isdigit

Returns true when all bytes in the stringified parameter match
C<[[​:digit​:]]>

=item isgraph

Returns true when all bytes in the stringified parameter match
C<[[​:graph​:]]>

=item islower

Returns true when all bytes in the stringified parameter match
C<[[​:lower​:]]>

=item isprint

Returns true when all bytes in the stringified parameter match
C<[[​:print​:]]>

=item ispunct

Returns true when all bytes in the stringified parameter match
C<[[​:print​:]]>

=item isspace

Returns true when all bytes in the stringified parameter match
C<[[​:space​:]]>

=item isupper

Returns true when all bytes in the stringified parameter match
C<[[​:upper​:]]>

=item isxdigit

Returns true when all bytes in the stringified parameter match
C<[[​:xdigit​:]]>

=item kill

Simply calls Perl's builtin C<kill()> function for sending signals
to processes, but with B<the parameters reversed>. see L<perlfunc/kill>.

  use POSIX qw(SIGHUP);
  POSIX​::kill($proc_id, SIGHUP);
  kill(SIGHUP, $proc_id);

=item lchown

Like C<chown()>, but will change the owner of the symlink when provided,
not the destination of the symlink.

As difference with the POSIX specs, is the order of arguments consistent
with Perl's builtin C<chown()> with B<the restriction of only one path>,
not an list of paths.

=item ldexp

Multiply the numberical argument with powers of two.

  $x_quadrupled = ldexp($x, 2);

=item localeconv

Returns a reference to a hash containing the current locale
formatting details. See L<perllocale>.

Here is how to query the database for the German language (B<de>).

  use POSIX qw(setlocale localeconv LC_ALL);
  $loc = setlocale( LC_ALL, "de" );
  print "Locale = $loc\n";
  $lconv = localeconv();

  use Data​::Dumper 'Dumper';
  print Dumper $lconv;

=item log10

The 10-base logarithm of the numerical argument.

=item lseek

Move the file's read/write position via a file descriptor.
Returns C<undef> on failure.

  use POSIX qw(O_RDONLY lseek SEEK_SET);
  $fd = POSIX​::open( "foo", O_RDONLY );
  $off_t = lseek( $fd, 0, SEEK_SET );

=item mkfifo

Create FIFO special files. Requires a name and a mode.
Returns C<undef> on failure. The C<$mode> is similar to the
mode of C<mkdir()>, see L<perlfunc/mkdir>.

  if(mkfifo($path, $mode)) { ....

=item mktime

Convert date/time info to a calendar time. Returns C<undef> on failure.

  mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = -1)

The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero.
I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The
year (C<year>) is given in years since 1900. I.e. The year 1995 is 95; the
year 2001 is 101.

Calendar time for December 12, 1995, at 10​:30 am.

  use POSIX qw(mktime ctime);
  $time_t = mktime( 0, 30, 10, 12, 11, 95 );
  print "Date = ", ctime($time_t);

=item modf

Return the integral and fractional parts of a floating-point number.

  ($fractional, $integral) = modf( 3.14 );

=item nice

Change the scheduling preference of the current process. Returns C<undef>
on failure. The exact meaning of the parameter and the returned value
is platform dependent.

=item open

Open a file for reading for writing, returning a file descriptor,
not a Perl file-handle. Use C<POSIX​::close> to close the file.
Returns C<undef> on failure. See also L<perlfunc/sysopen>.

B<Be warned> that people do not expect that Perl's C<open()> function
gets redefined to use file-descriptors! So better not import C<open>
and its related C<read>, C<write>, C<pipe>, and C<close> from POSIX into
your package namespace.

People use file-descriptor based IO to gain a tiny bit of performance
on file IO -avoiding the IO buffering within the program- or in event
driven IO (sockets, pipes, ...)

  use POSIX qw(fcntl_h);
  $fd = POSIX​::open( "foo" ); # read-only, mode 0666
  $fd = POSIX​::open( "foo", O_RDWR ); # read and write
  $fd = POSIX​::open( "foo", O_WRONLY|O_TRUNC ); # write and truncate
  $fd = POSIX​::open( "foo", O_CREAT|O_WRONLY, 0640 );

=item opendir

Open a directory for reading. Returns C<undef> on failure.

  $dir = POSIX​::opendir( "/var" );
  @​files = POSIX​::readdir( $dir );
  POSIX​::closedir( $dir );

  opendir(DIR, '/var');
  my @​files = readdir DIR;
  closedir DIR;
 
=item pathconf

Retrieves the value of a configurable limit on a file or directory.
Returns C<undef> on failure.

The following will determine the maximum length of the longest allowable
path on the filesystem which holds C</var/foo>.

  use POSIX qw(pathconf _PC_PATH_MAX);
  $path_max = pathconf( '/var/foo', _PC_PATH_MAX );

Be aware that the results are platform dependent​: the C<_PC_PATH_MAX>
key may be missing or the result may be C<undef>. In case of this
particular piece of information, the value will be more accurate than
the C<PATH_MAX> or C<MAXPATHLEN> constants.

=item pause

Suspend the execution of the current process until a signal is received.
Returns C<undef> on failure.

=item perror

Outputs to STDERR the specified message followed by "​: " and the current
error string. Better use C<warn()> and the C<$!> variable instead.
See L<perlfunc/warn> and L<perlvar/$ERRNO>.

=item pipe

Create an interprocess channel using file descriptors.
See also L<perlfunc/pipe>, which uses file handles.

  my ($read, $write) = POSIX​::pipe();
  POSIX​::write( $write, "hello", 5 );
  POSIX​::read( $read, $buf, 5 );

=item raise

Sends the specified signal to the current process.
See also L<perlfunc/kill> and the C<$$> in L<perlvar/$PID>.

=item read

Read from a file descriptor. The C<$buf> will automatically size.
Returns C<undef> on failure. See also L<perlfunc/sysread>.

  $fd = POSIX​::open( "foo", &POSIX​::O_RDONLY );
  $bytes = POSIX​::read( $fd, $buf, 3 );

=item remove

This calls C<unlink()> function (when passes a file name) or C<rmdir()>
(when passed a directory name). It does not remove non-empty directories.

=item rewind

Seeks to the beginning of the file, with a file handle.

=item setlocale

Modifies and queries program's locale. Consult L<perllocale>.

  use POSIX qw(setlocale LC_ALL LC_CTYPE);

  # set the traditional UNIX system locale behavior
  $loc = setlocale( LC_ALL, "C" );

  # query the current LC_CTYPE category.
  # (No second argument means 'query'.)
  $loc = setlocale( LC_CTYPE );

  # set the LC_CTYPE behaviour according to the locale
  # environment variables (the second argument C<"">).
  $loc = setlocale( LC_CTYPE, "" );

  # set the LC_COLLATE behaviour to Argentinian Spanish.
  $loc = setlocale( LC_COLLATE, "es_AR.ISO8859-1" );

=item setpgid

Set the process group identifier of the current process.
Returns C<undef> on failure.

=item setsid

Set the session identifier of the current process.

=item setuid

Calls C<setuid()>, which effect depends very much on your Operating
System. Better assign to C<< $< >> or use L<Unix​::SavedIDs>, which
both provide a more consistent behavior.

=item sigaction

Detailed signal management. This uses C<POSIX​::SigAction> objects
for the C<action> and C<oldaction> arguments (the oldaction can also
be just a hash reference). Returns C<undef> on failure. See also
C<POSIX​::SigRt>, below.

  sigaction(signal, action, oldaction = 0)

The C<signal> must be a number (like SIGHUP), not a string (like
"SIGHUP").

If you use the C<SA_SIGINFO> flag, the signal handler will in addition to
the first argument, the signal name, also receive a second argument, a
hash reference, inside which are the following keys with the following
semantics, as defined by POSIX/SUSv3​:

  signo the signal number
  errno the error number
  code if this is zero or less, the signal was sent by
  a user process and the uid and pid make sense,
  otherwise the signal was sent by the kernel

The following are also defined by POSIX/SUSv3, but unfortunately
not very widely implemented​:

  pid the process id generating the signal
  uid the uid of the process id generating the signal
  status exit value or signal for SIGCHLD
  band band event for SIGPOLL

A third argument is also passed to the handler, which contains a copy
of the raw binary contents of the siginfo structure​: if a system has
some non-POSIX fields, this third argument is where to unpack() them
from.

Note that not all siginfo values make sense simultaneously (some are
valid only for certain signals, for example), and not all values make
sense from Perl perspective, you should to consult your system's
C<sigaction> and possibly also C<siginfo> documentation.

=item sigpending

Examine signals that are blocked and pending. This uses C<POSIX​::SigSet>
objects for the C<sigset> argument. Returns C<undef> on failure.

  sigpending(sigset)

=item sigprocmask

Change and/or examine calling process's signal mask. This uses
C<POSIX​::SigSet> objects for the C<sigset> and C<oldsigset> arguments.
Returns C<undef> on failure.

  sigprocmask(how, sigset, oldsigset = 0)

Note that you can't reliably block or unblock a signal from its own signal
handler if you're using safe signals. Other signals can be blocked or
unblocked reliably.

=item sigsuspend

Install a signal mask and suspend process until signal arrives.
This uses C<POSIX​::SigSet> objects for the C<signal_mask> argument.
Returns C<undef> on failure.

  sigsuspend(signal_mask)

=item sinh

The hyperbolic sine of the numerical argument.

=item sleep

Like Perl's builtin C<sleep()>, but with B<one significant difference>​:
C<POSIX​::sleep()> returns the number of B<unslept seconds>, while the
C<CORE​::sleep()> returns the number of slept seconds.

=item strerror

Returns the error string for the specified errno.
Identical to the string form of the C<$!>, see L<perlvar/$ERRNO>.

=item strftime

Convert date and time information to string. Returns the string.

  strftime(fmt, sec, min, hour, mday, mon, year, wday = -1, yday = -1, isdst = -1)

The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero.
I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The
year (C<year>) is given in years since 1900. I.e., the year 1995 is 95; the
year 2001 is 101. Consult your system's C<strftime()> manpage for details
about these and the other arguments.

If you want your code to be portable, your format (C<fmt>) argument
should use only the conversion specifiers defined by the ANSI C
standard (C89, to play safe). These are C<aAbBcdHIjmMpSUwWxXyYZ%>.
But even then, the B<results> of some of the conversion specifiers are
non-portable. For example, the specifiers C<aAbBcpZ> change according
to the locale settings of the user, and both how to set locales (the
locale names) and what output to expect are non-standard.
The specifier C<c> changes according to the timezone settings of the
user and the timezone computation rules of the operating system.
The C<Z> specifier is notoriously unportable since the names of
timezones are non-standard. Sticking to the numeric specifiers is the
safest route.

The given arguments are made consistent as though by calling
C<mktime()> before calling your system's C<strftime()> function,
except that the C<isdst> value is not affected.

The string for Tuesday, December 12, 1995.

  $str = strftime( "%A, %B %d, %Y", 0, 0, 0, 12, 11, 95, 2 );
  $this_year = strftime "%Y", localtime;

=item strtod

String to double translation. Returns the parsed number and the number
of characters in the unparsed portion of the string.
When called in a scalar context, C<strtod()> returns the parsed number.

Truly POSIX-compliant systems set C<$!> (C<$ERRNO>) to indicate a
translation error, so clear C<$!> before calling strtod. However,
non-POSIX systems may not check for overflow, and therefore will never
set C<$!>. C<strtod()> should respect any POSIX I<setlocale()> settings.

To parse a string C<$str> as a floating point number use

  $! = 0;
  ($num, $n_unparsed) = strtod($str);

The second returned item and C<$!> can be used to check for valid input​:

  if ($str eq '' || $n_unparsed != 0 || $!) {
  die "Non-numeric input $str" . ($! ? "​: $!\n" : "\n");
  }

=item strtol

String to (long) integer translation. Returns the parsed number and
the number of characters in the unparsed portion of the string.
When called in a scalar context strtol returns the parsed number.

Truly POSIX-compliant systems set $! ($ERRNO) to indicate a translation
error, so clear $! before calling strtol. However, non-POSIX systems
may not check for overflow, and therefore will never set $!.

strtol should respect any POSIX I<setlocale()> settings.

To parse a string $str as a number in some base $base use

  $! = 0;
  ($num, $n_unparsed) = strtol($str, $base);

The base should be zero or between 2 and 36, inclusive. When the base
is zero or omitted strtol will use the string itself to determine the
base​: a leading "0x" or "0X" means hexadecimal; a leading "0" means
octal; any other leading characters mean decimal. Thus, "1234" is
parsed as a decimal number, "01234" as an octal number, and "0x1234"
as a hexadecimal number.

The second returned item and $! can be used to check for valid input​:

  if ($str eq '' || $n_unparsed != 0 || ! $!) {
  die "Non-numeric input $str" . ($! ? "​: $!\n" : "\n");
  }

=item strtoul

String to unsigned (long) integer translation. C<strtoul()> works like
C<strtol()> except that C<strtoul()> only parses unsigned integers. See
L</strtol> for details.

Note​: Some vendors supply C<strtod()> and C<strtol()> but not C<strtoul()>.
Other vendors that do supply C<strtoul()> parse "-1" as a valid value.

=item sysconf

Retrieves values of system configurable numerical variables.
Returns C<undef> on failure.

The following will get the schedule frequency of the Operating System.

  use POSIX qw(unistd_h);
  $clock_ticks = sysconf( _SC_CLK_TCK );

=item tanh

The hyperbolic tangent of the numerical argument.

=item tcdrain

Drain the output queue of some terminal character stream.
Returns C<undef> on failure.

=item tcflow

Controle the flow of a terminal character stream.
Returns C<undef> on failure.

=item tcflush

Flush the I/O buffers of some terminal character stream.
Returns C<undef> on failure.

=item tcgetpgrp

Return the process group identifier of the foreground process group of
the controlling terminal.

=item tcsendbreak

Send a break on a terminal character stream.
Returns C<undef> on failure.

=item tcsetpgrp

Set the process group identifier of the foreground process group of the
controlling terminal. Returns C<undef> on failure.

=item times

Returns elapsed real-time since some point in the past (such as system
startup), user and system times for this process, and user and system
times used by child processes. All times are returned in clock ticks,
which is returned by C<sysconf(_SC_CLK_TCK)>.

B<Warning​: Perl's builtin> C<times()> function returns four
values, measured in seconds~

  ($realtime, $user, $system, $cuser, $csystem) = POSIX​::times();

=item tmpnam

Returns a name for a temporary file. For security reasons this interface
should not be used; instead see L<File​::Temp>.

  $filename = tmpnam;

=item tolower

Lowercase a string via C<lc()>.

=item toupper

Uppercase a string via C<uc()>.

=item ttyname

The path to the terminal connected to the specified file-descriptor.

=item tzname

Retrieves the time conversion information from the C<tzname> variable.
You must call C<tzset> first.

  use POSIX qw(time_h);
  tzset();
  ($std, $dst) = tzname();

=item tzset

Set the current timezone based on the environment variable C<TZ>, to
be used by C<ctime()>, C<localtime()>, C<mktime()>, and C<strftime()>
functions.

=item uname

Get name of current operating system.

  ($sysname, $nodename, $release, $version, $machine) = POSIX​::uname();

The actual meanings of the various fields is not that well standardized;
do not expect any great portability. The C<$sysname> might be the name of
the operating system, the C<$nodename> might be the name of the host, the
C<$release> might be the (major) release number of the operating system,
the C<$version> might be the (minor) release number of the operating
system, and the C<$machine> might be a hardware identifier. Maybe.

=item utime

Like Perl's built-in, but with B<different parameter order>.

  POSIX​::utime($filename, $atime, $mtime);
  utime($atime, $ctime, @​filenames);

=item write

Write to a file descriptor. There will be no in-program buffering,
and the string is treated as bytes (no conversions, no understanding
of utf8, etc). Returned are the number of bytes passed to the OS and
C<undef> on failure. See also L<perlfunc/syswrite>.

It may very well be that the number of bytes written is less than the
amount requested, for instance when writing to a socket. In that case,
you have to reinitiate a write for the remainding, repeatedly until all
bytes have been sent.

Also, when no failure is flagged, that does not mean that the bytes have
actually arrived in the file or got sent over the socket​: the error is
only about the first step in the delivery process. The exit status of
C<close()> is a much better indicator for success.

  use POSIX qw(O_WRONLY);
  $fd = POSIX​::open( "foo", O_WRONLY );
  $buf = "hello";
  $bytes = POSIX​::write( $fd, $buf, 5 );

  # be aware that strings in Perl may be unicode​: write
  # treats strings as bytes.
  use Encode qw(encode);
  $buf = encode("hello", 'utf8');
  $bytes = POSIX​::write( $fd, $buf, length($buf) );

=back

=head1 CLASSES

=head2 POSIX​::SigAction

=over 8

=item new

Creates a new C<POSIX​::SigAction> object which corresponds to the C
C<struct sigaction>. This object will be destroyed automatically when
it is no longer needed. The first parameter is the handler, a sub
reference. The second parameter is a C<POSIX​::SigSet> object, it
defaults to the empty set. The third parameter contains the
C<sa_flags>, it defaults to 0.

  $sigset = POSIX​::SigSet->new(SIGINT, SIGQUIT);
  $sigaction = POSIX​::SigAction->new( \&handler, $sigset, &SA_NOCLDSTOP );

This C<POSIX​::SigAction> object is intended for use with the
C<POSIX​::sigaction()> function.

=back

=over 8

=item handler

=item mask

=item flags

  $sigset = $sigaction->mask;
  $sigaction->flags(SA_RESTART);

=item safe

Use "safe signals" flags. See L<perlipc> for general information on safe
(a.k.a. "deferred") signals. If you wish to handle a signal safely, use
this accessor to set the "safe" flag in the C<POSIX​::SigAction> object​:

  $sigaction->safe(1);

You may also examine the "safe" flag on the output action object which is
filled in when given as the third parameter to C<POSIX​::sigaction()>​:

  sigaction(SIGINT, $new_action, $old_action);
  if ($old_action->safe) {
  # previous SIGINT handler used safe signals
  }

=back

=head2 POSIX​::SigRt

=over 8

=item %SIGRT

A hash of the POSIX realtime signal handlers. It is an extension of
the standard %SIG, the C<$POSIX​::SIGRT{SIGRTMIN}> is roughly equivalent
to C<$SIG{SIGRTMIN}>, but the right POSIX moves (see below) are made with
the POSIX​::SigSet and POSIX​::sigaction instead of accessing the %SIG.

You can set the C<%POSIX​::SIGRT> elements to set the POSIX realtime
signal handlers, use C<delete()> and C<exists()> on the elements, and use
C<scalar> on the C<%POSIX​::SIGRT> to find out how many POSIX realtime
signals there are available (SIGRTMAX - SIGRTMIN + 1, the SIGRTMAX is
a valid POSIX realtime signal).

Setting the %SIGRT elements is equivalent to calling this​:

  sub new {
  my ($rtsig, $handler, $flags) = @​_;
  my $sigset = POSIX​::SigSet($rtsig);
  my $sigact = POSIX​::SigAction->new($handler, $sigset, $flags);
  sigaction($rtsig, $sigact);
  }

The flags default to zero, if you want something different you can
either use C<local> on $POSIX​::SigRt​::SIGACTION_FLAGS, or you can
derive from POSIX​::SigRt and define your own C<new()> (the tied hash
STORE method of the %SIGRT calls C<new($rtsig, $handler, $SIGACTION_FLAGS)>,
where the $rtsig ranges from zero to SIGRTMAX - SIGRTMIN + 1).

Just as with any signal, you can use sigaction($rtsig, undef, $oa) to
retrieve the installed signal handler (or, rather, the signal action).

B<NOTE​:> whether POSIX realtime signals really work in your system, or
whether Perl has been compiled so that it works with them, is outside
of this discussion.

=item SIGRTMIN

Return the minimum POSIX realtime signal number available, or C<undef>
if no POSIX realtime signals are available.

=item SIGRTMAX

Return the maximum POSIX realtime signal number available, or C<undef>
if no POSIX realtime signals are available.

=back

=head2 POSIX​::SigSet

=over 8

=item new

Create a new SigSet object. This object will be destroyed automatically
when it is no longer needed. Arguments may be supplied to initialize the
set.

  use POSIX qw(signal_h);
  $sigset = POSIX​::SigSet->new; # empty set
  $sigset = POSIX​::SigSet->new( SIGUSR1 );

=item addset

Add a signal to a SigSet object.
Returns C<undef> on failure.

  $sigset->addset( SIGUSR2 );

=item delset

Remove a signal from the SigSet object. Returns C<undef> on failure.

  $sigset->delset( SIGUSR2 );

=item emptyset

Initialize the SigSet object to be empty. Returns C<undef> on failure.

  $sigset->emptyset();

=item fillset

Initialize the SigSet object to include all signals.
Returns C<undef> on failure.

  $sigset->fillset();

=item ismember

Tests the SigSet object to see if it contains a specific signal.

  if( $sigset->ismember(SIGUSR1) ) {
  print "contains SIGUSR1\n";
  }

=back

=head2 POSIX​::Termios

=over 8

=item new

Create a new Termios object. This object will be destroyed automatically
when it is no longer needed. A Termios object corresponds to the termios
C struct. new() mallocs a new one, getattr() fills it from a file descriptor,
and setattr() sets a file descriptor's parameters to match Termios' contents.

  use POSIX qw(termios_h);
  $termios = POSIX​::Termios->new;

=item getattr

Get terminal control attributes.
Returns C<undef> on failure.

Obtain the attributes for stdin​:

  $termios->getattr( 0 ) # Recommended for clarity.
  $termios->getattr()

Obtain the attributes for stdout​:

  $termios->getattr( 1 )

=item getcc

Retrieve a value from the c_cc field of a termios object. The c_cc field is
an array so an index must be specified.

  $c_cc[1] = $termios->getcc(1);

=item getcflag

Retrieve the c_cflag field of a termios object.

  $c_cflag = $termios->getcflag;

=item getiflag

Retrieve the c_iflag field of a termios object.

  $c_iflag = $termios->getiflag;

=item getispeed

Retrieve the input baud rate.

  $ispeed = $termios->getispeed;

=item getlflag

Retrieve the c_lflag field of a termios object.

  $c_lflag = $termios->getlflag;

=item getoflag

Retrieve the c_oflag field of a termios object.

  $c_oflag = $termios->getoflag;

=item getospeed

Retrieve the output baud rate.

  $ospeed = $termios->getospeed;

=item setattr

Set terminal control attributes. Returns C<undef> on failure.

Set attributes immediately for stdout.

  $termios->setattr( 1, TCSANOW );

=item setcc

Set a value in the c_cc field of a termios object. The c_cc field is an
array so an index must be specified.

  $termios->setcc( VEOF, 1 );

=item setcflag

Set the c_cflag field of a termios object.

  $termios->setcflag( $c_cflag | CLOCAL );

=item setiflag

Set the c_iflag field of a termios object.

  $termios->setiflag( $c_iflag | BRKINT );

=item setispeed

Set the input baud rate.

  $termios->setispeed( B9600 );

Returns C<undef> on failure.

=item setlflag

Set the c_lflag field of a termios object.

  $termios->setlflag( $c_lflag | ECHO );

=item setoflag

Set the c_oflag field of a termios object.

  $termios->setoflag( $c_oflag | OPOST );

=item setospeed

Set the output baud rate. Returns C<undef> on failure.

  $termios->setospeed( B9600 );

=item Baud rate values

  B38400 B75 B200 B134 B300 B1800 B150 B0 B19200 B1200 B9600 B600 B4800
  B50 B2400 B110

=item Terminal interface values

  TCSADRAIN TCSANOW TCOON TCIOFLUSH TCOFLUSH TCION TCIFLUSH TCSAFLUSH
  TCIOFF TCOOFF

=item c_cc field values

  VEOF VEOL VERASE VINTR VKILL VQUIT VSUSP VSTART VSTOP VMIN VTIME NCCS

=item c_cflag field values

  CLOCAL CREAD CSIZE CS5 CS6 CS7 CS8 CSTOPB HUPCL PARENB PARODD

=item c_iflag field values

  BRKINT ICRNL IGNBRK IGNCR IGNPAR INLCR INPCK ISTRIP IXOFF IXON PARMRK

=item c_lflag field values

  ECHO ECHOE ECHOK ECHONL ICANON IEXTEN ISIG NOFLSH TOSTOP

=item c_oflag field values

  OPOST

=back

=head1 PATHNAME CONSTANTS

=over 8

=item Constants

  _PC_CHOWN_RESTRICTED _PC_LINK_MAX _PC_MAX_CANON _PC_MAX_INPUT
  _PC_NAME_MAX _PC_NO_TRUNC _PC_PATH_MAX _PC_PIPE_BUF _PC_VDISABLE

=back

=head1 POSIX CONSTANTS

=over 8

=item Constants

  _POSIX_ARG_MAX _POSIX_CHILD_MAX _POSIX_CHOWN_RESTRICTED
  _POSIX_JOB_CONTROL _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT
  _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_NO_TRUNC _POSIX_OPEN_MAX
  _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SAVED_IDS _POSIX_SSIZE_MAX
  _POSIX_STREAM_MAX _POSIX_TZNAME_MAX _POSIX_VDISABLE _POSIX_VERSION

=back

=head1 SYSTEM CONFIGURATION

=over 8

=item Constants

  _SC_ARG_MAX _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL _SC_NGROUPS_MAX
  _SC_OPEN_MAX _SC_PAGESIZE _SC_SAVED_IDS _SC_STREAM_MAX _SC_TZNAME_MAX
  _SC_VERSION

=back

=head1 ERRNO

=over 8

=item Constants

  E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT EAGAIN EALREADY EBADF
  EBUSY ECHILD ECONNABORTED ECONNREFUSED ECONNRESET EDEADLK EDESTADDRREQ
  EDOM EDQUOT EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH EINPROGRESS EINTR
  EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK EMSGSIZE ENAMETOOLONG
  ENETDOWN ENETRESET ENETUNREACH ENFILE ENOBUFS ENODEV ENOENT ENOEXEC
  ENOLCK ENOMEM ENOPROTOOPT ENOSPC ENOSYS ENOTBLK ENOTCONN ENOTDIR
  ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM EPFNOSUPPORT EPIPE
  EPROCLIM EPROTONOSUPPORT EPROTOTYPE ERANGE EREMOTE ERESTART EROFS
  ESHUTDOWN ESOCKTNOSUPPORT ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS
  ETXTBSY EUSERS EWOULDBLOCK EXDEV

=back

=head1 FCNTL

=over 8

=item Constants

  FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_OK F_RDLCK F_SETFD F_SETFL
  F_SETLK F_SETLKW F_UNLCK F_WRLCK O_ACCMODE O_APPEND O_CREAT O_EXCL
  O_NOCTTY O_NONBLOCK O_RDONLY O_RDWR O_TRUNC O_WRONLY

=back

=head1 FLOAT

=over 8

=item Constants

  DBL_DIG DBL_EPSILON DBL_MANT_DIG DBL_MAX DBL_MAX_10_EXP DBL_MAX_EXP
  DBL_MIN DBL_MIN_10_EXP DBL_MIN_EXP FLT_DIG FLT_EPSILON FLT_MANT_DIG
  FLT_MAX FLT_MAX_10_EXP FLT_MAX_EXP FLT_MIN FLT_MIN_10_EXP FLT_MIN_EXP
  FLT_RADIX FLT_ROUNDS LDBL_DIG LDBL_EPSILON LDBL_MANT_DIG LDBL_MAX
  LDBL_MAX_10_EXP LDBL_MAX_EXP LDBL_MIN LDBL_MIN_10_EXP LDBL_MIN_EXP

=back

=head1 LIMITS

=over 8

=item Constants

  ARG_MAX CHAR_BIT CHAR_MAX CHAR_MIN CHILD_MAX INT_MAX INT_MIN LINK_MAX
  LONG_MAX LONG_MIN MAX_CANON MAX_INPUT MB_LEN_MAX NAME_MAX NGROUPS_MAX
  OPEN_MAX PATH_MAX PIPE_BUF SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN
  SSIZE_MAX STREAM_MAX TZNAME_MAX UCHAR_MAX UINT_MAX ULONG_MAX USHRT_MAX

=back

=head1 LOCALE

=over 8

=item Constants

  LC_ALL LC_COLLATE LC_CTYPE LC_MONETARY LC_NUMERIC LC_TIME

=back

=head1 MATH

=over 8

=item Constants

  HUGE_VAL

=back

=head1 SIGNAL

=over 8

=item Constants

  SA_NOCLDSTOP SA_NOCLDWAIT SA_NODEFER SA_ONSTACK SA_RESETHAND SA_RESTART
  SA_SIGINFO SIGABRT SIGALRM SIGCHLD SIGCONT SIGFPE SIGHUP SIGILL SIGINT
  SIGKILL SIGPIPE SIGQUIT SIGSEGV SIGSTOP SIGTERM SIGTSTP SIGTTIN SIGTTOU
  SIGUSR1 SIGUSR2 SIG_BLOCK SIG_DFL SIG_ERR SIG_IGN SIG_SETMASK
  SIG_UNBLOCK

=back

=head1 STAT

=over 8

=item Constants

  S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU S_ISGID S_ISUID S_IWGRP
  S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR

=item Macros

  S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG

=back

=head1 STDLIB

=over 8

=item Constants

  EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX RAND_MAX

=back

=head1 STDIO

=over 8

=item Constants

  BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid L_tmpname TMP_MAX

=back

=head1 TIME

=over 8

=item Constants

  CLK_TCK CLOCKS_PER_SEC

=back

=head1 UNISTD

=over 8

=item Constants

  R_OK SEEK_CUR SEEK_END SEEK_SET STDIN_FILENO STDOUT_FILENO STDERR_FILENO
  W_OK X_OK

=back

=head1 WAIT

=over 8

=item Constants

WNOHANG WUNTRACED

=over 16

=item WNOHANG

Do not suspend the calling process until a child process
changes state but instead return immediately.

=item WUNTRACED

Catch stopped child processes.

=back

=item Macros

WIFEXITED WEXITSTATUS WIFSIGNALED WTERMSIG WIFSTOPPED WSTOPSIG

=over 16

=item WIFEXITED

WIFEXITED(${^CHILD_ERROR_NATIVE}) returns true if the child process
exited normally (C<exit()> or by falling off the end of C<main()>)

=item WEXITSTATUS

WEXITSTATUS(${^CHILD_ERROR_NATIVE}) returns the normal exit status of
the child process (only meaningful if WIFEXITED(${^CHILD_ERROR_NATIVE})
is true)

=item WIFSIGNALED

WIFSIGNALED(${^CHILD_ERROR_NATIVE}) returns true if the child process
terminated because of a signal

=item WTERMSIG

WTERMSIG(${^CHILD_ERROR_NATIVE}) returns the signal the child process
terminated for (only meaningful if WIFSIGNALED(${^CHILD_ERROR_NATIVE})
is true)

=item WIFSTOPPED

WIFSTOPPED(${^CHILD_ERROR_NATIVE}) returns true if the child process is
currently stopped (can happen only if you specified the WUNTRACED flag
to waitpid())

=item WSTOPSIG

WSTOPSIG(${^CHILD_ERROR_NATIVE}) returns the signal the child process
was stopped for (only meaningful if WIFSTOPPED(${^CHILD_ERROR_NATIVE})
is true)

=back

=back

@p5pRT
Copy link
Author

p5pRT commented Feb 5, 2013

From Mark@Overmeer.net

* Karl Williamson via RT (perlbug-followup@​perl.org) [130205 04​:22]​:

On Mon Feb 04 19​:10​:08 2013, jkeenan wrote​:

On Fri Feb 25 11​:34​:59 2011, stmpeters wrote​:

On Fri, Feb 25, 2011 at 1​:16 PM, Abigail <abigail@​abigail.be> wrote​:

On Fri, Feb 25, 2011 at 06​:03​:54PM +0100, Leon Timmermans wrote​:

On Fri, Feb 25, 2011 at 5​:52 PM, Abigail <abigail@​abigail.be>
wrote​:

Is there a reason the description uses vague terms like "digits
range",
instead of 0-9?

Because according to POSIX �The isdigit() function shall test
whether
c is a character of class digit in the program's current locale�.

But surely, something like "digits 0-9 (unless your locale defines
other
digits)" or "digits 0-9 (or what is defined by your locale)" is
clearer?
Many people don't use locales, or don't even know what they are -
does it
hurt to mention the general case first, and be explicite about the
exception
instead of using a phrase that will leave many puzzled (and many to
assume
something else than intended)?

Abigail

It certainly never hurts to clarify. I'll clear that up as well.

Steve Peters
steve@​fisharerojo.org

ext/POSIX/lib/POSIX.pod currently states with respect to 'isdigit'​:

#####
=item isdigit

This is identical to the C function, except that it can apply to
a single character or to a whole string. Note that locale settings
may affect what characters are considered C<isdigit> (unlikely, but
still possible). Does not work on Unicode characters code point 256
or higher. Consider using regular expressions and the C</[[​:digit​:]]/>
construct instead, or the C</\d/> construct.
#####

Is that sufficient to resolve the issues raised in this RT and enable us
to close this ticket?

Thank you very much.
Jim Keenan

I'm trying to understand the thread above, and don't. Why can't we
change the behavior as the OP requested?

There are a few problems with most of POSIX.pm Mainly, that it says
that it want to provide POSIX functionality for Perl, but
  . totally ignores the utf8 flag
  . does not provide the pure POSIX functions
  . re-exports some core functions with missing prototypes and
  sometimes different parameters.
  . is very incomplete (less than 10% of POSIX)

For instance in this documented case above, isdigit() is not "identical"
because it applies to a whole string. We do not have single-char
variables. Does this "3a" return true? Locales do influence isdigit(),
so not "unlikely".
Only the last remark is useful​: use /\d/

The bug reported here is a documentation bug. Implementation is​:

  Returns true when all bytes in the string pass isdigit().

IMO, the POSIX module should focus on helping people who know the POSIX
interface from other languages, to find their way in Perl. That's why
I wrote POSIX​::Overview (available on CPAN)
POSIX.xs could offer OS functions which are sometimes needed, but as
raw as possibile​: without "smart" interpretation. Smart behavior can
live on CPAN (see for instance the many wrappers around select and poll)

More about my ideas in the YAPC​::EU presentation
http​://mark.overmeer.net/pub/2012yapc/posix.odp
--
Regards,

  MarkOv


  Mark Overmeer MSc MARKOV Solutions
  Mark@​Overmeer.net solutions@​overmeer.net
http​://Mark.Overmeer.net http​://solutions.overmeer.net

@p5pRT
Copy link
Author

p5pRT commented Feb 5, 2013

From @jkeenan

On Tue Feb 05 00​:37​:05 2013, Mark@​Overmeer.net wrote​:

This description is really broken in many, many ways. I even gave
a presentation about this at YAPC​::EU.

I have a new version for the whole POSIX.pm manual-page attached. It has
been read by a few core members (like RJBS and David Golden) in older
versions, with positive remarks. But, as non-core and non-native speaker,
I hessitate posting it... Can you take that from me to include in core?

There are enough native and other English-speakers here that cleaning up
grammar in the POD is the least of our problems. I will take a look.

Thank you very much.
Jim Keenan

@p5pRT
Copy link
Author

p5pRT commented Mar 24, 2013

From fmeyers@mailfish.de

$ python -c 'print "".isdigit()'
False
$ php -r 'var_dump(ctype_digit(""));'
bool(false)
$ perl -MPOSIX -e 'print isdigit(""), "\n"'
1
$

WTF?

@p5pRT
Copy link
Author

p5pRT commented Mar 24, 2013

From [Unknown Contact. See original ticket]

$ python -c 'print "".isdigit()'
False
$ php -r 'var_dump(ctype_digit(""));'
bool(false)
$ perl -MPOSIX -e 'print isdigit(""), "\n"'
1
$

WTF?

@p5pRT
Copy link
Author

p5pRT commented Mar 25, 2013

From Mark@Overmeer.net

* Frank Meyers via RT (perlbug-comment@​perl.org) [130325 19​:26]​:

$ python -c 'print "".isdigit()'
False
$ php -r 'var_dump(ctype_digit(""));'
bool(false)
$ perl -MPOSIX -e 'print isdigit(""), "\n"'
1
$

WTF?

Yes, the documentation is flawed in many ways. New documentation
is waiting for acceptance.

The actual implementations is​: "true if all bytes are digits in
ASCII". Useless function, and true with zero characters.
--
Regards,

  MarkOv


  Mark Overmeer MSc MARKOV Solutions
  Mark@​Overmeer.net solutions@​overmeer.net
http​://Mark.Overmeer.net http​://solutions.overmeer.net

@p5pRT
Copy link
Author

p5pRT commented Mar 25, 2013

From @rjbs

* Mark Overmeer <mark@​overmeer.net> [2013-03-25T17​:11​:54]

Yes, the documentation is flawed in many ways. New documentation
is waiting for acceptance.

Mark, I know we talked about new documentation in the past, but I thought it
ended with something like, "I will submit something in the future," which
didn't happen. If there was something pending on this, I have clearly dropped
the ball, and I'm really sorry about that!

I'll look for an RT ticket, unless you know it offhand and can supply it. If
there isn't one, it would be good to get it on file to look at applying to
5.19.0.

Sorry again if this one's on me! :-/

--
rjbs

@p5pRT
Copy link
Author

p5pRT commented Mar 26, 2013

From Mark@Overmeer.net

* Ricardo Signes (perl.p5p@​rjbs.manxome.org) [130325 22​:47]​:

* Mark Overmeer <mark@​overmeer.net> [2013-03-25T17​:11​:54]

Yes, the documentation is flawed in many ways. New documentation
is waiting for acceptance.

Mark, I know we talked about new documentation in the past, but I thought it
ended with something like, "I will submit something in the future," which
didn't happen. If there was something pending on this, I have clearly
dropped the ball, and I'm really sorry about that!

Experiences in the past frighten me away from p5p to discuss the text.
Two months ago, I put the new manual-page in the hands of James Keenan,
which seems a good bet for getting it in. Meanwhile, POSIX​::1003 has
been ported to a few platforms.

Sorry again if this one's on me! :-/

It's not on you.
--
Thanks for responding,

  MarkOv


  Mark Overmeer MSc MARKOV Solutions
  Mark@​Overmeer.net solutions@​overmeer.net
http​://Mark.Overmeer.net http​://solutions.overmeer.net

@p5pRT
Copy link
Author

p5pRT commented Apr 4, 2013

From fmeyers@mailfish.de

On Mon Mar 25 14​:12​:38 2013, Mark@​Overmeer.net wrote​:

Yes, the documentation is flawed in many ways.

No, it's a bug in Perl. Unless, of course, you want to establish a new
software development paradigm​: "There are no software bugs, just bad
documentation". That would surely be helpful.

@p5pRT
Copy link
Author

p5pRT commented Apr 4, 2013

From [Unknown Contact. See original ticket]

On Mon Mar 25 14​:12​:38 2013, Mark@​Overmeer.net wrote​:

Yes, the documentation is flawed in many ways.

No, it's a bug in Perl. Unless, of course, you want to establish a new
software development paradigm​: "There are no software bugs, just bad
documentation". That would surely be helpful.

@p5pRT
Copy link
Author

p5pRT commented Apr 7, 2013

From @mauke

On 04.04.2013 10​:36, Frank Meyers via RT wrote​:

On Mon Mar 25 14​:12​:38 2013, Mark@​Overmeer.net wrote​:

Yes, the documentation is flawed in many ways.

No, it's a bug in Perl. Unless, of course, you want to establish a new
software development paradigm​: "There are no software bugs, just bad
documentation". That would surely be helpful.

If you think it's a bug, what should the correct behavior be?

--
Lukas Mai <plokinom@​gmail.com>

@p5pRT
Copy link
Author

p5pRT commented Apr 7, 2013

From Mark@Overmeer.net

* Frank Meyers via RT (perlbug-comment@​perl.org) [130407 08​:49]​:

On Mon Mar 25 14​:12​:38 2013, Mark@​Overmeer.net wrote​:

Yes, the documentation is flawed in many ways.

No, it's a bug in Perl. Unless, of course, you want to establish a new
software development paradigm​: "There are no software bugs, just bad
documentation". That would surely be helpful.

I agree​: also these documentation errors are "bugs in Perl". This does
not contradict the statement "the documentation is flawed in many
ways".

In this particular case, the code does not do what I pretends (provide the
POSIX interface) and the documentation does not describe the working of
the code. Both separate problems. The first I would classify as
'mis-feature', the second as 'bug'.

And I do not understand what your second sentence has to do with it, at
all. Do you feel people do not take documentation bugs seriously
enough? That's not what I see.
--
  MarkOv


  Mark Overmeer MSc MARKOV Solutions
  Mark@​Overmeer.net solutions@​overmeer.net
http​://Mark.Overmeer.net http​://solutions.overmeer.net

@p5pRT
Copy link
Author

p5pRT commented Mar 11, 2014

From @khwilliamson

I agree with the OP that this code does not do the right, expected thing. However, we decided to not fix this, but instead to deprecate this and similar functions. I also agree it's best to not change the behavior now of these old, essentially obsolete functions. They will be deprecated in 5.20, uses of them raising a deprecated warning, and are scheduled to be removed in 5.24.

--
Karl Williamson

@p5pRT
Copy link
Author

p5pRT commented Mar 11, 2014

@khwilliamson - Status changed from 'open' to 'stalled'

@p5pRT
Copy link
Author

p5pRT commented Feb 12, 2016

@khwilliamson - Status changed from 'stalled' to 'open'

@p5pRT
Copy link
Author

p5pRT commented Feb 12, 2016

From @khwilliamson

Done in 47ed9d9
--
Karl Williamson

@p5pRT
Copy link
Author

p5pRT commented Feb 12, 2016

@khwilliamson - Status changed from 'open' to 'pending release'

@p5pRT
Copy link
Author

p5pRT commented Feb 12, 2016

From @khwilliamson

On Thu Feb 11 19​:34​:48 2016, khw wrote​:

Done in 47ed9d9

I should have been clearer. The functions have been removed from perl, so any bugs associated with them are gone.
--
Karl Williamson

@p5pRT
Copy link
Author

p5pRT commented May 13, 2016

From @khwilliamson

Thank you for submitting this report. You have helped make Perl better.
 
With the release of Perl 5.24.0 on May 9, 2016, this and 149 other issues have been resolved.

Perl 5.24.0 may be downloaded via https://metacpan.org/release/RJBS/perl-5.24.0

@p5pRT
Copy link
Author

p5pRT commented May 13, 2016

@khwilliamson - Status changed from 'pending release' to 'resolved'

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Development

No branches or pull requests

1 participant