[C] GCC Warning inspiegabile

[sheijtan]

il seguente programmino compilato con il comando:
~$ gcc -Wconversion bool.c -o bool.x
bool.c: In function ‘main’:
bool.c:23: warning: passing argument 1 of ‘isTrue’ with different width due to prototype

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#define BSIZE 10

const char* isTrue(bool test) {
return test?"True":"False";
}

int main(void) {
bool yes = 1;
bool no = 0;
bool * iseven = (bool *) malloc (BSIZE*sizeof(bool));
size_t i;
for (i=0; i<BSIZE; ++i) {
if (i%2==0) {
iseven[i]=yes;
} else {
iseven[i]=no;
}
}
for (i=0; i<BSIZE; ++i) {
printf("%d is even: %s\n",i, isTrue(iseven[i]));
}
free(iseven);
return 0;
}


Qualcuno ha idea dove sia il problema e come eliminare il Warning?
(Non mi dite di togliere la flag -Wconversion perché non vale...)

EDIT: ma porc#@! alla fine l' unica soluzione possibile è *NON* usare -Wconversion :doh:
EDIT_2: -Wconversion potrà essere usata con gcc --version >= 4.3 (in sviluppo)

[vizzz]

trovato googlando:
Don't use -Wconversion. It is useless with ISO-C code. It is only
usefull if you want to add prototypes to K&R-C code, and want to know
about cases where `foo (char)' is actually `foo (int)' in absense of
prototypes.

[sheijtan]

trovato googlando:
Don't use -Wconversion. It is useless with ISO-C code. It is only
usefull if you want to add prototypes to K&R-C code, and want to know
about cases where `foo (char)' is actually `foo (int)' in absense of
prototypes.

D'accordo. Però questo non spiega perché gcc si lamenti quando passo una variabile dichiarata bool alla funzione isTrue() che si aspetta proprio un bool :boh: . Voglio dire: -Wconversion dovrebbe avvertire se ci sono delle conversioni implicite, ma nel mio esempio non ce ne dovrebbero essere, o no?!

[71104]

a me pare di si... bool ha la stessa dimensione di char, quindi...

[sheijtan]

a me pare di si... bool ha la stessa dimensione di char, quindi...

Quindi cosa? lascia perdere la risposta di vizzz. Nel mio es. che è anche il mio problema io passo un bool ad una funzione che si aspetta un bool e gcc dice che avviene una conversione. Perché?

[sheijtan]

nessuno ne sa niente? Sto scrivendo codice numerico e quella flag del compilatore mi serve: :help:

[CoreDump]

Se ricordo bene ( ho avuto tale problema anta anni fà :old: :D ) con il flag
-Wconversion il compilatore si aspetta "old like" stile per le funzioni, ovvero
invece di :

const char* isTrue(bool test) {
return test?"True":"False";
}

dovresti scrivere :

const char* isTrue(test)
bool test;
{
return test?"True":"False";
}

cosi dovrebbe compilare, nell'altro caso non compila perchè suppongo che il
compilatore non trovi il prototipo di bool ( anche con char è uguale ) è faccia
automaticamente la promozione a int e di li il warning per il tipo diverso di dati ( bool <-> int )
prova e fammi sapere :)

[71104]

Quindi cosa? lascia perdere la risposta di vizzz. Nel mio es. che è anche il mio problema io passo un bool ad una funzione che si aspetta un bool e gcc dice che avviene una conversione. Perché? dal momento che lo stack è allineato ai 4 byte suppongo che sia quello il motivo percui il bool (che occupa un solo byte) deve essere espanso. l'unico significato che riesco ad attribuire a quel warning è che il programmatore non ha modo di controllare se il bool debba essere sign-extended o meno. comunque non per dire ma io francamente me ne sbatterei... :p

[sheijtan]

@CoreDump

Ho provato ma non funziona:
~$ gcc -Wconversion bool.c -o bool.x
bool.c: In function ‘isTrue’:
bool.c:7: error: ‘test’ redeclared as different kind of symbol
bool.c:6: error: previous definition of ‘test’ was here

credo che la dichiarazione old-style sia troppo :old: ...

@71104
però, seguendo il tuo ragionamento, anche un char andrebbe incontro a problemi analoghi, o no? :confused:

cmq, grazie ragazzi per i vari suggerimenti, alla fine si impara sempre qualcosa .

[sheijtan]

