-Werror заставляет компилятор останавливаться при #warning. Что я могу сделать, чтобы предотвратить это?

Я не знаком с компилятором Tensilica xtensa (xt-xcc), но со стандартным gcc можно использовать

  #pragma GCC diagnostic warning "-Wcpp"

сделать #warning простым предупреждением (а не ошибкой из-за -Werror). Чтобы сделать эффект временным, вы можете использовать #pragma и #warning между #pragma GCC diagnostic push и #pragma GCC diagnostic pop.

Когда я компилирую файл, содержащий следующее

    #pragma GCC diagnostic push
    #pragma GCC diagnostic warning "-Wcpp"
    #warning one
    #pragma GCC diagnostic pop

    #warning two

с -Werror с помощью gcc 4.6.1 (команда gcc -c -Werror warning-test.c) я получаю следующий вывод:

    warning-test.c:3:2: warning: #warning one [-Wcpp]
    warning-test.c:6:2: error: #warning two [-Werror=cpp]
    cc1: all warnings being treated as errors

Когда я удаляю второй #warning, компиляция не прерывается по ошибке.

Вы также можете заменить параметры компилятора -Werror на -Werror -Wno-error=cpp. Я не знаю, какие другие эффекты включает в себя категория предупреждений cpp (и у вас может быть законное #warning в каком-то другом месте, которое вы хотите отловить как ошибку), поэтому временно отключите ошибку для определенного #warning и восстановите настройки сразу после того, как кажется более точный метод удовлетворения ваших требований.

Edit (2016): использование gcc версий 4.8.4 и 4.9.2 дает почти такое же поведение (только дополнительно распечатывается исходная строка). Но использование gcc версии 5.0.1 (предварительная версия, включенная в Ubuntu 15.04) выдаст два предупреждения, если также не включена опция -Werror=cpp. Таким образом, кажется, что -Werror с более новым gcc больше не подразумевает -Werror=cpp, как раньше, и при желании его необходимо указать отдельно.

К сожалению, для моей конкретной цепочки инструментов нет ответа, по крайней мере, так говорят инженеры Tensilica. Они не поддерживают #message или #pramga message() и не знают, как подавить #warning как ошибку при наличии -Werror.

Инструментальная цепочка GCC позволяет использовать -Wno-error=[код], чтобы сказать, что «это предупреждение НЕ является ошибкой», но я не нашел списка, соответствующего #warning какому-либо коду, который потребуется (или даже списка коды это может быть)

Я могу попытаться найти время, чтобы углубиться в стандартные командные строки GCC и исходный код препроцессора, чтобы попытаться найти список того, чему может быть равен -Wno-error=, или есть ли код -Werror=, который соответствует #предупреждение. Если я это сделаю, я вернусь и обновлю ответ.

Что случилось с:

#warning "Come back and implement this"
#warning "Do not do that!"
#warning "Must fix this before release"

Обычно компилятор включает аргумент(ы) до - или материал после - #warning в сообщении об ошибке или предупреждении.

И, как правило, если компилятор обнаруживает что-то, требующее предупреждения, он довольно четко сообщает об этом.

Учитывая требования, я думаю, что единственный способ справиться с этим - защитить директивы #warning...

#ifdef DO_WARNINGS
#warning "Some warning"
#endif /* DO_WARNINGS */

В большинстве случаев вы компилируете без -DDO_WARNINGS; когда вам нужно проверить предупреждения #warning (с -Werror), вы в конце концов включаете -DDO_WARNINGS, соглашаясь с тем, что компиляция завершится ошибкой. Помните, что make -k сделает все возможное даже при наличии отдельных ошибок компиляции.

В разделе 5.52.9 руководства GCC 4.4.1 говорится (частично):

5.52.9 Диагностические прагмы

GCC позволяет пользователю выборочно включать или отключать определенные типы диагностики и изменять тип диагностики. Например, политика проекта может требовать, чтобы все исходные коды компилировались с параметром «-Werror», но некоторые файлы могут иметь исключения, допускающие определенные типы предупреждений. Или проект может выборочно включать диагностику и рассматривать их как ошибки в зависимости от того, какие макросы препроцессора определены.

#pragma GCC diagnostic kind option

Изменяет расположение диагностики. Обратите внимание, что не все диагностические данные можно изменить; на данный момент можно управлять только предупреждениями (обычно управляемыми ‘-W...’), а не всеми. Используйте «-fdiagnostics-show-option», чтобы определить, какие диагностики являются управляемыми и какой параметр ими управляет. типом является «ошибка», чтобы рассматривать эту диагностику как ошибку, «предупреждение», чтобы рассматривать ее как предупреждение (даже если действует «-Werror»), или «игнорировать», если диагностику следует игнорировать. option — это строка в двойных кавычках, которая соответствует параметру командной строки.

#pragma GCC diagnostic warning "-Wformat"
#pragma GCC diagnostic error "-Wformat"
#pragma GCC diagnostic ignored "-Wformat"

Обратите внимание, что эти прагмы переопределяют любые параметры командной строки. Кроме того, хотя синтаксически допустимо размещать эти прагмы в любом месте ваших источников, единственное поддерживаемое место для них — до того, как будут определены какие-либо данные или функции. В противном случае это может привести к непредсказуемым результатам в зависимости от того, как оптимизатор управляет вашими источниками. Если одна и та же опция указана несколько раз, действует последняя указанная опция. Эта прагма предназначена не для замены параметров командной строки общего назначения, а для реализации строгого контроля над политиками проекта.

GCC также предлагает простой механизм для вывода сообщений во время компиляции.

#pragma message string

Выводит строку как сообщение компилятора при компиляции. Сообщение носит только информационный характер и не является ни предупреждением компиляции, ни ошибкой.

#pragma message "Compiling " __FILE__ "..."

строка может быть заключена в круглые скобки и печатается с информацией о местоположении.

Я не уверен, хотите ли вы преобразовать свои #warning строк в #pragma message строк. Это избавит вас от проблемы - и это только хуже, чем добавление условной компиляции вокруг #warning, поскольку #pragma message может поддерживаться меньшим количеством компиляторов. Это зависит от ваших требований к переносимости.

Учитывая, что #warning предположительно обрабатывается препроцессором, вы можете запустить препроцессор отдельно без -Werror, а затем запустить компилятор с запрещенной предварительной обработкой на выходе пропроцессора.

Для этого пропустите файл .c через препроцессор со всеми обычными параметрами, кроме -Werror, и сгенерируйте выходные данные в виде файла .i (.ii для C++). Компилятор распознает эти файлы как не подлежащие предварительной обработке, поэтому вы можете скомпилировать их с параметром -Werror и предположить, что препроцессор сбрасывает #warning и не обрабатывается самим компилятором, это может решить вашу проблему.

Я не проверял это; когда я столкнулся с той же проблемой, я просто решил жить с ней и не использовать -Werror. Решение казалось более сложным, чем проблема!

Десять лет спустя правильный способ выдавать предупреждения и избегать этих дополнительных сообщений/ошибок от -Wpedantic — использовать #pragma message. GCC поддерживает этот синтаксис, начиная с GCC 4.5 и clang, по крайней мере, с Клэнг 6.

Современные версии этих компиляторов даже поддерживают #pragma GCC error "message" и #pragma GCC warning "message" (GCC9, уже поддерживается в Clang 6)

Если ваш компилятор поддерживает это, вы можете попробовать использовать constructor атрибут функции для определения функции, которая запускается при запуске программы (до main) и выводит сообщение на стандартный вывод:

#define TOKENPASTE(x, y) TOKENPASTE2(x, y)
#define TOKENPASTE2(x, y) x ## y
#define WARNING(message) \
  static void TOKENPASTE(_print_warning, __LINE__)() __attribute__((constructor)); \
  static void TOKENPASTE(_print_warning, __LINE__)() \
  { \
    puts(message); \
  }

WARNING("fix this before ship")  // prints out a message at runtime before main

Это заставляет сообщение распечатываться во время выполнения, а не во время компиляции, что почти так же хорошо, особенно если у вас нет других вариантов. Единственное ограничение состоит в том, что вы должны использовать это в глобальном масштабе вне определения функции.