Different behavior (strtod) between musl and glibc

Different behavior (strtod) between musl and glibc

[Xiaowei Zhan]

[-- Attachment #1: Type: text/plain, Size: 652 bytes --]

Hello,

I notice that when pass a non-numeric char to strtod, musl will set errno
to non-zero, but glibc will set errno to zero.
I am curious why this difference exists, and whether it is necessary to
make strtod in musl behave similarly to glibc.

Here is the toy program:


#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {
  errno = 0;
  char input[] = "NA023";
  strtod(input, NULL);
  printf("errno = %d\n", errno);
  perror("strtod");

  return 0;
}

Output (musl):

bash-4.3# ./main
errno = 22
strtod: Invalid argument

Output (glibc, Ubuntu 16.04):
> ./main
errno = 0
strtod: Success



Best,
Xiaowei

[-- Attachment #2: Type: text/html, Size: 1199 bytes --]

Re: Different behavior (strtod) between musl and glibc

[Khem Raj]

On Tue, Jun 13, 2017 at 7:43 AM, Xiaowei Zhan <zhanxw@gmail.com> wrote:
> Hello,
>
> I notice that when pass a non-numeric char to strtod, musl will set errno to
> non-zero, but glibc will set errno to zero.

Musl is detecting that it can not perform the conversion due to invalid input.
It seems that musl is conforming to posix definition here
http://pubs.opengroup.org/onlinepubs/009695399/functions/strtod.html

> I am curious why this difference exists, and whether it is necessary to make
> strtod in musl behave similarly to glibc.
>
> Here is the toy program:
>
>
> #include <errno.h>
> #include <stdio.h>
> #include <stdlib.h>
>
> int main(int argc, char** argv) {
>   errno = 0;
>   char input[] = "NA023";
>   strtod(input, NULL);
>   printf("errno = %d\n", errno);
>   perror("strtod");
>
>   return 0;
> }
>
> Output (musl):
>
> bash-4.3# ./main
> errno = 22
> strtod: Invalid argument
>
> Output (glibc, Ubuntu 16.04):
>> ./main
> errno = 0
> strtod: Success
>
>
>
> Best,
> Xiaowei
>
>

Re: Different behavior (strtod) between musl and glibc

[Florian Weimer]

Xiaowei Zhan <zhanxw@gmail.com> writes:

> I notice that when pass a non-numeric char to strtod, musl will set
> errno to non-zero, but glibc will set errno to zero.  I am curious why
> this difference exists, and whether it is necessary to make strtod in
> musl behave similarly to glibc.

I think glibc leaves errno at zero; it does not set it.  For input which
cannot be converted, this seems to be the behavior mandated by C11.
POSIX describes the EINVAL value as an extension to the C standard.
glibc does not appear to implement this extension.

So both behaviors are correct.

Florian

Re: Different behavior (strtod) between musl and glibc

[Rich Felker]

On Wed, Jun 14, 2017 at 03:44:34PM +0200, Florian Weimer wrote:
> Xiaowei Zhan <zhanxw@gmail.com> writes:
> 
> > I notice that when pass a non-numeric char to strtod, musl will set
> > errno to non-zero, but glibc will set errno to zero.  I am curious why
> > this difference exists, and whether it is necessary to make strtod in
> > musl behave similarly to glibc.
> 
> I think glibc leaves errno at zero; it does not set it.  For input which
> cannot be converted, this seems to be the behavior mandated by C11.
> POSIX describes the EINVAL value as an extension to the C standard.
> glibc does not appear to implement this extension.
> 
> So both behaviors are correct.

CX is a normative requirement for POSIX conformance; it indicates a
requirement beyond (but not conflicting with) the C requirements for
an interface defined by C. However, it's a "may fail", not a "shall
fail", so the error is optional, and thus you're right that both musl
and glibc are correct on the matter.

I think you're also correct that glibc leaves errno alone in this
case. Setting it to 0 would be non-conforming. The implementation is
never permitted to set errno to 0 except at initial program entry.

Rich