Why is this cast nessasary

[Neil]

Question

should this cast be necessary?
The Compiler is 8 Bits the ints are 16 bits.
The Code is for a ring buffer

It does not work without the cast in this compiler.
I have seen it work else where without it.
Which way is right (or should it matter at all?)

Thanks Neil



unsigned char t_in;
unsigned char t_out;

/*----------------------------------------------------------------*/
bit com_putchar (unsigned char c)
{

/*If the buffer is full, return an error value.*/
if ((TBUF_SIZE - (unsigned char)(t_in - t_out)) <= 2)
return (1);

/* More Code */
/* More Code */
/* More Code */
/* More Code */

return (0);
}

[Harald van Dijk]

CBFalconer wrote:

Thad Smith wrote:

Neil wrote:

Thad Smith wrote:
Neil wrote:

should this cast be necessary?
The Compiler is 8 Bits the ints are 16 bits.
The Code is for a ring buffer

unsigned char t_in;
unsigned char t_out;

/*---------------------------------------------------------*/
bit com_putchar (unsigned char c)
{
/*If the buffer is full, return an error value.*/
if ((TBUF_SIZE - (unsigned char)(t_in - t_out)) <= 2)
return (1);

Assuming a standard implementation where t_in and t_out are input
and output indexes, the logic is incorrect after a buffer wrap.

You are right it is still wrong. I hate it when it looks like it
works, but is wrong) But it can be done continuous, not 2 cases.
The original two examples I used Use the full width of the type.

Assuming my buffer was 256 bytes with 8bit indexes I get a modulus
256 for free.

Since it is smaller I must truncate myself.

if ((TBUF_SIZE - ((t_in - t_out)%TBUF_SIZ E) <= 2)

... snip ...

Better, but still not correct in C. The result a%b has the same
sign as a if the results is non-zero. You can get what you want
by making it positive:
(t_in - t_out + TBUF_SIZE) % TBUF_SIZE

Caution. There is a subtle difference in the modulo operation on
negative values between C90 and C99. I am not sure exactly what,
but I know it is there. Check the standard(s).

C90 allows division to round to -inf, which always results in a
nonnegative remainder. On such an implementation, the change Thad Smith
suggested would be unnecessary but harmless.