2009-06-12 23 views
6

Vorremmo rendere più coerente il nostro stile di bretelle C++. In questo momento, il nostro codice contiene un mix di:Riformattare le parentesi graffe C++ senza modificare il rientro?

if (cond) 
{ 
    // ...  
} 
else 
{ 
    // ... 
} 

... e:

if (cond) { 
    // ... 
} else { 
    // ... 
} 

Vogliamo utilizzare questi ultimi stile esclusivo.

Tuttavia, abbiamo non desidera modificare il rientro del nostro codice. Ho provato a utilizzare astyle, bcpp, GNU indent e Uncrustify (e ho esaminato le opzioni della riga di comando per GreatCode). Sfortunatamente, ognuno di questi strumenti insiste nel reindentare il nostro codice, e la maggior parte di essi altera le liste di inizializzazione del costruttore C++ e le macro del preprocessore piuttosto male.

Esistono abbellitori di codice C++ che possono riparare le parentesi lasciando solo le indentazioni? Non deve essere uno strumento preesistente - se sai come farlo usando una fodera di Perl pazza, va anche bene. Grazie!

Aggiornamento: Sì, siamo consapevoli che questo renderà difficile leggere le differenze rispetto al codice precedente. Si tratta di una pulizia del codice posticipata e abbiamo deciso che i vantaggi quotidiani della formattazione coerente superano qualsiasi difficoltà di controllo della versione.

+0

Voi ragazzi state sudando la Piccola Stuff. –

risposta

7

Ecco un one-liner Perl che dovrebbe fare quello che vuoi.

perl -pi.bak -e 'BEGIN { undef $/; } s/\s*?(\s?\/\/.*)?\r?\n\s*{/ {\1/g; s/}(\s?\/\/.*)?\r?\n\s*else\b(.*)/} else\2\1/g;' 

Risulta questo:

int main(int argc, char *argv[]) 
{ 
    int something = 0; 
    if (something) // 5-12-2007 
    { 
     printf("Hi!\n"); 
    } 
    else // 5-13-2007 
    { 
     printf("Bye\n"); 
    } 
    return 0; 
} 

in questo:

int main(int argc, char *argv[]) { 
    int something = 0; 
    if (something) { // 5-12-2007 
     printf("Hi!\n"); 
    } else { // 5-13-2007 
     printf("Bye\n"); 
    } 
    return 0; 
} 
+0

Ottimo! Ci proverò tra un'ora o così. – emk

+0

Mille grazie! Questo è un buon inizio e può essere adattato per gestire altri costrutti come "catch". – emk

3

Davvero dovresti pensarci due volte, e probabilmente tre volte, prima di farlo. Distruggerà completamente la cronologia delle revisioni del sistema di controllo del codice sorgente nel punto di cambiamento. Stai usando un sistema di controllo del codice sorgente, vero?

+0

forse sono spesso, ma non capisco.L'unico problema che vedo è che diffondere i file prima e dopo la modifica comporterà molte differenze. Non vedo come "Distruggerà completamente la cronologia delle revisioni del sistema di controllo del codice sorgente". – Glen

+3

Precisamente - molte differenze - probabilmente su ogni altra linea, se si usano metodi brevi. Ciò renderà le differenze inutili - non sareste in grado di individuare i cambiamenti reali dal rumore causato dalla riformattazione. –

+2

Beh, hai ragione. Non distruggerà completamente la cronologia delle tue revisioni. Distruggerà solo la tua capacità di confrontare il codice più recente interessato con il codice più vecchio attraverso il limite di modifica. Questo potrebbe non avere importanza per il tuo o il tuo progetto. – kmarsh

2

Il rientro del comando UNIX (http://en.wikipedia.org/wiki/Indent_(Unix)) (disponibile per PC da GNU) ha un milione di opzioni per personalizzare la riformattazione esattamente come desiderato.

+0

Per quanto ne so, la maggior parte dei comandi di rientro riecheggia sempre il codice sorgente, proprio come tutti gli altri strumenti. Conosci qualche modo per disattivarlo? Inoltre, il rientro generalmente non supporta il C++. – emk

+1

Se è possibile (1) indicarmi una versione di rientro con le opzioni necessarie e (2) spiegare tutto ciò che non è ovvio dal manuale, quindi accetterò questa risposta. Ma ho già passato mezz'ora a guardare il rientro GNU senza fortuna. – emk

1

Una mano piena di semplici regex non sarebbe una soluzione? Piace (\). ? \ N.? \ {) -> (\) \ {) per eliminare lo spazio tra una parentesi chiusa e una parentesi graffa aperta.

2
perl -ei '$/=undef;while(<>){s/}\s*?(\s*\/\/^[\r\n]*)?\r?\n\s*else/} else$1/gm;s/(\s*\/\/[^\r\n]*)?\r?\n\s*{/ {$1/gm;print;}' yoursourcefile.cpp 

Questo primo Mangles } <eol> <whitespace> else a } else, quindi rimuove fine linee da <eol> <whitespace> {.

Per applicare questo ad un albero dei sorgenti, utilizzare find e xargs: problemi

find . -name \*.cpp -print0 | xargs -0 perl -ei '$/=undef;while(<>){s/}\s*?(\s*\/\/^[\r\n]*)?\r?\n\s*else/} else$1/gm;s/(\s*\/\/[^\r\n]*)?\r?\n\s*{/ {$1/gm;print;}' 
0

ho affrontato come questo in passato da prima l'uso di alcuni strumenti come astyle di fare il 95% di quello che volevamo, e poi scrivere uno script Perl o Python sul risultato per finire il restante 5%. Provalo, è sempre una buona pratica conoscere le tue espressioni regolari. :)

Problemi correlati