Converting large strings to numbers

[rouble]

Without using errno, is there a portable way to detect if a string
number is not within the range 0 to 4294967295.

Currently I am using strtoul. I can check the string for "-" as the
first character before calling strtoul, so I can figure out if the
value is less than 0.

My issue arises when the number is greater than 4294967295 on platforms
where ULONG_MAX is 4294967295; in this case strtoul will return
ULONG_MAX and set errno to ERANGE. However, some platforms I work on do
not support errno. So there is no way for me to know that the value was
greater than 4294967295.

Is there another way to do this ?

TIA,
rouble

[Walter Roberson]

In article <11*********************@l41g2000cwc.googlegroups. com>,
<ro****@gmail.com> wrote:

Without using errno, is there a portable way to detect if a string
number is not within the range 0 to 4294967295. Currently I am using strtoul. I can check the string for "-" as the
first character before calling strtoul, so I can figure out if the
value is less than 0. My issue arises when the number is greater than 4294967295 on platforms
where ULONG_MAX is 4294967295; in this case strtoul will return
ULONG_MAX and set errno to ERANGE. However, some platforms I work on do
not support errno. So there is no way for me to know that the value was
greater than 4294967295.

Stringify ULONG_MAX and do a strcmp() of the source number against
that value. If the source number is all digits then strcmp() of the
decimal representations is equivilent to a numeric comparison.
Even in odd character sets, because of the C standard's specifi
rules about the representation of the digits.
--
"Mathematics? I speak it like a native." -- Spike Milligan

[David Resnick]

[e-mail] wrote:

Without using errno, is there a portable way to detect if a string
number is not within the range 0 to 4294967295.

Currently I am using strtoul. I can check the string for "-" as the
first character before calling strtoul, so I can figure out if the
value is less than 0.

My issue arises when the number is greater than 4294967295 on platforms where ULONG_MAX is 4294967295; in this case strtoul will return
ULONG_MAX and set errno to ERANGE. However, some platforms I work on do not support errno. So there is no way for me to know that the value was greater than 4294967295.

Is there another way to do this ?

TIA,
rouble

Well, if strtoul returns ULONG_MAX, you could compare the string being
converted to "4294967295". If it is NOT the same, you have overflowed.

-David

[Eric Sosman]

ro****@gmail.com wrote:

Without using errno, is there a portable way to detect if a string
number is not within the range 0 to 4294967295.

Currently I am using strtoul. I can check the string for "-" as the
first character before calling strtoul, so I can figure out if the
value is less than 0.

My issue arises when the number is greater than 4294967295 on platforms
where ULONG_MAX is 4294967295; in this case strtoul will return
ULONG_MAX and set errno to ERANGE. However, some platforms I work on do
not support errno. So there is no way for me to know that the value was
greater than 4294967295.

Is there another way to do this ?

A platform that doesn't "support errno" is a non-conforming
implementation of C, so you're in uncertain territory at best.
One possibility, of course, is to write your own replacement; if
the implementation is already known to be non-conforming and
hence suspect, this may be the safest course.

If you can at least trust strtoul() to return ULONG_MAX for
an out-of-range number, you could conclude that any other value
is legitimate. When ULONG_MAX shows up, you could inspect the
string itself to see whether it was in fact "4294967295" (or
"037777777777" or "0xFFFFFFFF" or ... it'll be a little more
trouble than a mere strcmp(), and the tests will depend on the
value of strtoul()'s third argument). Or (if circumstances
permit) you could just treat ULONG_MAX as an error, sacrificing
the possibility of actually handling that single large number.

--
Er*********@sun.com

[CBFalconer]

ro****@gmail.com wrote:

Without using errno, is there a portable way to detect if a string
number is not within the range 0 to 4294967295.

Currently I am using strtoul. I can check the string for "-" as the
first character before calling strtoul, so I can figure out if the
value is less than 0.

My issue arises when the number is greater than 4294967295 on
platforms where ULONG_MAX is 4294967295; in this case strtoul will
return ULONG_MAX and set errno to ERANGE. However, some platforms I
work on do not support errno. So there is no way for me to know that
the value was greater than 4294967295.

Is there another way to do this ?

You obviously have a non-conformant implementation. However, you
can do the fundamental conversions yourself. For input from a
stream see txtio.zip, and if you need string input make the
appropriate changes yourself. See:

