Portabilité de la directive #warning préprocesseur

Question

Je sais que la directive #warning n'est pas standard C / C ++, mais plusieurs compilateurs la prennent en charge, y compris gcc / g ++. Mais pour ceux qui ne le supportent pas, vont-ils l'ignorer silencieusement ou cela va-t-il aboutir à un échec de compilation? En d’autres termes, puis-je l’utiliser en toute sécurité dans mon projet sans casser la construction des compilateurs qui ne le prennent pas en charge?

Answer 1

Il est probable que si un compilateur ne prend pas en charge #warning, il générera une erreur. Contrairement à #pragma, il n’est pas recommandé que le préprocesseur ignore les directives qu’il ne comprend pas.

Cela étant dit, j'ai utilisé des compilateurs sur différentes plates-formes (assez communes) et ils ont tous pris en charge le #warning.

Answer 2

Il convient de noter que MSVC utilise la syntaxe suivante:

#pragma message ( "your warning text here" )

La syntaxe habituelle #warning génère une erreur fatale

C1021: invalid preprocessor command 'warning'

il n'est donc pas portable pour ces compilateurs.

Answer 3

Vous êtes susceptible de recevoir au moins un avertissement de directive non reconnu de compilateurs qui ne reconnaissent pas #warning, même si le bloc de code n'est pas inclus dans votre compilation. Cela pourrait ou ne pourrait pas être traité comme une erreur - le compilateur pourrait légitimement le traiter comme une erreur, mais beaucoup seraient plus laxistes.

Connaissez-vous (pouvez-vous nommer) un compilateur autre que GCC / G ++ qui fournit #warning? [ Modifié: Sun Solaris 10 (Sparc) et les compilateurs Studio 11 C / C ++ acceptent tous les deux #warning.]

Answer 4

J'ai eu ce problème une fois avec un compilateur pour un processeur Atmel. Et il a généré des erreurs de préprocesseur en raison du jeton #warning inconnu.

Malheureusement, la solution semblait être de convertir l'ensemble de l'arborescence source afin qu'elle utilise l'équivalent #pragma et d'accepter le fait que le comportement de construction allait être différent si vous utilisiez gcc.

Answer 5

Lors du passage de mingw à visual studio, j'ai ajouté ces lignes à mon en-tête de configuration globale. (incluez-le dans stdafx.h)

#ifdef __GNUC__
//from https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Pragmas.html
//Instead of put such pragma in code:
//#pragma GCC diagnostic ignored "-Wformat"
//use:
//PRAGMA_GCC(diagnostic ignored "-Wformat")
#define DO_PRAGMA(x) _Pragma (#x)
#define PRAGMA_GCC(x) DO_PRAGMA(GCC #x)

#define PRAGMA_MESSAGE(x) DO_PRAGMA(message #x)
#define PRAGMA_WARNING(x) DO_PRAGMA(warning #x)
#endif //__GNUC__
#ifdef _MSC_VER
/*
#define PRAGMA_OPTIMIZE_OFF __pragma(optimize("", off))
// These two lines are equivalent
#pragma optimize("", off)
PRAGMA_OPTIMIZE_OFF
*/
#define PRAGMA_GCC(x)
// https://support2.microsoft.com/kb/155196?wa=wsignin1.0
#define __STR2__(x) #x
#define __STR1__(x) __STR2__(x)
#define __PRAGMA_LOC__ __FILE__ "("__STR1__(__LINE__)") "
#define PRAGMA_WARNING(x) __pragma(message(__PRAGMA_LOC__ ": warning: " #x))
#define PRAGMA_MESSAGE(x) __pragma(message(__PRAGMA_LOC__ ": message : " #x))

#endif

//#pragma message "message quoted"
//#pragma message message unquoted

//#warning warning unquoted
//#warning "warning quoted"

PRAGMA_MESSAGE(PRAGMA_MESSAGE unquoted)
PRAGMA_MESSAGE("PRAGMA_MESSAGE quoted")

#warning "#pragma warning quoted"

PRAGMA_WARNING(PRAGMA_WARNING unquoted)
PRAGMA_WARNING("PRAGMA_WARNING quoted")

J'utilise maintenant PRAGMA_WARNING (ce problème doit être corrigé)

Malheureusement, il n'y a pas de #pragma warning dans gcc. Il avertit donc d'un pragma non spécifié.

Je doute que gcc ajoute #pragma warning " au lieu de ajouter Microsoft #warning .

Answer 6

En fait, la plupart des compilateurs que je connais ignorent les directives inconnues #pragma et génèrent un message d'avertissement. Dans le pire des cas, vous recevrez toujours un avertissement.