So finden Sie die Quelle einiger Makros

Es gibt viele Stellen zum Definieren eines Makros. Wenn das Makro in unserem eigenen Projekt von uns definiert wird, ist es einfach, die Definitionsposition dafür zu finden. Aber wenn ich versuche, ein berühmtes Open-Source-Projekt zu lernen, werde ich häufig von der Frage geplagt: Wo finde ich die Quelle der Makros, wenn ich ihre Definition nicht bekomme, werde ich einige von ihnen nicht verstehen (zB einige von ihnen lässt sich anhand des Namens erraten). zum Beispiel eine Aussage von Apache:

#if defined(__osf__) && defined(__alpha),

#elif defined(__NSIG)

Soweit ich weiß, weiß ich, dass es einen möglichen Ursprungsort für ein Makro gibt:

1. aus diesem Projekt selbst, in einer Quelldatei (dies ist am einfachsten, weil wir es mit einem Tool finden können)
2. Aus einer Header-Datei einer 3. Bibliothek können wir sie grep
3. aus der c/c++ Standard-Header-Datei (wo sind sie in Linux?)
4. aus dem Betriebssystem (wo sind sie in Linux?)
5. automatisch vom Konfigurationstool generiert (es ist bitter, ich habe keine Ahnung)
6. aus dem Compiler-Tool wie gcc/g++ oder im Makefile können wir ein Makro definieren

Ich habe eine Frage zu konsultieren:

1. Wie kann man sie zwischen os-definierten und gcc/g++-definierten und vom Konfigurationstool generierten Makros unterscheiden? Haben sie jeweils bestimmte Eigenschaften?
2. Wie finde ich die Quelle der von OS oder Standard-C oder Compiler definierten? zB mit grep oder find Dienstprogramme
3. was bedeutet es, wenn ein Makro wie z __strange___ kann nicht durch Kämmen der gesamten Maschine gefunden werden (cd /;grep __strange___ -r)?

Danke, dass Sie das Prinzip und die Methode erklärt haben, sie zu unterscheiden und ihre Quelle zu finden!

Eine einfache und schnelle Methode, um herauszufinden, wo ein Makro definiert wurde, besteht darin, das Makro neu zu definieren und die Warn-/Fehlermeldung des Compilers zu überprüfen.

#include <windows.h>
#define min(a,b) nonsense

mintest.cpp(3) : warning C4005: 'min' : macro redefinition
    C:\Programme\Microsoft SDKs\Windows\v6.0A\include\windef.h(194) : see previous definition of 'min'

1. Wie kann man sie zwischen os-definierten und gcc/g++-definierten und vom Konfigurationstool generierten Makros unterscheiden? Haben sie jeweils bestimmte Eigenschaften?

Die überwiegende Mehrheit ist irgendwo in einer Header-Datei definiert. gcc -dN -E kann hier weiterhelfen. Vorbehalt: Wenn Sie diesen Ansatz verwenden, müssen Sie aufrufen gcc -dN -E mit den gleichen include-Pfade, die gleichen -D<name> Befehlszeilenoptionen, dieselben Umgebungsvariablen wie z CPATH…, wie Sie es tun, wenn Sie Ihre Quelle in Objektdateien kompilieren.

1. Wie finde ich die Quelle der von OS oder Standard-C oder Compiler definierten? zB mit grep oder Find Utilities

RTFM. Lesen Sie die feine Anleitung.

1. was bedeutet es, wenn ein Makro wie z __strange__ kann nicht durch Kämmen der gesamten Maschine gefunden werden (cd /;grep __strange___ -r)?

Es könnte einfach bedeuten, dass dieses Symbol auf Ihrem Computer nicht definiert ist. Angenommen, der fragliche Code stammt aus einem Open-Source-Paket, das auf eine Schiffsladung verschiedener Systeme und verschiedener Compiler abzielt, von denen einige nicht ganz mit dem C++-Standard kompatibel sind. Der typische Ansatz ist zu verwenden #ifdef __some_bizarre_os__ in wichtigen Teilen des Codes. Dieses Symbol wird nur auf Computern definiert, auf denen das Bizarre-Betriebssystem ausgeführt wird – nicht auf Ihrem.

Leider ist das nicht der einzige Fall. Das Symbol könnte gut definiert sein, auch wenn Ihr grep es nirgendwo finden kann. Das Makefile könnte zwei Strings verketten, -D__str und ange__ um ein einzelnes Befehlszeilenargument für den Compiler zu bilden. Die Option -D__strange__ könnte sich in einer Ihrer Umgebungsvariablen, die vom Makefile verwendet werden, gut sichtbar verstecken. Die ~/.tcshrc-Dateien, die einige Projekte vorschreiben, können unglaublich verworren sein.