@71104
la tua osservazione mi suggerito di provare a definire il tipo bool in due modi:
typedef unsigned int bool
typedef unsigned short int bool
ebbene, con la prima definizione compilo senza warning. Mentre con la seconda gcc continua a lamentarsi. Credo che la strada da te suggerita per capire quel che succede durante questa compilazione sia quella giusta, purtroppo le mie conoscenze sull' effetiva implementazione dello stack sono praticamente nulle. Qualche url/book dove documentarmi su questi argomenti?

[CoreDump]

@CoreDump

Ho provato ma non funziona:
~$ gcc -Wconversion bool.c -o bool.x
bool.c: In function ‘isTrue’:
bool.c:7: error: ‘test’ redeclared as different kind of symbol
bool.c:6: error: previous definition of ‘test’ was here

credo che la dichiarazione old-style sia troppo :old: ...

@71104
però, seguendo il tuo ragionamento, anche un char andrebbe incontro a problemi analoghi, o no? :confused:

cmq, grazie ragazzi per i vari suggerimenti, alla fine si impara sempre qualcosa .

Umh, io ho provato con il Dev-C++ effettivamente e cosi funziona, quando ho due minuti provo anche con il gcc che al momento
non mi ritrovo sotto mano :)

Edit: Ho provato con il gcc 3.3.5 su una Unix/Solaris ( la prima che mi trovavo sottomano :D ) e con l'old-like style compila senza
problemi :confused: per curiosità, ma su che sistema sta cercando di compilare ? :)

[CoreDump]

Umh, io ho provato con il Dev-C++ effettivamente e cosi funziona, quando ho due minuti provo anche con il gcc che al momento
non mi ritrovo sotto mano :)

Edit: Ho provato con il gcc 3.3.5 su una Unix/Solaris ( la prima che mi trovavo sottomano :D ) e con l'old-like style compila senza
problemi :confused: per curiosità, ma su che sistema sta cercando di compilare ? :)

Mi quoto e allego tracciato del test :D

[trallallero]

é la prima volta che vedo questo errore e se ti interessa puoi risolverlo cosí:

#undef bool
typedef int bool;

la cosa strana é che se fai
printf("bool <%i>\n", sizeof(bool));
l'output é ... 1 :wtf:

EDIT: ho provato anche la ol-style (che :Puke: aborro) e compila senza problemi, su Linux.

[sheijtan]

Mi quoto e allego tracciato del test :D

c' hai ragione così funziona! Avevo sbagliato io a digitare il tuo esempio:
invece di

char*
isTrue (test)
bool test;
{
/*body*/
}

avevo digitato:

char*
isTrue (test)
{
bool test;
/*body*/
}
:muro:
Grazie mille! Ehm, un' ultima cosa: perché dichiarando la funzione nel modo da te suggerito funziona? Il codice prodotto nei due casi dal compilatore sarà diverso?

[sheijtan]

é la prima volta che vedo questo errore e se ti interessa puoi risolverlo cosí:

#undef bool
typedef int bool;

la cosa strana é che se fai
printf("bool <%i>\n", sizeof(bool));
l'output é ... 1 :wtf:

EDIT: ho provato anche la ol-style (che :Puke: aborro) e compila senza problemi, su Linux.

Grazie anche a te dei suggerimenti e dell' interessamento!
sì con la dichiarazione old-style tutto va liscio, però vorrei evitare di usarla. Probabilmente userò una mia definizione di bool:
stavo pensando a un
typedef unsigned int bool; evitando di includere le definizioni di stdbool.h . In questo caso, c'è qualche altro accorgimento da usare?

[CoreDump]

c' hai ragione così funziona! Avevo sbagliato io a digitare il tuo esempio:
invece di

char*
isTrue (test)
bool test;
{
/*body*/
}

avevo digitato:

char*
isTrue (test)
{
bool test;
/*body*/
}
:muro:
Grazie mille! Ehm, un' ultima cosa: perché dichiarando la funzione nel modo da te suggerito funziona? Il codice prodotto nei due casi dal compilatore sarà diverso?

Infatti mi sembrava strano :D, comunque suppongo e sottolineo suppongo che con il flag -Wconversion il compilatore nel primo esempio
non riesca a risalire al tipo di dato ( bool ) e per default promuova il tipo di dato da bool a int ( che è quello di default ) e da
li il "warning: passing argument 1 of ‘isTrue’ with different width due to prototype" nel secondo esempio invece con la
funzione dichiarata in old-like style il compilatore riesce a risalire al tipo di dato e quindi non genera l'errore, questo spiega anche perchè usando una
nuova definizione come hai proposto tu la cosa funzioni :)

