Strumento per tenere traccia delle dipendenze #include [chiuso]

Qualche buon suggerimento? L'input sarà il nome di un file di intestazione e l'output dovrebbe essere un elenco (preferibilmente un albero) di tutti i file incluso direttamente o indirettamente.

Se hai accesso a GCC / G ++, l' -Mopzione genererà l'elenco delle dipendenze. Non fa nessuna delle cose extra che fanno gli altri strumenti, ma dal momento che proviene dal compilatore, non c'è alcuna possibilità che raccolga i file dal posto "sbagliato".

Grazie a KeithB. Ho cercato i documenti per cl.exe (VS2008) e ho trovato il flag / showIncludes. Dall'IDE, questo può essere impostato dalla pagina delle proprietà di qualsiasi file CPP.

Per una soluzione pesante, dovresti dare un'occhiata a doxygen . Esegue la scansione della base di codice e crea un sito Web che documenta effettivamente il codice. Una delle tante cose che mostra è includere alberi.

Se stavi cercando di essere in grado di collegare l'output di questo strumento in qualche altro processo, allora questo potrebbe non funzionare per te (anche se doxygen produce output in altri formati, non ho molta familiarità con quella funzione). Se vuoi semplicemente controllare le dipendenze, però, dovrebbe funzionare alla grande.

Ho giocato con uno strumento chiamato cinclude2dot . È stato molto utile ottenere una maniglia su una base di codice piuttosto grande quando sono venuto a lavorare qui. Alla fine ho pensato di integrarlo nella nostra build quotidiana.

Innanzitutto, cinclude2dot.pl è uno script perl che analizza il codice C / C ++ e produce un grafico di dipendenza #include come file dot per l'input in graphviz.

http://www.flourish.org/cinclude2dot/

Se non vuoi seguire la strada per quel tipo di strumento manuale, allora il vincitore di gran lunga a mio avviso è uno strumento noto come "IncludeManager" di ProFactor.

http://www.profactor.co.uk/includemanager.php

C'è una prova gratuita ed è fantastico. È un plug-in per Visual Studio completamente integrato, quindi facendo doppio clic su qualcosa qui ti porta nel luogo in cui è incluso laggiù.

I mouseover della descrizione comandi ti danno tutte le informazioni che desideri e ti consentono di eseguire il drill-down / up, rimuovere interi sottotitoli che non ti interessano, visualizzare rappresentazioni diverse dai grafici, scorrere un elenco di corrispondenze per questo e quello, è meraviglioso.

Se sei veloce a riguardo, puoi riformattare la struttura #include di un grande progetto prima che finisca il processo. Anche così, non costa molto, circa $ 35 per licenza.

Per quello che fa, è quasi perfetto. Non solo grafici #include ma anche dipendenze tra progetti di file condivisi, impatto sui tempi di costruzione, proprietà dettagliate nelle griglie, perfetto.

Buone notizie: redhat Source-Navigator (funziona anche su Windows). Naturalmente, gli switch del compilatore (menzionati in precedenza) hanno un analisi superiore e non sono sicuro di come gestirà MFC, Qt e le loro parole chiave magiche.

Sulla base della risposta di KeithB , ecco la sintassi di GNUmake per 1) generare automaticamente i file delle dipendenze, 2) tenerli aggiornati e 3) usarli nel tuo makefile:

.dep:
    mkdir $@
.dep/%.dep: %.c .dep
    (echo $@ \\; $(CC) $(IFLAGS) -MM $<) > $@ || (rm $@; false)
.dep/%.dep: %.cpp .dep
    (echo $@ \\; $(CXX) $(IFLAGS) -MM $<) > $@ || (rm $@; false)
DEPEND := $(patsubst %.dep,.dep/%.dep,$(OBJ:.o=.dep))
-include $(DEPEND)

(Assicurati di cambiare questi rientri in hardtabs.)

Puoi anche dare un'occhiata a makedepend :

http://en.wikipedia.org/wiki/Makedepend

http://www.xfree86.org/current/makedepend.1.html

Capire per C ++ dovrebbe essere in grado di aiutarti: crea un database a cui puoi accedere da Perl.

cscope ( http://cscope.sourceforge.net/ ) lo fa in un xterm autonomo e può anche essere usato nel tuo editor preferito - ha un ottimo supporto per emacs e vi / vim.

Esiste uno strumento gratuito Includi osservatore dipendenze file