Jak wyświetlić wartość #define w czasie kompilacji?

Próbuję dowiedzieć się, jakiej wersji Boost mój kod używa. Chcę zrobić coś takiego:

#error BOOST_VERSION

ale preprocesor nie rozwija BOOST_VERSION.

Wiem, że mógłbym wydrukować go w czasie wykonywania z programu i wiem, że mógłbym spojrzeć na dane wyjściowe preprocesora, aby znaleźć odpowiedź. Czuję, że sposób na zrobienie tego podczas kompilacji może być przydatny.

Wiem, że minęło dużo czasu od pierwotnego zapytania, ale może to być przydatne.

Można to zrobić w GCC za pomocą operatora stringify „#”, ale wymaga to dwóch etapów.

#define XSTR(x) STR(x)
#define STR(x) #x

Wartość makra można następnie wyświetlić za pomocą:

#pragma message "The value of ABC: " XSTR(ABC)

Zobacz: 3.4 Stringifikacja w dokumentacji online gcc.

Jak to działa:

Preprocesor rozumie cytowane ciągi i traktuje je inaczej niż zwykły tekst. Przykładem tego specjalnego traktowania jest konkatenacja ciągów. Komunikat pragma wymaga argumentu będącego łańcuchem cudzysłowu. Jeśli argument zawiera więcej niż jeden składnik, wszystkie muszą być łańcuchami, aby można było zastosować konkatenację ciągów. Preprocesor nigdy nie może założyć, że niecytowany ciąg powinien być traktowany tak, jakby był cytowany. Jeśli tak się stało:

#define ABC 123
int n = ABC;

nie będzie się kompilować.

Rozważmy teraz:

#define ABC abc
#pragma message "The value of ABC is: " ABC

co jest równoważne

#pragma message "The value of ABC is: " abc

Powoduje to ostrzeżenie preprocesora, ponieważ abc (bez cudzysłowu) nie może zostać połączone z poprzednim ciągiem.

Rozważmy teraz preprocesor stringize (który kiedyś był nazywany stringification, linki w dokumentacji zostały zmienione, aby odzwierciedlić poprawioną terminologię. (Nawiasem mówiąc, oba terminy są równie obrzydliwe. Prawidłowy termin to oczywiście stringifaction. Przygotuj się do aktualizacji Twoje linki.)). Działa to tylko na argumentach makra i zastępuje nierozwinięty argument argumentem ujęty w podwójne cudzysłowy. A zatem:

#define STR(x) #x
char *s1 = "abc";
char *s2 = STR(abc);

przypisze identyczne wartości s1 i s2. Jeśli uruchomisz gcc -E, zobaczysz to na wyjściu. Być może STR byłoby lepiej nazwane czymś w rodzaju ENQUOTE.

To rozwiązuje problem umieszczania cudzysłowów wokół niecytowanego elementu, problem polega teraz na tym, że jeśli argumentem jest makro, makro nie zostanie rozwinięte. Dlatego potrzebne jest drugie makro. XSTR rozszerza swój argument, a następnie wywołuje STR, aby umieścić rozwiniętą wartość w cudzysłowie.

BOOST_PP_STRINGIZE wydaje się być doskonałym rozwiązaniem dla C ++, ale nie dla zwykłego C.

Oto moje rozwiązanie dla CPP GNU:

/* Some test definition here */
#define DEFINED_BUT_NO_VALUE
#define DEFINED_INT 3
#define DEFINED_STR "ABC"

/* definition to expand macro then apply to pragma message */
#define VALUE_TO_STRING(x) #x
#define VALUE(x) VALUE_TO_STRING(x)
#define VAR_NAME_VALUE(var) #var "="  VALUE(var)

/* Some example here */
#pragma message(VAR_NAME_VALUE(NOT_DEFINED))
#pragma message(VAR_NAME_VALUE(DEFINED_BUT_NO_VALUE))
#pragma message(VAR_NAME_VALUE(DEFINED_INT))
#pragma message(VAR_NAME_VALUE(DEFINED_STR))

Powyższe definicje skutkują:

test.c:10:9: note: #pragma message: NOT_DEFINED=NOT_DEFINED
test.c:11:9: note: #pragma message: DEFINED_BUT_NO_VALUE=
test.c:12:9: note: #pragma message: DEFINED_INT=3
test.c:13:9: note: #pragma message: DEFINED_STR="ABC"

W przypadku zmiennych „zdefiniowane jako interger” , „zdefiniowane jako łańcuch” i „zdefiniowane, ale bez wartości” , działają one dobrze. Tylko dla zmiennej „niezdefiniowanej” wyświetlały się dokładnie tak samo, jak oryginalna nazwa zmiennej. Trzeba się do tego przyzwyczaić - a może ktoś zaproponuje lepsze rozwiązanie.

Jeśli używasz języka Visual C ++, możesz użyć #pragma message:

#include <boost/preprocessor/stringize.hpp>
#pragma message("BOOST_VERSION=" BOOST_PP_STRINGIZE(BOOST_VERSION))

Edycja: dzięki LB za link

