Как изменить код C++ из пользовательского ввода

Вам нужна система преобразования программ. Это инструменты, которые обычно позволяют вам выражать изменения в исходном коде, написанные в шаблонах исходного кода, которые, по сути, говорят:

 if you see *this*, replace it by *that*

но работа с абстрактными синтаксическими деревьями, поэтому процесс сопоставления и замены гораздо более надежен, чем то, что вы получаете при взломе строк.

Такие инструменты должны иметь синтаксические анализаторы интересующего исходного языка. Исходный язык C++ делает это довольно сложным.

Clang подходит; в конце концов, он может анализировать C++. Объекты OP, он не может этого сделать без всего контекста среды. В той мере, в какой OP вводит (правильно сформированные) фрагменты программы (операторы и т. д.) в интерпретатор, Clang может [у меня нет большого опыта работы с этим] иметь проблемы с фокусировкой на том, что представляет собой фрагмент (оператор «выражение» объявление? ...). Наконец, Clang на самом деле не PTS; его процедуры модификации дерева не являются преобразованиями источника в источник. Это важно для удобства, но может не помешать OP использовать его; правило перезаписи синтаксиса поверхности удобно, но вы всегда можете заменить процедурный взлом дерева с большим усилием. Когда правил больше, чем несколько, это начинает иметь большое значение.

GCC с Melt квалифицируется так же, как и Clang. У меня сложилось впечатление, что Melt делает GCC в лучшем случае менее невыносимым для такой работы. YMMV.

Наш набор инструментов для реинжиниринга программного обеспечения DMS с его полный интерфейс C++14 [EDIT July 2018: C++17] абсолютно подходит. DMS использовался для выполнения массовых преобразований в крупномасштабных кодовых базах C++.