[trallallero]

Probabilmente userò una mia definizione di bool:
stavo pensando a un
typedef unsigned int bool; evitando di includere le definizioni di stdbool.h . In questo caso, c'è qualche altro accorgimento da usare?

sicuramente questo: ;)

#define true 1
#define false 0

[CoreDump]

Grazie anche a te dei suggerimenti e dell' interessamento!
sì con la dichiarazione old-style tutto va liscio, però vorrei evitare di usarla. Probabilmente userò una mia definizione di bool:
stavo pensando a un
typedef unsigned int bool; evitando di includere le definizioni di stdbool.h . In questo caso, c'è qualche altro accorgimento da usare?

Si ma occhio che il medesimo problema si rappresenta anche con tutti i tipi di dati diversi da int, per esempio prova a fare una
funzioncina e come tipo di dati passato prova a usare char o float ;)

[sheijtan]

Infatti mi sembrava strano :D, comunque suppongo e sottolineo suppongo che con il flag -Wconversion il compilatore nel primo esempio
non riesca a risalire al tipo di dato ( bool ) e per default promuova il tipo di dato da bool a int ( che è quello di default ) e da
li il "warning: passing argument 1 of ‘isTrue’ with different width due to prototype" nel secondo esempio invece con la
funzione dichiarata in old-like style il compilatore riesce a risalire al tipo di dato e quindi non genera l'errore, questo spiega anche perchè usando una
nuova definizione del tipo come proposto da 71104 la cosa funzioni :)
sì, sembra ragionevole come spiegazione. Però una nuova definizione può non bastare ad evitare il warining, come ho già fatto notare qualche post più su, una definizione di bool:
typedef unsigned short int bool; continua a generare il warning.
Sembra che sia importante il sizeof() dell' intero usato per definire il bool e questo in effetti tornerebbe con la tua spiegazione.

[trallallero]

a me andava con l'unsigned int perché avevo lasciato la old-style :doh:

[CoreDump]

a me andava con l'unsigned int perché avevo lasciato la old-style :doh:

:D , ho scoperto un'altra cosa ( sto andando in fissa con sta cosa :mc: ) che usando il g++ invece del gcc compila bene senza warning
con il programma originale, mentre con il gcc si becca il warning :mbe:

[sheijtan]

pure io mi sto fissando e visto che vi gusta beccatevi sto esempio:


#include <stdio.h>

int
intConv(short int n) {
return n;
}

int
main(void) {
int num = 2;
printf ("%d = %d\n",num, intConv(num));
return 0;
}

compilando con l'ormai famosa flag -Wconversion ottengo (stavolta a ragione) il solito warning:
int.c: In function ‘main’:
int.c:11: warning: passing argument 1 of ‘intConv’ with different width due to prototype
ora, se dichiaro intConv() old-style riesco a ingannare il compilatore e a by-passare il check!
Ma non basta! Se correggo il programma in :

int
intConv(short int n) {
return n;
}

int
main(void) {
short int num = 2;
printf ("%d = %d\n",num, intConv(num));
return 0;
}

mi ribecco il warning. Insomma , sto iniziando a pensare che ci troviamo di fronte a una qualche strana "feature" di gcc.

[trallallero]

:D , ho scoperto un'altra cosa ( sto andando in fissa con sta cosa :mc: ) che usando il g++ invece del gcc compila bene senza warning
con il programma originale, mentre con il gcc si becca il warning :mbe:

hai provato con man gcc ? sono SOLO 8284 righe, buon divertimento :asd:

[trallallero]

comunque son stordito ... volevo dire:
a me andava con lo short int perché avevo lasciato la old-style :doh:

[trallallero]

e perché se compili usando solo -Wall (che dovrebbe accendere tutti i warnings) invece non da niente ? :mbe:

[sheijtan]

@CoreDump
vero, con g++ tutti gli esempi compilano senza dare il warning. Si hanno problemi con il tipo short int. Che si tratti di un problema di gcc?

[sheijtan]

e perché se compili usando solo -Wall (che dovrebbe accendere tutti i warnings) invece non da niente ? :mbe:
No, non è così -Wall non comprende -Wconversion.

[trallallero]

No, non è così -Wall non comprende -Wconversion.

é vero, azz! non avevo mai visto questa parte del man:

The following -W... options are not affected by -Wall.
....

[CoreDump]

pure io mi sto fissando e visto che vi gusta beccatevi sto esempio:


#include <stdio.h>

int
intConv(short int n) {
return n;
}