<http://cbfalconer.home.att.net/download/>

--
"If you want to post a followup via groups.google.com, don't use
the broken "Reply" link at the bottom of the article. Click on
"show options" at the top of the article, then click on the
"Reply" at the bottom of the article headers." - Keith Thompson

[pete]

ro****@gmail.com wrote:

Without using errno, is there a portable way to detect if a string
number is not within the range 0 to 4294967295.

Currently I am using strtoul. I can check the string for "-" as the
first character before calling strtoul, so I can figure out if the
value is less than 0.

My issue arises when the number
is greater than 4294967295 on platforms
where ULONG_MAX is 4294967295; in this case strtoul will return
ULONG_MAX and set errno to ERANGE.
However, some platforms I work on do
not support errno.
So there is no way for me to know that the value was
greater than 4294967295.

Is there another way to do this ?

Use strcmp instead of strtoul.

/* BEGIN new.c */

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

#define str(s) # s
#define xstr(s) str(s)

#define RANGE_1 "4294967295"

int all_digits(char *s);

int main(void)
{
char *range = RANGE_1;

/* char *range = xstr(ULONG_MAX); */
/* char *range = RANGE_1 */

char *strings[] = {
"0","","-1","4294967296","4294967296000",
"4294967294","4294967295", NULL
};
char **s = strings;

printf("\nRange is %s.\n\n", range);
while (*s != NULL) {
if (**s != '\0' && all_digits(*s)
&& 0 >= strcmp(*s, range)) {
printf("%s is in range.\n", *s);
} else {
printf("%s is out of range.\n", *s);
}
++s;
}
return 0;
}

int all_digits(char *s)
{
while(isdigit(*s)) {
++s;
}
return *s == '\0';
}

/* END new.c */

--
pete

[pete]

pete wrote:

/* char *range = xstr(ULONG_MAX); */

That one doesn't work right.

It's "0xffffffffUL" on my machine.

--
pete

[Lawrence Kirby]

On Thu, 28 Apr 2005 16:42:00 +0000, Walter Roberson wrote:

In article <11*********************@l41g2000cwc.googlegroups. com>,
<ro****@gmail.com> wrote:

Without using errno, is there a portable way to detect if a string
number is not within the range 0 to 4294967295.

Currently I am using strtoul. I can check the string for "-" as the
first character before calling strtoul, so I can figure out if the
value is less than 0.

My issue arises when the number is greater than 4294967295 on platforms
where ULONG_MAX is 4294967295; in this case strtoul will return
ULONG_MAX and set errno to ERANGE. However, some platforms I work on do
not support errno. So there is no way for me to know that the value was
greater than 4294967295.

Stringify ULONG_MAX

Ok as long as you mean convert the value to a string with, say, sprintf()
and not by preprocessor tricks on the ULONG_MAX macro itself.
and do a strcmp() of the source number against
that value. If the source number is all digits then strcmp() of the
decimal representations is equivilent to a numeric comparison.
Unless there are leading zeros.
Even in
odd character sets, because of the C standard's specifi rules about the
representation of the digits.

It would still work even if the digits weren't contiguous in the character
set.

Lawrence

[Keith Thompson]

"David Resnick" <ln********@gmail.com> writes:

[e-mail] wrote:

Without using errno, is there a portable way to detect if a string
number is not within the range 0 to 4294967295.

Currently I am using strtoul. I can check the string for "-" as the
first character before calling strtoul, so I can figure out if the
value is less than 0.

My issue arises when the number is greater than 4294967295 on
platforms where ULONG_MAX is 4294967295; in this case strtoul will
return ULONG_MAX and set errno to ERANGE. However, some platforms I
work on do not support errno. So there is no way for me to know
that the value was greater than 4294967295.

Is there another way to do this ?

Well, if strtoul returns ULONG_MAX, you could compare the string being
converted to "4294967295". If it is NOT the same, you have overflowed.

Unless the string is "[phone]", or "04294967295", or
"+0004294967295". That's if you use a "base" argument of 10; if you
set "base" to 0, a leading '0' implies octal, and you also have to
worry about "037777777777", "00037777777777", "0xffffffff",
"0X000FfFfFfFf", and so forth.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.