DMS может разбирать произвольные (правильно сформированные) фрагменты C++, не сообщая заранее, что такое синтаксическая категория, и возвращать AST надлежащего грамматического нетерминального типа, используя его механизм разбора шаблонов. [Вы можете получить несколько синтаксических анализов, например. двусмысленности, которые вы должны решить, как решить, см. 1004737">Почему C++ не может быть проанализирован с помощью синтаксического анализатора LR(1)? для более подробного обсуждения] Он может сделать это, не прибегая к «окружению», если вы готовы жить без раскрытия макросов во время синтаксического анализа, и настаивайте на том, чтобы директивы препроцессора (они тоже анализировались) были хорошо структурированы по отношению к фрагменту кода (#if foo{#endif не разрешено), но вряд ли это реальная проблема для фрагментов кода, введенных в интерактивном режиме.

Затем DMS предлагает полную процедурную библиотеку AST для манипулирования проанализированными деревьями (поиск, проверка, изменение, построение, замена), а затем может регенерировать поверхностный исходный код из модифицированного дерева, предоставляя текст OP для передачи интерпретатору.

В этом случае блестит то, что OP, вероятно, может написать большинство своих модификаций непосредственно в виде правил синтаксиса от источника к источнику. Для своего примера он может предоставить DMS правило перезаписи (непроверенное, но довольно близкое к правильному):

rule replace_Draw(A:primary,B1:expression,B2:expression):
        primary->primary
    "\A->Draw(\B1, \B2)"     -- pattern
rewrites to
    "MyFunc(\A, \B1, \B2)";  -- replacement

и DMS возьмет любой проанализированный AST, содержащий левосторонний шаблон "...Draw...", и заменит это поддерево правой частью после замены совпадений для A, B1 и B2. Кавычки являются метакавычками и используются, чтобы отличить текст C++ от текста правил синтаксиса; обратная косая черта — это метаэкранирование, используемое внутри метакавычек для обозначения метапеременных. Дополнительные сведения о том, что вы можете указать в синтаксисе правила, см. в правилах перезаписи DMS.

Попробуйте изменить заголовки, чтобы подавить метод, тогда при компиляции вы найдете ошибки и сможете заменить все ядро.

Поскольку у вас есть интерпретатор C++ (как корень CERN), я думаю, вы должны использовать компилятор для перехвата всего Draw, простой и чистый способ сделать это — объявить в заголовках метод Draw как частный, используя некоторые определения.

 class ItemWithDrawMehtod
 {
 ....
 public:
 #ifdef CATCHTHEMETHOD
     private:
 #endif
 void Draw(A,B);
 #ifdef CATCHTHEMETHOD
     public:
 #endif
 ....
 };

Затем скомпилируйте как:

 gcc -DCATCHTHEMETHOD=1 yourfilein.cpp

В случае, если пользователь хочет ввести в приложение сложные алгоритмы, я предлагаю интегрировать язык сценариев в приложение. Чтобы пользователь мог написать код [функцию/алгоритм определенным образом], чтобы приложение могло выполнить его в интерпретаторе и получить окончательные результаты. Например: Python, Perl, JS и т. д.

Поскольку вам нужен C++ в интерпретаторе, рекомендуется http://chaiscript.com/.

Что происходит, когда кто-то получает функцию-член Draw (auto draw = &A::Draw;), а затем начинает использовать draw? Вероятно, вы захотите, чтобы и в этом случае вызывалась та же улучшенная функциональность Draw. Таким образом, я думаю, мы можем сделать вывод, что вы действительно хотите заменить функцию-член Draw своей собственной функцией.

Поскольку кажется, что вы не в состоянии изменить класс, содержащий Draw напрямую, решением может быть создание собственного класса из A и переопределение там Draw. Тогда ваша проблема сводится к тому, чтобы ваши пользователи использовали ваш новый улучшенный класс.

Вы можете снова рассмотреть проблему автоматического преобразования использования класса A в ваш новый производный класс, но это все еще кажется довольно сложным без помощи полной реализации C++. Возможно, есть способ скрыть старое определение A и вместо этого представить свою замену под этим именем с помощью разумного использования файлов заголовков, но я не могу определить, так ли это, из того, что вы нам сказали.

Другая возможность может состоять в том, чтобы использовать некоторые хакерские действия динамического компоновщика с использованием LD_PRELOAD для замены функции Draw, которая вызывается во время выполнения.

В основном это можно сделать с помощью регулярных выражений.

Поскольку все, что появляется после Draw(, уже правильно отформатировано как параметры, вам не нужно полностью анализировать их для цели, которую вы изложили.

По сути, важная часть — это «SYMBOL->Draw(»

SYMBOL может быть любым выражением, которое разрешается в объект, который перегружает ->, или в указатель типа, который реализует Draw(...). Если вы уменьшите это до двух случаев, вы можете сократить синтаксический анализ.

В первом случае простое регулярное выражение, которое ищет любой допустимый символ C++, что-то вроде "[A-Za-z_][A-Za-z0-9_\.]", а также буквальное выражение "->Draw (". Это даст вам часть, которую необходимо переписать, поскольку код, следующий за этой частью, уже отформатирован как допустимые параметры C++.

Второй случай для сложных выражений, которые возвращают перегруженный объект или указатель. Это требует немного больше усилий, но короткая процедура синтаксического анализа для обхода сложного выражения в обратном направлении может быть написана на удивление легко, поскольку вам не нужно поддерживать блоки (блоки в C++ не могут возвращать объекты, поскольку определения лямбда-выражений не вызывают сами лямбды, а фактические вложенные блоки кода {...} не могут возвращать ничего непосредственно встроенного, что применимо здесь). Обратите внимание, что если выражение не заканчивается на ), то оно должно быть допустимым символом в этом контексте, поэтому, если вы найдете ) просто сопоставьте вложенный ) с ( и извлеките символ, предшествующий вложенному SYMBOL(...(.. .)...)->Draw() Это возможно с регулярными выражениями, но должно быть довольно просто и в обычном коде.

Как только у вас есть символ или выражение, замена тривиальна, начиная с

СИМВОЛ->Нарисовать(...

to

ВашаФункция(СИМВОЛ, ...

без необходимости иметь дело с дополнительными параметрами Draw().

Дополнительным преимуществом этой модели является то, что связанные вызовы функций анализируются бесплатно, поскольку вы можете рекурсивно перебирать код, например

A->Draw(B...)->Draw(C...)

Первая итерация идентифицирует первый A->Draw( и переписывает весь оператор как

YourFunction(A, B...)->Draw(C...)

который затем идентифицирует второй ->Draw с предшествующим ему выражением "YourFunction(A,...)->" и переписывает его как

YourFunction(YourFunction(A, B...), C...)

где B... и C... — правильно сформированные параметры C++, включая вложенные вызовы.

Не зная версии C++, которую поддерживает ваш интерпретатор, или типа кода, который вы будете переписывать, я действительно не могу предоставить какой-либо пример кода, который, вероятно, будет полезен.

Один из способов - загрузить пользовательский код в виде DLL (что-то вроде плагинов), таким образом, вам не нужно компилировать ваше фактическое приложение, будет скомпилирован только пользовательский код, и ваше приложение будет загружать его динамически.