[mfonz85]

ok, per la moltiplicazione ho avuto l'idea...mi sembra banale, ma credo funzioni...

Se ho un numero massimo, mettiamo caso 32767 numero signed su 16 bit, e devo vedere se 2 numeri moltiplicati tra loro vanno in overflow: trovo il minimo e il massimo tra i 2 numeri e poi divido il massimo numero rappresentabile su 16 bit signed con il massimo fattore della moltiplicazione: se il risultato di questa operazione è minore del secondo fattore, siamo in overflow...altrimenti no

150*160 = 24000 (ok, minore di 32767)
32767 / 160 = 204
204 > 150 (no overflow, perchè il secondo fattore sta dentro il 204)

150*260 = 39000 (overflow)
32767 / 260 = 126
126 < 150 (overflow, il secondo fattore sta fuori dal 126)

#define __HALF_MAX_SIGNED(type) ((type)1 << (sizeof(type)*8-2))
#define __MAX_SIGNED(type) (__HALF_MAX_SIGNED(type) - 1 + __HALF_MAX_SIGNED(type))
#define __MIN_SIGNED(type) (-1 - __MAX_SIGNED(type))

#define __MIN(type) ((type)-1 < 1?__MIN_SIGNED(type):(type)0)
#define __MAX(type) ((type)~__MIN(type))

#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a,b) ((a) > (b) ? (a):(b)) 

int isMultOverflow(int32_t a, int32_t b, int8_t bit) {
    int massimo = max(a,b);
    int minimo = min(a,b);
    if( bit == 1 ) return( minimo > (__MAX(int8_t) / massimo) );
    else if( bit == 2 ) return( minimo > (__MAX(int16_t) / massimo) );
    else if( bit == 4 ) return( minimo > (__MAX(int32_t) / massimo) );
    else return 1;
}

Che programmazione burina, mi sento uno "zappatore del C"

L'ho scritta al volo, così al brucio, ora ci faccio un pò di debugging, non si sa mai...