K&R 2 exercise 2-3

[Herrcho]

Hi~ i've studied C for a few months myself,

and i'd appreciate it if anyone could improve my coding or correct it.

the following is my solution to the K&R exercise 2-3

"Write the function htoi(s), which converts a string of hexademical digits
(including an optional 0x or 0X) into its equivalent integer value.
The allowable digits are 0 through 9, a through f, and A throught F."
//*************** *************** *************** *************** **************

#include <stdio.h>

int isxdigit2(int c)
{
if ( (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') || (c >= '0' && c <= '9') )
return 1;
else
return 0;
}

int tolower2(int c)
{
if (c >= 'A' && c <= 'Z')
return c+32;
else
return c;
}

int power2(int base, int num)
{
int sum;
for (sum = 1; num >0 ; num --)
sum *= base;
return sum;
}

int char_to_num(int c)
{
if (c >= '0' && c <= '9')
{
return c - 48;
}
else
{
return 10 + (tolower2(c) - 'a');
}
}

int htoi(char *c)
{
int i, k, prefix = 0;
size_t sum = 0;

if (c[0] == '0' && tolower2(c[1]) == 'x')
prefix = 1;

for (i = (prefix == 1)? 2:0 ; c[i] ;i++ )
{
if (!isxdigit2(c[i]) )
{
printf("Wrong hexa number\n");
return 0;
}
c[i] = char_to_num(c[i]);
}

for (k = (prefix == 1)? 2 : 0 ; k <= i-1 ; ++k )
{
sum += c[k] * power2(16, i-1-k);
}

return sum;
}

int main()
{
char c[] = "0xAB";
printf("%u", htoi(c));

return 0;
}

//*************** *************** *************** *************** ******

when i change char c[] to char *c in main(),
it shows error, why ??

Thanks..

[RoRsOaMrPiEo]

On Fri, 20 Feb 2004 14:12:54 GMT, RoRsOaMrPiEo <[e-mail]> wrote:

On Fri, 20 Feb 2004 12:32:52 GMT, rl*@hoekstra-uitgeverij.nl (Richard
Bos) wrote:

> #include <limits.h>
> #include <stdlib.h>
>
> unsigned int htoi(char *txt)
> {
> unsigned long tmp=strtoul(txt , 0, 16);
> if (tmp>UINT_MAX) return UINT_MAX;
> return tmp;
> }

but here htoi(8eeeeeeeee eeeeeeeeeeeeee) ==-1

this seems htoi(8eeeeeeeee eeeeeeeeeeeeee) == INT_MAX

Imprimis, htoi(8eeeeeeeee eeeeeeeeee) is a syntax error.
Secundis, htoi("8eeeeeeee eeeeeeeeeeee") invokes undefined behaviour for
your implementation (and thus has a license to return anything,
including garbage, and even crash the machine), and returns UINT_MAX
(not INT_MAX) for my implementation, without being undefined.

so your is htou and not htoi

is there any pc where
(int) (unsigned) INT_MAX != INT_MAX (this would be true for K&R?)
or where
(int) (unsigned) INT_MIN != INT_MIN

or where if zE{INT_MIN...IN T_MAX}
then (int) (unsigned) z != z

[CBFalconer]

Martin wrote:

"Richard Bos" wrote:

Why do work which the library will do for you?

#include <limits.h>
#include <stdlib.h>

unsigned int htoi(char *txt)
{
unsigned long tmp=strtoul(txt , 0, 16);
if (tmp>UINT_MAX) return UINT_MAX;
return tmp;
}

Shorter, sweeter, doesn't waste value space on
negative numbers which you don't parse anyway,
doesn't invoke undefined behaviour on overflow,
and is portable no matter what your character set it.
Feel free.

Isn't there a possibility that UINT_MAX == ULONG_MAX?

So? As before, this means input >= UINT_MAX returns UINT_MAX.

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[Martin]

"CBFalconer " wrote:

So? As before, this means input >= UINT_MAX returns UINT_MAX.

If UINT_MAX == ULONG_MAX then tmp>UINT_MAX can never be true and UINT_MAX
will never be returned by your function, even when overflow occurs.

Martin
http://martinobrien.co.uk/

[CBFalconer]

Martin wrote:

"CBFalconer " wrote:

So? As before, this means input >= UINT_MAX returns UINT_MAX.

If UINT_MAX == ULONG_MAX then tmp>UINT_MAX can never be true and
UINT_MAX will never be returned by your function, even when
overflow occurs.

You snipped the code in question and the attributions (it wasn't
my function), but strtoul will return ULONG_MAX for an overflow,
IIRC, which in this case is == UINT_MAX, and is returned. The
code is portable.

I repeat - so?

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[nrk]

Martin wrote:

"CBFalconer " wrote:

So? As before, this means input >= UINT_MAX returns UINT_MAX.
If UINT_MAX == ULONG_MAX then tmp>UINT_MAX can never be true and UINT_MAX
will never be returned by your function, even when overflow occurs.

That would automatically be taken care of by strtoul. In case of overflow,
strtoul will return ULONG_MAX (which also happens to UINT_MAX in the
scenario you describe) and set errno to ERANGE. Richard's code takes the
extra care for situations where ULONG_MAX > UINT_MAX.

-nrk.
Martin
http://martinobrien.co.uk/

--
Remove devnull for email

[Richard Bos]

RoRsOaMrPiEo <[e-mail]> wrote:

On Fri, 20 Feb 2004 12:32:52 GMT, rl*@hoekstra-uitgeverij.nl (Richard
Bos) wrote:

> #include <limits.h>
> #include <stdlib.h>
>
> unsigned int htoi(char *txt)
> {
> unsigned long tmp=strtoul(txt , 0, 16);
> if (tmp>UINT_MAX) return UINT_MAX;
> return tmp;
> }

but here htoi(8eeeeeeeee eeeeeeeeeeeeee) ==-1

this seems htoi(8eeeeeeeee eeeeeeeeeeeeee) == INT_MAX

Imprimis, htoi(8eeeeeeeee eeeeeeeeee) is a syntax error.
Secundis, htoi("8eeeeeeee eeeeeeeeeeee") invokes undefined behaviour for
your implementation (and thus has a license to return anything,
including garbage, and even crash the machine), and returns UINT_MAX
(not INT_MAX) for my implementation, without being undefined.

so your is htou and not htoi

If you wish. Yours doesn't read signed hex numbers, either, though, so I
fail to see the advantage of having a signed format. If you wish, you
can remove all unsigneds, use strtol() instead of strtoul(), and INT_MAX
instead of UINT_MAX, and you'll have a version which can read only half
of the original numbers but returns a signed int.

In fact, if I were you, I'd use strtoul() directly. Much simpler.

and some
slight slowness, while not ideal, is at least to be preferred above a
license to crash your machine at any inconvenient moment.

crash where in code?

Wherever it invokes undefined behaviour. I haven't checked it in detail,
but people upthread said that it does. They may, of course, have been
mistaken.

Richard

[Richard Bos]

RoRsOaMrPiEo <[e-mail]> wrote:

is there any pc where
(int) (unsigned) INT_MAX != INT_MAX (this would be true for K&R?)
No. INT_MAX must be representable in unsigned int (6.2.5#9 in C99).
(int) (unsigned) INT_MIN != INT_MIN

or where if zE{INT_MIN...IN T_MAX}
then (int) (unsigned) z != z

Whether such a machine actually exists I don't know, but AFAICT it's
certainly allowed. Conversion of out-of-range values to unsigned format
is defined to be done modulo (<type>_MAX+1) , but conversion of out-of-
range values to signed format is not well-defined.

Richard