Aktualisieren
gcc -dM -E zeigt die Definitionen der Makros, aber nicht wo sie definiert wurden. Eine viel bessere Optionen ist zu verwenden gcc -dN -E und dann Zeilen herausfiltern, die nicht mit einem Anfangsbuchstaben beginnen #.

Vom gcc-Compiler definierte Makros können angezeigt werden

gcc  -dM -E a.c

Abgesehen davon stammen sie alle aus enthaltenen Dateien und Quellen.

Wenn Sie das Makro nicht finden können, bedeutet dies, dass die Bedingung als falsch ausgewertet wird.

Sie können auch die Option -v verwenden, sie zeigt, wo es seine standardmäßigen Include-Verzeichnisse findet.

So finden Sie heraus, aus welcher Datei das Makro stammt:

gcc -E $your_compile_options $your_c_file | \
egrep "^# " | grep -v '<'| cut -f 2 -d '"' | \
sort | uniq |
while read line
    do
            grep -l $your_macro $line
    done

Wie andere sagten, gcc mit einem von -d Optionen verwendet werden sollten Finden Sie heraus, wo das Makro definiert ist. Diese Optionen werden nicht von ausgegeben gcc -v --helpalso müssen sie mit gelesen werden das HandbuchKapitel 3.11suchen nach -dCHARS.

Schließlich sind meine Schritte:

1. Verwenden gcc ... -E -dD
2. Suchen Sie die Definition in der Ausgabedatei
3. Suchen Sie rückwärts nach # (ein Hash und ein Leerzeichen), um die Datei anzuzeigen

Es sieht so aus, als wären diese Makros Kompilierungskonstanten.

Es empfiehlt sich, solche Makros zu verwenden, um dem Compiler mitzuteilen, dass dieser Teil des Codes kompiliert werden muss und dieser Teil des Codes nicht kompiliert werden soll.

Wenn Sie sie nicht in Ihrem Projektarbeitsbereich suchen können, sollten Sie den Programmablauf durchgehen und entscheiden, welcher Teil des Codes von Ihrer Anwendung benötigt wird, und das entsprechende Makro definieren.

Zum Beispiel;

#ifdef (_CASE1_)

...
...
...

#elif (_CASE2_)

...
...
...

#endif

jetzt im obigen Beispiel, wenn der Code unter abgedeckt ist _CASE1_ für Ihre Anwendung erforderlich ist, müssen Sie diese definieren _CASE1_. z.B #define _CASE1_

ich hoffe es hilft…

Wenn Sie ein Open-Source-Projekt studieren, gehe ich davon aus, dass Sie es so eingerichtet haben, dass Sie es erstellen können. Wählen Sie eine Datei aus, die das gesuchte Makro enthält, und verwenden Sie Ihren Compiler, um eine vorverarbeitete Datei zu generieren. Die tatsächliche Option hängt vom verwendeten Compiler ab, es ist -E für gcc, Sie können einige weitere Informationen finden hier.

Beachten Sie, dass Sie wahrscheinlich das Build-System Ihres Projekts verwenden müssen, um Ihre Datei tatsächlich zu kompilieren und zu sehen, welche Optionen Sie benötigen, damit die Ausführung des Präprozessors erfolgreich ist.

Sobald Sie Ihre vorverarbeitete Datei haben, suchen Sie einfach nach Ihrem Makro. Es gibt Präprozessoroptionen, die den Pfadnamen für jede enthaltene Datei generieren.

UPDATE: Dieser Ansatz funktioniert offensichtlich nicht, da Ihr Makro um den Prozessor erweitert wird. Wenn Sie also nicht seine erweiterte Form oder seine Auswirkungen erkennen können, wäre es von geringem Nutzen.

Etwas nützlicher könnte es sein, den Compiler dazu zu bringen, die genaue Reihenfolge der enthaltenen Dateien auszugeben. Dies wird in gcc mit der Option -H erreicht.

Sie sollten eine IDE wie Eclipse verwenden, in der Sie einfach mit der rechten Maustaste auf das Makro klicken und auf Deklaration öffnen klicken können, und Sie werden an die Datei weitergeleitet, und die Zeile, in der das Makro definiert ist.

Manchmal sind einige Makros nicht einmal in den Header-Dateien definiert, da sie als Flags an den GNU-Compiler übergeben werden (Beispiel: -DMYMACRO).