Najwyraźniej odpowiednik GCC to (nie testowano):

#pragma message "BOOST_VERSION=" BOOST_PP_STRINGIZE(BOOST_VERSION)

O ile wiem, '#error' wypisze tylko ciągi znaków, w rzeczywistości nie musisz nawet używać cudzysłowów .

Czy próbowałeś napisać różne celowo niepoprawne kody przy użyciu „BOOST_VERSION”? Może coś w rodzaju „bla [BOOST_VERSION] = foo;” powie ci coś w rodzaju „literał ciągu 1.2.1 nie może być użyty jako adres tablicy”. Nie będzie to ładny komunikat o błędzie, ale przynajmniej pokaże odpowiednią wartość. Możesz bawić się, aż znajdziesz błąd kompilacji, który mówi ci o wartości.

Bez doładowania:

1. zdefiniuj ponownie to samo makro, a sam kompilator wyświetli ostrzeżenie.

2. Z ostrzeżenia można zobaczyć lokalizację poprzedniej definicji.

3. vi o poprzedniej definicji.

ambarish@axiom:~/cpp$ g++ shiftOper.cpp
shiftOper.cpp:7:1: warning: "LINUX_VERSION_CODE" redefined
shiftOper.cpp:6:1: warning: this is the location of the previous definition

#define LINUX_VERSION_CODE 265216
#define LINUX_VERSION_CODE 666

int main ()
{

}

W Microsoft C / C ++ możesz użyć wbudowanego _CRT_STRINGIZE()do drukowania stałych. Wiele moich stdafx.hplików zawiera kombinacje następujących elementów:

#pragma message("_MSC_VER      is " _CRT_STRINGIZE(_MSC_VER))
#pragma message("_MFC_VER      is " _CRT_STRINGIZE(_MFC_VER))
#pragma message("_ATL_VER      is " _CRT_STRINGIZE(_ATL_VER))
#pragma message("WINVER        is " _CRT_STRINGIZE(WINVER))
#pragma message("_WIN32_WINNT  is " _CRT_STRINGIZE(_WIN32_WINNT))
#pragma message("_WIN32_IE     is " _CRT_STRINGIZE(_WIN32_IE))
#pragma message("NTDDI_VERSION is " _CRT_STRINGIZE(NTDDI_VERSION)) 

i wyświetla coś takiego:

_MSC_VER      is 1915
_MFC_VER      is 0x0E00
_ATL_VER      is 0x0E00
WINVER        is 0x0600
_WIN32_WINNT  is 0x0600
_WIN32_IE     is 0x0700
NTDDI_VERSION is 0x06000000

#define a <::BOOST_VERSION>
#include a

MSVC2015 : błąd krytyczny C1083: nie można otworzyć pliku dołączanego: „:: 106200”: nie ma takiego pliku lub katalogu

Działa, nawet jeśli preprocess to filejest włączona, nawet jeśli obecne są nieprawidłowe tokeny:

#define a <::'*/`#>
#include a

MSVC2015 : błąd krytyczny C1083: Nie można otworzyć pliku dołączanego: '::' * / `# ': Nie ma takiego pliku lub katalogu
GCC4.x : ostrzeżenie: brak znaku kończącego' [-Winvalid-pp-token]
#define a <:: '* / `#>

Możesz również wstępnie przetworzyć plik źródłowy i zobaczyć, do czego szacowana jest wartość preprocesora.

Czy szukasz

#if BOOST_VERSION != "1.2"
#error "Bad version"
#endif

Niedobrze, jeśli BOOST_VERSION jest ciągiem, jak założyłem, ale mogą również istnieć indywidualne liczby całkowite zdefiniowane dla numerów głównych, pomocniczych i numerów wersji.

Spojrzenie na dane wyjściowe preprocesora jest najbliższe odpowiedzi, o którą prosisz.

Wiem, że wykluczyłeś to (i inne sposoby), ale nie jestem pewien, dlaczego. Masz wystarczająco konkretny problem do rozwiązania, ale nie wyjaśniłeś, dlaczego żadna z „normalnych” metod nie działa dobrze.

Możesz napisać program, który wydrukuje, BOOST_VERSIONskompiluje i uruchomi go jako część twojego systemu budowania. W przeciwnym razie myślę, że nie masz szczęścia.

BOOST_VERSION jest zdefiniowana w pliku nagłówka boost version.hpp.

Zapoznaj się również z dokumentacją Boost, aby dowiedzieć się, jak używasz makra:

W odniesieniu do BOOST_VERSION, z http://www.boost.org/doc/libs/1_37_0/libs/config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.boost_helper_macros :

Opisuje numer wersji boost w formacie XXYYZZ taki, że: (BOOST_VERSION % 100)jest wersją podrzędną, wersją pomocniczą i wersją główną.((BOOST_VERSION / 100) % 1000)(BOOST_VERSION / 100000)

Zamiast #error spróbuj przedefiniować makro tuż przed jego użyciem. Kompilacja zakończy się niepowodzeniem, a kompilator poda bieżącą wartość, którą według niego ma zastosować do makra.

# zdefiniować BOOST_VERSION bla