int
main(void) {
int num = 2;
printf ("%d = %d\n",num, intConv(num));
return 0;
}

compilando con l'ormai famosa flag -Wconversion ottengo (stavolta a ragione) il solito warning:
int.c: In function ‘main’:
int.c:11: warning: passing argument 1 of ‘intConv’ with different width due to prototype
ora, se dichiaro intConv() old-style riesco a ingannare il compilatore e a by-passare il check!
Ma non basta! Se correggo il programma in :

int
intConv(short int n) {
return n;
}

int
main(void) {
short int num = 2;
printf ("%d = %d\n",num, intConv(num));
return 0;
}

mi ribecco il warning. Insomma , sto iniziando a pensare che ci troviamo di fronte a una qualche strana "feature" di gcc.

Se parliamo di stranezze guarda un pò che ho trovando googlando per la rete :eek:

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=9072

Sembra che la flag -Wconversion avesse qualche problemino ( infatti in giro su internet ho trovato molta gente che accusava un comportamento
anomalo del gcc con la flag attivata :O ) in pratica sembra che la flag -Wconversion sia stata splittata in altri due tra cui il -Wtraditional-conversion
infatti usando solo questo flag il gcc compila ma non ancora dirti se questo comporta qualche altro inconveniente, working progress ............. :D

[CoreDump]

Se parliamo di stranezze guarda un pò che ho trovando googlando per la rete :eek:

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=9072

Sembra che la flag -Wconversion avesse qualche problemino ( infatti in giro su internet ho trovato molta gente che accusava un comportamento
anomalo del gcc con la flag attivata :O ) in pratica sembra che la flag -Wconversion sia stata splittata in altri due tra cui il -Wtraditional-conversion
infatti usando solo questo flag il gcc compila ma non ancora dirti se questo comporta qualche altro inconveniente, working progress ............. :D

Trovato :D , questa dovrebbe essere la spiegazione ufficiale, dategli una letta e ditemi cosa ne pensate :)

http://gcc.gnu.org/wiki/Wcoercion#Background

[sheijtan]

tratto dall' articolo postato da CoreDump:
Therefore, it is not surprising that many incorrectly believe that the purpose of Wconversion is to warn about implicit type conversions that could cause unexpected results [An Introduction to GCC, Network Theory Ltd], when actually it is not. :doh:
Ci sono cascato con tutte le scarpe! Onore e (le mie) scuse a vizzz che già al secondo post aveva individuato correttamente il problema. insomma ricapitolando: -Wconversion non fa quello che pensavo facesse. Quel che mi serve è la futura -Wcoercion. Quindi per ora compilerò senza -Wconversion e quando verrà implementata -Wcoercion ricompilerò tutto :sofico: . Grazie a tutti per l'aiuto!
certo è che ogni giorno se ne impara una...

[CoreDump]

tratto dall' articolo postato da CoreDump:
:doh:
Ci sono cascato con tutte le scarpe! Onore e (le mie) scuse a vizzz che già al secondo post aveva individuato correttamente il problema. insomma ricapitolando: -Wconversion non fa quello che pensavo facesse. Quel che mi serve è la futura -Wcoercion. Quindi per ora compilerò senza -Wconversion e quando verrà implementata -Wcoercion ricompilerò tutto :sofico: . Grazie a tutti per l'aiuto!
certo è che ogni giorno se ne impara una...

Io ringrazierei anche santo google :sofico: comunque mi è servito molto anche a me per dare una rinfrescatina alla memoria :old:
cavolo mi sa che tra un pò mi serve una espansione anche a me :stordita: :fagiano:

[CoreDump]

tratto dall' articolo postato da CoreDump:
:doh:
Ci sono cascato con tutte le scarpe! Onore e (le mie) scuse a vizzz che già al secondo post aveva individuato correttamente il problema. insomma ricapitolando: -Wconversion non fa quello che pensavo facesse. Quel che mi serve è la futura -Wcoercion. Quindi per ora compilerò senza -Wconversion e quando verrà implementata -Wcoercion ricompilerò tutto :sofico: . Grazie a tutti per l'aiuto!
certo è che ogni giorno se ne impara una...

Altresì sarebbe interessante vedere su sull'ultimo gcc disponibile la -Wcoercion è stata già implementata :)

[sheijtan]

la nuova versione di -Wconversion sarà presente in gcc dalla versione 4.3:
http://gcc.gnu.org/wiki/NewWconversion

in questo caso il comportamento dovrebbe essere quello atteso: warning in caso di conversioni implicite.