Ricerca di file di intestazione

Naviga le tue risposte
3

Il compilatore AC o C ++ cerca i file di intestazione usando un set severo di regole: relativo alla directory del file incluso (se è stato usato "", quindi lungo i percorsi di inclusione specificati e predefiniti, esito negativo se non ancora trovato.

Uno strumento ausiliario come un analizzatore di codici (su cui sto attualmente lavorando) ha requisiti diversi: potrebbe, per una serie di ragioni, non avere il beneficio della configurazione eseguita da un complesso processo di compilazione, e dover fare il meglio di ciò che è dato. In altre parole, può trovare un file di intestazione non presente nei percorsi di inclusione che conosce e deve fare del suo meglio per trovare il file stesso.

Attualmente sto pensando di utilizzare il seguente algoritmo:

  1. Inizia nella directory del file incluso.

  2. Il file di intestazione si trova nella directory corrente o in una sua sottodirectory? Se è così, fatto.

  3. Se siamo nella directory root, il file non sembra essere presente su questa macchina, quindi saltatelo. Altrimenti, passa al padre della directory corrente e vai al passaggio 2.

È questo il miglior algoritmo da usare? In particolare, qualcuno sa di casi in cui un diverso algoritmo avrebbe funzionato meglio?

    
posta rwallace 13.11.2011 - 18:44
fonte

2 risposte

3

I'm currently thinking of using the following algorithm:

  1. Start in the directory of the including file.

  2. Is the header file found in the current directory or any subdirectory thereof? If so, done.

  3. If we are at the root directory, the file doesn't seem to be present on this machine, so skip it. Otherwise move to the parent of the current directory and go to step 2.

Is this the best algorithm to use? In particular, does anyone know of any case where a different algorithm would work better?

Ho lavorato in progetti con una configurazione del genere: 

prj  
   |  
   +-config.h  
   |  
   +-sub_A  
   | |  
   | +-config.h  
   | +-...  
   |  
   +-sub_B
   | |  
   | +-config.h  
   | +-...  
   |  
   +-...

Questi sono indicati come 

#include "config.h"
#include "sub_A/config.h"
#include "sub_B/config.h"
...

Basta cercare un'intestazione con un nome di file corrispondente per farla esplodere, il che credo sia che un diverso algoritmo funzionerebbe meglio.

    
risposta data 13.11.2011 - 20:34
fonte
3

Penso che con qualsiasi algoritmo non si riuscirà senza conoscere la riga di comando del compilatore utilizzata per la compilazione di determinati file. Quindi, vedo solo due possibilità di utilizzare l'analizzatore statico con qualsiasi sistema di compilazione:

  1. "lint way" (che probabilmente non è molto allineato con i requisiti dell'utente) posiziona l'utility subito prima o al posto del richiamo del compilatore, passando tutti gli stessi argomenti. In questo caso dovresti scavare in qualsiasi sistema di compilazione / makefile per trovare tutte le regole responsabili della compilazione.
  2. "modo di copertura" esegui ogni processo di compilazione sotto il tuo strumento, cioè come / i processo / i figlio / i. Pertanto, il tuo strumento dovrebbe essere abbastanza intelligente da tracciare quali file sono attualmente aperti dal compilatore, quali flag vengono passati. Questo è tuttavia un modo complicato ma affidabile.
risposta data 13.11.2011 - 22:24
fonte

Leggi altre domande sui tag

migrazione del prodotto e del team dalla gara di avvio allo sviluppo della qualità [duplicato] Come posso fornire indicazioni sulle scelte tecnologiche attraverso le storie degli utenti?