Jestem w trakcie refaktoryzacji bardzo dużej ilości kodu, głównie C ++, aby usunąć pewną liczbę tymczasowych kontroli konfiguracji, które zostały trwale ustawione na podane wartości. Na przykład miałbym następujący kod:

<code>#include <value1.h>
#include <value2.h>
#include <value3.h>

...

if ( value1() )
{
    // do something
}

bool b = value2();

if ( b && anotherCondition )
{
    // do more stuff
}

if ( value3() < 10 )
{
    // more stuff again
}
</code>

gdzie wywołania wartości zwracają wartość bool lub int. Ponieważ znam wartości, które te wywołania zawsze zwracają, zrobiłem pewne podstawienie wyrażeń regularnych, aby rozwinąć wywołania do ich normalnych wartości:

<code>// where:
//   value1() == true
//   value2() == false
//   value3() == 4

// TODO: Remove expanded config (value1)
if ( true )
{
    // do something
}

// TODO: Remove expanded config (value2)
bool b = false;

if ( b && anotherCondition )
{
    // do more stuff
}

// TODO: Remove expanded config (value3)
if ( 4 < 10 )
{
    // more stuff again
}
</code>

Zauważ, że chociaż wartości są stałe, nie są ustawiane w czasie kompilacji, ale są odczytywane z pamięci współużytkowanej, więc kompilator nie optymalizuje obecnie niczego poza scenami.

Chociaż wynikowy kod wygląda trochę głupkowato, to podejście oparte na wyrażeniach regularnych osiąga wiele z tego, czego chcę, ponieważ jest proste w zastosowaniu i usuwa zależność od wywołań, nie zmieniając jednocześnie zachowania kodu, a także prawdopodobne jest, że kompilator może zoptymalizować wiele z tego wiedząc, że bloku nigdy nie można wywołać lub że sprawdzanie zawsze zwróci prawdę. To także sprawia, że ​​dość łatwo (zwłaszcza podczas porównywania z kontrolą wersji) zobaczyć, co się zmieniło, i podjąć ostatni krok w celu oczyszczenia, więc powyższy kod w końcu wygląda następująco:

<code>// do something

// DONT do more stuff (b being false always prevented this)

// more stuff again
</code>

Problem polega na tym, że mam setki (być może tysiące) zmian, które należy wprowadzić, aby przejść z drugiego, poprawnego, ale niemądrego etapu, aby dostać się do końcowego oczyszczonego kodu.

Zastanawiałem się, czy ktoś nie wiedział o narzędziu do refaktoryzacji, które mogłoby obsłużyć to lub o jakichkolwiek technikach, które mógłbym zastosować. Głównym problemem jest to, że składnia C ++ sprawia, że ​​pełne rozszerzenie lub wyeliminowanie jest dość trudne do osiągnięcia, a powyższy kod zawiera wiele permutacji. Wydaje mi się, że prawie potrzebuję kompilatora, aby poradzić sobie ze zmiennością składni, którą musiałbym omówić.

Wiem, że pojawiły się podobne pytania, ale nie mogę znaleźć żadnego takiego wymagania i zastanawiałem się, czy pojawiły się jakieś narzędzia lub procedury od czasu ich zapytania?