Компиляция C++ с Clang API

#include <clang/Frontend/CompilerInstance.h>
#include <clang/Frontend/TextDiagnosticPrinter.h>
#include <clang/Basic/DiagnosticOptions.h>
#include <llvm/Support/Host.h>
 
using namespace clang;
 
int main() {
    // Создаем экземпляр компилятора
    CompilerInstance CI;
    
    // Настраиваем диагностику
    DiagnosticOptions *diagOpts = new DiagnosticOptions();
    TextDiagnosticPrinter *diagClient = 
        new TextDiagnosticPrinter(llvm::errs(), diagOpts);
    CI.createDiagnostics(diagClient);
    
    // Создаем менеджеры файлов и исходников
    CI.createFileManager();
    CI.createSourceManager(CI.getFileManager());
    
    // Устанавливаем целевую платформу
    std::shared_ptr<TargetOptions> targetOpts = std::make_shared<TargetOptions>();
    targetOpts->Triple = llvm::sys::getDefaultTargetTriple();
    CI.setTarget(TargetInfo::CreateTargetInfo(
        CI.getDiagnostics(), targetOpts));
        
    // Инициализируем препроцессор
    CI.createPreprocessor(TranslationUnitKind::TU_Complete);
    
    // Инициализируем контекст AST
    CI.createASTContext();
    
    // Теперь компилятор готов к работе!
    
    return 0;
}

#include <clang/CodeGen/CodeGenAction.h>
#include <clang/Driver/Compilation.h>
#include <clang/Driver/Driver.h>
#include <clang/Frontend/CompilerInstance.h>
#include <clang/Frontend/FrontendOptions.h>
#include <llvm/Support/TargetSelect.h>
#include <llvm/Support/VirtualFileSystem.h>
 
using namespace clang;
 
// Константа для целевой платформы
constexpr llvm::StringRef kTargetTriple = "x86_64-unknown-linux-gnu";
 
bool compileFile(const char *filename, const char *output) {
    // Инициализация LLVM
    llvm::InitializeNativeTarget();
    llvm::InitializeNativeTargetAsmParser();
    llvm::InitializeNativeTargetAsmPrinter();
    
    // Создаем объект диагностики
    IntrusiveRefCntPtr<DiagnosticOptions> diagOpts = new DiagnosticOptions();
    auto diagClient = new TextDiagnosticPrinter(llvm::errs(), &*diagOpts);
    IntrusiveRefCntPtr<DiagnosticIDs> diagID(new DiagnosticIDs());
    DiagnosticsEngine diags(diagID, &*diagOpts, diagClient);
    
    // Настраиваем driver для компиляции
    auto vfs = llvm::vfs::getRealFileSystem();
    driver::Driver drv("clang", kTargetTriple, diags, "compiler", vfs);
    drv.setCheckInputsExist(false);
    
    // Аргументы как будто из командной строки
    std::vector<const char *> args = {
        "clang", "-c", filename, "-o", output
    };
    
    // Создаем компиляцию
    std::unique_ptr<driver::Compilation> compilation(
        drv.BuildCompilation(args));
    
    // Получаем список команд (в нашем случае одна)
    auto &jobs = compilation->getJobs();
    if (jobs.size() != 1) {
        llvm::errs() << "Expected only one compilation job\n";
        return false;
    }
    
    // Извлекаем аргументы для CompilerInvocation
    auto &cmd = jobs.begin()->getArguments();
    
    // Настраиваем компилятор
    auto CI = std::make_unique<CompilerInstance>();
    CompilerInvocation::CreateFromArgs(
        CI->getInvocation(), cmd, diags);
    
    // Настраиваем вывод диагностики
    CI->createDiagnostics();
    
    if (!CI->hasDiagnostics()) {
        llvm::errs() << "Failed to create diagnostics\n";
        return false;
    }
    
    // Создаем действие для генерации объектного файла
    EmitObjAction codeGenAction;
    if (!CI->ExecuteAction(codeGenAction)) {
        llvm::errs() << "Failed to execute EmitObjAction\n";
        return false;
    }
    
    return true;
}
 
int main(int argc, char *argv[]) {
    if (argc != 3) {
        llvm::errs() << "Usage: " << argv[0] << " input.cpp output.o\n";
        return 1;
    }
    
    return compileFile(argv[1], argv[2]) ? 0 : 1;
}

class MyDiagnosticConsumer : public DiagnosticConsumer {
public:
  void HandleDiagnostic(DiagnosticsEngine::Level level,
                        const Diagnostic &info) override {
    // Получаем текст диагностического сообщения
    llvm::SmallString<256> message;
    info.FormatDiagnostic(message);
    
    // Получаем информацию о местоположении в коде
    SourceManager &SM = info.getSourceManager();
    SourceLocation loc = info.getLocation();
    
    // Преобразуем в строки имя файла, строку и столбец
    std::string filename = SM.getFilename(loc).str();
    unsigned line = SM.getSpellingLineNumber(loc);
    unsigned column = SM.getSpellingColumnNumber(loc);
    
    // Определяем уровень сообщения
    const char *levelStr = nullptr;
    switch (level) {
    case DiagnosticsEngine::Ignored: levelStr = "ignored"; break;
    case DiagnosticsEngine::Note:    levelStr = "note";    break;
    case DiagnosticsEngine::Remark:  levelStr = "remark";  break;
    case DiagnosticsEngine::Warning: levelStr = "warning"; break;
    case DiagnosticsEngine::Error:   levelStr = "error";   break;
    case DiagnosticsEngine::Fatal:   levelStr = "fatal";   break;
    }
    
    // Формируем и выводим сообщение в нужном формате
    std::cerr << filename << ":" << line << ":" << column 
              << ": " << levelStr << ": " << message.c_str() << "\n";
  }
};

// Создаём опции диагностики
auto diagOpts = new DiagnosticOptions();
diagOpts->ShowColors = true;  // Включаем цветной вывод
diagOpts->ShowCaret = true;   // Показывать указатель на позицию ошибки
diagOpts->TabStop = 4;        // Задаём ширину табуляции
 
// Создаём потребителя диагностики с кастомным форматированием
auto diagConsumer = new MyDiagnosticConsumer();
 
// Создаём движок диагностики
auto diagEngine = new DiagnosticsEngine(
    diagIDs,    // ID диагностических сообщений
    diagOpts,   // Настройки форматирования
    diagConsumer, // Наш обработчик
    false       // Владеет ли движок обработчиком
);
 
// Передаём движок диагностики компилятору
CI.setDiagnostics(diagEngine);

// Создаём опции для целевой платформы
std::shared_ptr<TargetOptions> targetOpts = std::make_shared<TargetOptions>();
targetOpts->Triple = llvm::sys::getDefaultTargetTriple(); // x86_64-unknown-linux-gnu
targetOpts->CPU = "skylake";  // Конкретный процессор
targetOpts->FeaturesAsWritten.push_back("+avx2"); // Включаем расширение AVX2
 
// Создаём и устанавливаем TargetInfo
TargetInfo *targetInfo = TargetInfo::CreateTargetInfo(
    CI.getDiagnostics(), targetOpts);
CI.setTarget(targetInfo);

// Для x86 архитектуры
LLVMInitializeX86AsmParser();
LLVMInitializeX86AsmPrinter();
LLVMInitializeX86Target();
LLVMInitializeX86TargetInfo();
LLVMInitializeX86TargetMC();
 
// Для ARM
LLVMInitializeARMAsmParser();
LLVMInitializeARMAsmPrinter();
LLVMInitializeARMTarget();
LLVMInitializeARMTargetInfo();
LLVMInitializeARMTargetMC();
 
// Или просто инициализировать все поддерживаемые цели
LLVMInitializeAllTargets();
LLVMInitializeAllTargetInfos();
LLVMInitializeAllTargetMCs();
LLVMInitializeAllAsmParsers();
LLVMInitializeAllAsmPrinters();

auto &HSO = CI.getHeaderSearchOpts();
 
// Добавляем пути для поиска пользовательских заголовков
HSO.AddPath("/usr/include", frontend::Angled, false, false);
HSO.AddPath("/usr/local/include", frontend::Angled, false, false);
HSO.AddPath("./include", frontend::Angled, false, false);
 
// Для заголовков стандартной библиотеки
HSO.AddPath("/usr/lib/clang/15.0.0/include", frontend::System, false, false);
 
// Задаём путь к стандартной библиотеке C++
HSO.AddPath("/usr/include/c++/11", frontend::CXXSystem, false, false);

// Создаём базовую виртуальную файловую систему
llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> overlayFS =
    new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem());
 
// Добавляем новый слой для хранения виртуальных файлов
llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> memFS =
    new llvm::vfs::InMemoryFileSystem;
overlayFS->pushOverlay(memFS);
 
// Добавляем виртуальный файл
const char *code = "int main() { return 0; }";
memFS->addFile("test.cpp", 0, llvm::MemoryBuffer::getMemBuffer(code));
 
// Создаём менеджер файлов с нашей файловой системой
CI.setFileManager(new FileManager(FileSystemOptions(), overlayFS));
CI.createSourceManager(CI.getFileManager());
 
// Теперь можно работать с виртуальным файлом
auto file = CI.getSourceManager().getFileManager().getFile("test.cpp");

// Предполагаем, что CompilerInstance CI уже настроен
 
// Создаём действие для парсинга и построения AST
ParseAST(CI.getPreprocessor(), &CI.getASTConsumer(),
         CI.getASTContext(), false, TU_Complete);
 
// Теперь у нас есть доступ к построенному AST через ASTContext
ASTContext &astContext = CI.getASTContext();

// Создаём кастомное действие для работы с AST
class MyASTConsumer : public ASTConsumer {
public:
    bool HandleTopLevelDecl(DeclGroupRef DG) override {
        for (auto *D : DG) {
            // Обрабатываем каждое объявление верхнего уровня
            D->dump(); // Для отладки: вывод информации о декларации
            
            // Если это функция, можем работать с её телом
            if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
                if (FD->hasBody()) {
                    Stmt *Body = FD->getBody();
                    // Анализируем тело функции
                }
            }
        }
        return true;
    }
};
 
// Создаём и выполняем действие
std::unique_ptr<ASTConsumer> Consumer = std::make_unique<MyASTConsumer>();
ParseAST(CI.getPreprocessor(), Consumer.get(), CI.getASTContext());

class MyASTVisitor : public RecursiveASTVisitor<MyASTVisitor> {
public:
    bool VisitFunctionDecl(FunctionDecl *FD) {
        // Вызывается для каждого объявления функции
        llvm::outs() << "Найдена функция: " << FD->getNameAsString() << "\n";
        return true; // true продолжает обход, false — прерывает
    }
    
    bool VisitCXXRecordDecl(CXXRecordDecl *RD) {
        // Вызывается для каждого объявления класса/структуры
        if (RD->isClass())
            llvm::outs() << "Найден класс: " << RD->getNameAsString() << "\n";
        return true;
    }
};
 
// Использование:
MyASTVisitor Visitor;
Visitor.TraverseDecl(Context.getTranslationUnitDecl());

// Создаём действие для генерации LLVM IR
EmitLLVMAction Action;
if (CI.ExecuteAction(Action)) {
    // Получаем сгенерированный модуль LLVM
    std::unique_ptr<llvm::Module> Module = Action.takeModule();
    
    // Можем манипулировать этим модулем, например, вывести его
    Module->print(llvm::outs(), nullptr);
}

// Для генерации объектного файла
EmitObjAction ObjAction;
if (CI.ExecuteAction(ObjAction)) {
    // Объектный файл уже записан в указанный выходной файл
}
 
// Или для генерации ассемблерного кода
EmitAssemblyAction AsmAction;
if (CI.ExecuteAction(AsmAction)) {
    // Ассемблерный код записан в выходной файл
}

// Настройка уровня оптимизации
CI.getCodeGenOpts().OptimizationLevel = 2; // Эквивалент -O2
 
// Включение/выключение конкретных оптимизаций
CI.getCodeGenOpts().DisableGCov = true;
CI.getCodeGenOpts().OptimizeSize = true; // Оптимизировать под размер, не скорость
 
// Более тонкая настройка через опции LLVM
auto &FPO = CI.getCodeGenOpts().FunctionPasses;
FPO.push_back("loop-unroll"); // Добавляем проход развертывания циклов

// Предполагаем, что у нас есть llvm::Module *M
 
// Создаём менеджер проходов
llvm::legacy::PassManager PM;
 
// Добавляем проходы оптимизации
PM.add(llvm::createInstructionCombiningPass());
PM.add(llvm::createReassociatePass());
PM.add(llvm::createGVNPass());
PM.add(llvm::createCFGSimplificationPass());
 
// Выполняем оптимизацию
PM.run(*M);

// Получаем контекст AST
ASTContext &Context = CI.getASTContext();
 
// Получаем список всех деклараций в единице трансляции
TranslationUnitDecl *TUD = Context.getTranslationUnitDecl();
 
// Обходим все декларации верхнего уровня
for (auto *D : TUD->decls()) {
    // Если это декларация функции
    if (auto *FD = dyn_cast<FunctionDecl>(D)) {
        // Выводим имя функции
        llvm::outs() << "Функция: " << FD->getNameAsString() << "\n";
        
        // Получаем тип функции
        QualType FT = FD->getType();
        llvm::outs() << "  Тип: " << FT.getAsString() << "\n";
        
        // Получаем местоположение в исходнике
        SourceManager &SM = Context.getSourceManager();
        SourceLocation Loc = FD->getLocation();
        llvm::outs() << "  В файле: " << SM.getFilename(Loc) 
                     << " строка: " << SM.getSpellingLineNumber(Loc) 
                     << "\n";
        
        // Если у функции есть тело, анализируем его
        if (FD->hasBody()) {
            Stmt *Body = FD->getBody();
            
            // Ищем все return-выражения
            struct ReturnFinder : public RecursiveASTVisitor<ReturnFinder> {
                bool VisitReturnStmt(ReturnStmt *RS) {
                    llvm::outs() << "    Найден return\n";
                    return true;
                }
            } Finder;
            
            Finder.TraverseStmt(Body);
        }
    }
}

// Работа с форматом отладочной информации DWARF
CI.getCodeGenOpts().setDebugInfo(codegenoptions::FullDebugInfo);
 
// Интеграция с системой профилирования
CI.getCodeGenOpts().ProfileInstrGenerate = true;
CI.getCodeGenOpts().InstrProfileInput = "/path/to/profile.profdata";
 
// Использование санитайзеров
CI.getDiagnosticOpts().Warnings.push_back("address");
CI.getDiagnosticOpts().Warnings.push_back("undefined");
 
// Интеграция с системой связывания (линковки)
CI.getCodeGenOpts().RelocationModel = llvm::Reloc::PIC_;
CI.getCodeGenOpts().CodeModel = llvm::CodeModel::Small;

// Проверка совместимости типов
bool AreTypesCompatible(QualType T1, QualType T2, ASTContext &Context) {
    return Context.hasSameType(T1, T2);
}
 
// Вычисление общего типа выражений (например, для бинарных операторов)
QualType GetCommonType(Expr *E1, Expr *E2, ASTContext &Context) {
    return Context.getCommonType(E1->getType(), E2->getType());
}
 
// Проверка преобразования типов
bool CanConvert(QualType FromType, QualType ToType, ASTContext &Context) {
    return !Context.hasSameType(FromType, ToType) && 
           Context.canConvertType(FromType, ToType);
}
 
// Проверка на перегрузку функций
void AnalyzeOverload(ASTContext &Context, FunctionDecl *FD) {
    // Получаем декларации с тем же именем
    DeclarationNameInfo DNI(FD->getDeclName(), FD->getLocation());
    LookupResult Result(Context, DNI, Sema::LookupOrdinaryName);
    
    if (Result.isAmbiguous()) {
        llvm::outs() << "Найдена перегруженная функция\n";
        // Анализируем возможные перегрузки
    }
}

// Создаем хранилище для предыдущих результатов компиляции
class CompilationCache {
private:
    std::unordered_map<std::string, std::unique_ptr<ASTUnit>> astCache;
    std::unordered_map<std::string, time_t> fileTimestamps;
 
public:
    // Проверяем, изменился ли файл с момента последней компиляции
    bool hasChanged(const std::string& filename) {
        struct stat statBuf;
        if (stat(filename.c_str(), &statBuf) != 0) {
            return true; // Файл не существует или ошибка доступа
        }
        
        auto it = fileTimestamps.find(filename);
        if (it == fileTimestamps.end()) {
            return true; // Первая компиляция этого файла
        }
        
        return it->second < statBuf.st_mtime;
    }
    
    // Получаем кэшированный AST или nullptr, если кэша нет
    ASTUnit* getAST(const std::string& filename) {
        auto it = astCache.find(filename);
        if (it != astCache.end() && !hasChanged(filename)) {
            return it->second.get();
        }
        return nullptr;
    }
    
    // Сохраняем AST в кэш
    void cacheAST(const std::string& filename, std::unique_ptr<ASTUnit> ast) {
        struct stat statBuf;
        if (stat(filename.c_str(), &statBuf) == 0) {
            fileTimestamps[filename] = statBuf.st_mtime;
        }
        astCache[filename] = std::move(ast);
    }
};

// Настраиваем опции для работы с PCH
CI.getPreprocessorOpts().ImplicitPCHInclude = "cached_headers.pch";
CI.getPreprocessorOpts().DisablePCHValidation = false;
 
// Генерируем PCH для последующего использования
GeneratePCHAction PCHAction;
CI.ExecuteAction(PCHAction);
 
// Позже используем эти заголовки
CI.getPreprocessorOpts().ImplicitPCHInclude = "cached_headers.pch";

// Настройка использования модулей
CI.getLangOpts().Modules = true;
CI.getHeaderSearchOpts().ModuleCachePath = "/path/to/module/cache";
 
// Указываем модульный файл для импорта
CI.getPreprocessorOpts().ImplicitModuleMaps.push_back("module.modulemap");

class FunctionCallVisitor : public RecursiveASTVisitor<FunctionCallVisitor> {
private:
    ASTContext *Context;
    std::unordered_map<std::string, int> callCounts;
    
public:
    explicit FunctionCallVisitor(ASTContext *Context) : Context(Context) {}
    
    // Анализируем вызовы функций
    bool VisitCallExpr(CallExpr *CallE) {
        if (FunctionDecl *FD = CallE->getDirectCallee()) {
            std::string Name = FD->getQualifiedNameAsString();
            callCounts[Name]++;
            
            // Проверяем аргументы вызова
            unsigned NumArgs = CallE->getNumArgs();
            for (unsigned i = 0; i < NumArgs; ++i) {
                Expr *Arg = CallE->getArg(i);
                QualType T = Arg->getType();
                
                // Предупреждаем о передаче сырых указателей в функции
                if (T->isPointerType() && !T->isAnyCharacterType()) {
                    SourceManager &SM = Context->getSourceManager();
                    SourceLocation Loc = Arg->getExprLoc();
                    llvm::errs() << "Предупреждение: сырой указатель передан в функцию "
                                << Name << " в "
                                << SM.getFilename(Loc) << ":"
                                << SM.getSpellingLineNumber(Loc) << "\n";
                }
            }
        }
        return true;
    }
    
    // Анализируем предложения с условиями
    bool VisitIfStmt(IfStmt *If) {
        // Проверяем условие на сложность
        Expr *Cond = If->getCond();
        int complexity = computeExpressionComplexity(Cond);
        if (complexity > 5) {
            SourceManager &SM = Context->getSourceManager();
            SourceLocation Loc = Cond->getExprLoc();
            llvm::errs() << "Предупреждение: сложное условие (сложность " 
                        << complexity << ") в "
                        << SM.getFilename(Loc) << ":"
                        << SM.getSpellingLineNumber(Loc) << "\n";
        }
        return true;
    }
    
    // Вспомогательная функция для оценки сложности выражения
    int computeExpressionComplexity(Expr *E) {
        if (!E) return 0;
        
        // Просто для примера: считаем количество операторов
        if (isa<BinaryOperator>(E) || isa<UnaryOperator>(E)) {
            int base = 1;
            if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
                base += computeExpressionComplexity(BO->getLHS());
                base += computeExpressionComplexity(BO->getRHS());
            } else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
                base += computeExpressionComplexity(UO->getSubExpr());
            }
            return base;
        }
        
        return 1; // Базовая сложность для других типов выражений
    }
    
    // Получение статистики вызовов функций
    const std::unordered_map<std::string, int>& getCallCounts() const {
        return callCounts;
    }
};

// Предполагаем, что у нас есть TranslationUnitDecl *TUD
FunctionCallVisitor Visitor(Context);
Visitor.TraverseDecl(TUD);
 
// Выводим статистику вызовов функций
auto Counts = Visitor.getCallCounts();
for (const auto &Pair : Counts) {
    llvm::outs() << "Функция " << Pair.first << " вызвана " 
                << Pair.second << " раз\n";
}

// Пример замены всех printf на std::cout
class PrintfRewriter : public MatchFinder::MatchCallback {
private:
    Rewriter &Rewrite;
    
public:
    explicit PrintfRewriter(Rewriter &Rewrite) : Rewrite(Rewrite) {}
    
    virtual void run(const MatchFinder::MatchResult &Result) {
        // Находим вызов printf
        const CallExpr *Call = Result.Nodes.getNodeAs<CallExpr>("printf");
        if (!Call)
            return;
        
        // Получаем текстовый аргумент формата
        const StringLiteral *FormatStr = nullptr;
        if (Call->getNumArgs() >= 1)
            FormatStr = dyn_cast<StringLiteral>(Call->getArg(0)->IgnoreParenImpCasts());
        if (!FormatStr)
            return;
            
        // Строим замену
        std::string Replacement = "std::cout << ";
        llvm::StringRef Format = FormatStr->getString();
        
        // Очень упрощенная обработка формата - только для демонстрации
        // В реальности нужен полноценный парсер форматных строк printf
        unsigned ArgIndex = 1;
        for (size_t i = 0; i < Format.size(); ++i) {
            if (Format[i] != '%') {
                if (Format[i] == '\n')
                    Replacement += "std::endl";
                else
                    Replacement.push_back(Format[i]);
                continue;
            }
            
            // Пропускаем спецификаторы формата
            ++i;
            while (i < Format.size() && 
                  (isdigit(Format[i]) || Format[i] == '.' || 
                   Format[i] == '+' || Format[i] == '-' || 
                   Format[i] == ' ' || Format[i] == '#' || 
                   Format[i] == 'l' || Format[i] == 'h'))
                ++i;
                
            if (i >= Format.size())
                break;
                
            // Вставляем аргумент
            if (ArgIndex < Call->getNumArgs()) {
                // Получаем текст аргумента
                SourceRange ArgRange = Call->getArg(ArgIndex)->getSourceRange();
                Replacement += " << ";
                Replacement += Rewrite.getRewrittenText(CharSourceRange::getTokenRange(ArgRange));
                ++ArgIndex;
            }
        }
        
        // Выполняем замену
        SourceRange CallRange = Call->getSourceRange();
        Rewrite.ReplaceText(
            CharSourceRange::getTokenRange(CallRange),
            Replacement);
    }
};

// Создаем Rewriter для модификации исходного кода
Rewriter TheRewriter;
TheRewriter.setSourceMgr(Context.getSourceManager(), Context.getLangOpts());
 
// Настраиваем поиск совпадений с нашим паттерном
MatchFinder Finder;
PrintfRewriter Callback(TheRewriter);
 
// Ищем вызовы printf
auto PrintfMatcher = callExpr(hasName("printf")).bind("printf");
Finder.addMatcher(PrintfMatcher, &Callback);
 
// Запускаем поиск и трансформацию
Finder.matchAST(Context);
 
// Применяем изменения и сохраняем результат
const RewriteBuffer *Buffer = TheRewriter.getRewriteBufferFor(
    Context.getSourceManager().getMainFileID());
llvm::outs() << std::string(Buffer->begin(), Buffer->end());

#include <clang/CodeGen/CodeGenAction.h>
#include <clang/Driver/Compilation.h>
#include <clang/Driver/Driver.h>
#include <clang/Frontend/CompilerInstance.h>
#include <clang/Frontend/FrontendOptions.h>
#include <llvm/Config/llvm-config.h>
#include <llvm/Support/TargetSelect.h>
#include <llvm/Support/VirtualFileSystem.h>
 
using namespace clang;
 
constexpr llvm::StringRef kTargetTriple = "x86_64-unknown-linux-gnu";
 
namespace {
struct DiagsSaver : DiagnosticConsumer {
  std::string message;
  llvm::raw_string_ostream os{message};
 
  void HandleDiagnostic(DiagnosticsEngine::Level diagLevel, const Diagnostic &info) override {
    DiagnosticConsumer::HandleDiagnostic(diagLevel, info);
    const char *level;
    switch (diagLevel) {
    default:
      return;
    case DiagnosticsEngine::Note:
      level = "note";
      break;
    case DiagnosticsEngine::Warning:
      level = "warning";
      break;
    case DiagnosticsEngine::Error:
    case DiagnosticsEngine::Fatal:
      level = "error";
      break;
    }
 
    llvm::SmallString<256> msg;
    info.FormatDiagnostic(msg);
    auto &sm = info.getSourceManager();
    auto loc = info.getLocation();
    auto fileLoc = sm.getFileLoc(loc);
    os << sm.getFilename(fileLoc) << ':' << sm.getSpellingLineNumber(fileLoc)
       << ':' << sm.getSpellingColumnNumber(fileLoc) << ": " << level << ": "
       << msg << '\n';
    if (loc.isMacroID()) {
      loc = sm.getSpellingLoc(loc);
      os << sm.getFilename(loc) << ':' << sm.getSpellingLineNumber(loc) << ':'
         << sm.getSpellingColumnNumber(loc) << ": note: expanded from macro\n";
    }
  }
};
}
 
static std::pair<bool, std::string> compile(int argc, char *argv[]) {
  auto fs = llvm::vfs::getRealFileSystem();
  DiagsSaver dc;
  std::vector<const char *> args{"clang"};
  args.insert(args.end(), argv + 1, argv + argc);
  auto diags = CompilerInstance::createDiagnostics(
#if LLVM_VERSION_MAJOR >= 20
      *fs,
#endif
      new DiagnosticOptions, &dc, false);
  driver::Driver d(args[0], kTargetTriple, *diags, "cc", fs);
  d.setCheckInputsExist(false);
  std::unique_ptr<driver::Compilation> comp(d.BuildCompilation(args));
  const auto &jobs = comp->getJobs();
  if (jobs.size() != 1)
    return {false, "only support one job"};
  const llvm::opt::ArgStringList &ccArgs = jobs.begin()->getArguments();
 
  auto invoc = std::make_unique<CompilerInvocation>();
  CompilerInvocation::CreateFromArgs(*invoc, ccArgs, *diags);
  auto ci = std::make_unique<CompilerInstance>();
  ci->setInvocation(std::move(invoc));
  ci->createDiagnostics(*fs, &dc, false);
  // Отключаем CompilerInstance::printDiagnosticStats, чтобы скрыть сообщение "2 warnings generated."
  ci->getDiagnostics().getDiagnosticOptions().ShowCarets = false;
  ci->createFileManager(fs);
  ci->createSourceManager(ci->getFileManager());
 
  // Clang вызывает BuryPointer для внутренних элементов AST и CodeGen, таких как TargetMachine.
  // Это приведет к утечкам памяти, если [INLINE]compile[/INLINE] выполняется много раз.
  ci->getCodeGenOpts().DisableFree = false;
  ci->getFrontendOpts().DisableFree = false;
 
  LLVMInitializeX86AsmParser();
  LLVMInitializeX86AsmPrinter();
  LLVMInitializeX86Target();
  LLVMInitializeX86TargetInfo();
  LLVMInitializeX86TargetMC();
 
  switch (ci->getFrontendOpts().ProgramAction) {
  case frontend::ActionKind::EmitObj: {
    EmitObjAction action;
    ci->ExecuteAction(action);
  } break;
  case frontend::ActionKind::EmitAssembly: {
    EmitAssemblyAction action;
    ci->ExecuteAction(action);
  } break;
  default:
    return {false, "unhandled action"};
  }
  return {true, std::move(dc.message)};
}
 
int main(int argc, char *argv[]) {
  auto [ok, err] = compile(argc, argv);
  llvm::errs() << err;
}

#include <clang/Tooling/CompilationDatabase.h>
#include <clang/Tooling/Tooling.h>
 
// Функция для анализа целого проекта
void analyzeProject(const std::string &buildPath) {
  std::string errorMsg;
  // Загружаем базу данных компиляции из compile_commands.json
  auto compDb = clang::tooling::CompilationDatabase::loadFromDirectory(buildPath, errorMsg);
  if (!compDb) {
    llvm::errs() << "Error loading compilation database: " << errorMsg << "\n";
    return;
  }
 
  // Получаем все команды компиляции для файлов проекта
  auto allFiles = compDb->getAllFiles();
  
  // Создаём инструмент для анализа
  clang::tooling::ClangTool Tool(*compDb, allFiles);
  
  // Настраиваем обработчик для AST
  struct MyASTConsumer : clang::ASTConsumer {
    bool HandleTopLevelDecl(clang::DeclGroupRef DG) override {
      // Обработка объявлений верхнего уровня
      for (auto D : DG) {
        // Например, подсчёт функций в проекте
        if (auto FD = llvm::dyn_cast<clang::FunctionDecl>(D)) {
          llvm::outs() << "Found function: " << FD->getNameAsString() << "\n";
        }
      }
      return true;
    }
  };
  
  // Создаём фронтенд-действие для анализа
  class MyFrontendAction : public clang::ASTFrontendAction {
  protected:
    std::unique_ptr<clang::ASTConsumer> 
    CreateASTConsumer(clang::CompilerInstance &CI, llvm::StringRef File) override {
      return std::make_unique<MyASTConsumer>();
    }
  };
  
  // Запускаем анализ всех файлов
  Tool.run(clang::tooling::newFrontendActionFactory<MyFrontendAction>().get());
}

class MemoryLeakChecker : public RecursiveASTVisitor<MemoryLeakChecker> {
private:
  ASTContext *Context;
  std::vector<std::pair<SourceLocation, std::string>> Allocations;
  std::vector<SourceLocation> Deallocations;
 
public:
  explicit MemoryLeakChecker(ASTContext *Context) : Context(Context) {}
 
  // Проверяем вызовы функций выделения памяти
  bool VisitCallExpr(CallExpr *Call) {
    if (FunctionDecl *FD = Call->getDirectCallee()) {
      std::string Name = FD->getNameAsString();
      
      // Отслеживаем выделения памяти
      if (Name == "malloc" || Name == "calloc" || Name == "realloc") {
        Allocations.push_back({Call->getBeginLoc(), Name});
      }
      // Отслеживаем освобождения памяти
      else if (Name == "free") {
        Deallocations.push_back(Call->getBeginLoc());
      }
    }
    return true;
  }
 
  // Проверяем операторы new
  bool VisitCXXNewExpr(CXXNewExpr *NewExpr) {
    Allocations.push_back({NewExpr->getBeginLoc(), "new"});
    return true;
  }
 
  // Проверяем операторы delete
  bool VisitCXXDeleteExpr(CXXDeleteExpr *DeleteExpr) {
    Deallocations.push_back(DeleteExpr->getBeginLoc());
    return true;
  }
 
  // Вывод результатов анализа
  void reportFindings() {
    SourceManager &SM = Context->getSourceManager();
    
    llvm::outs() << "Найдено выделений памяти: " << Allocations.size() << "\n";
    llvm::outs() << "Найдено освобождений памяти: " << Deallocations.size() << "\n\n";
    
    if (Allocations.size() > Deallocations.size()) {
      llvm::outs() << "Потенциальные утечки памяти:\n";
      for (const auto &Alloc : Allocations) {
        llvm::outs() << SM.getFilename(Alloc.first) << ":" 
                    << SM.getSpellingLineNumber(Alloc.first) << " - " 
                    << Alloc.second << "\n";
      }
    }
  }
};

class MemoryLeakConsumer : public ASTConsumer {
private:
  MemoryLeakChecker Checker;
 
public:
  explicit MemoryLeakConsumer(ASTContext *Context) : Checker(Context) {}
 
  void HandleTranslationUnit(ASTContext &Context) override {
    Checker.TraverseDecl(Context.getTranslationUnitDecl());
    Checker.reportFindings();
  }
};
 
class MemoryLeakAction : public PluginASTAction {
protected:
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, 
                                                 StringRef file) override {
    return std::make_unique<MemoryLeakConsumer>(&CI.getASTContext());
  }
 
  bool ParseArgs(const CompilerInstance &CI,
                 const std::vector<std::string> &args) override {
    return true;
  }
};

// Класс для инструментирования вызовов функций
class CallInstrumenter : public RecursiveASTVisitor<CallInstrumenter> {
private:
  Rewriter &TheRewriter;
  ASTContext &Context;
 
public:
  CallInstrumenter(Rewriter &R, ASTContext &C) : TheRewriter(R), Context(C) {}
 
  // Инструментируем вызовы функций
  bool VisitCallExpr(CallExpr *Call) {
    if (FunctionDecl *FD = Call->getDirectCallee()) {
      std::string Name = FD->getNameAsString();
      
      // Инструментируем только определённые функции
      if (Name == "connect" || Name == "send" || Name == "recv") {
        // Вставляем вызов трассировки перед вызовом
        SourceLocation LocStart = Call->getBeginLoc();
        std::string FuncCall = "trace_call(\"" + Name + "\", ";
        
        // Добавляем параметры трассировки (упрощённо)
        for (unsigned i = 0; i < Call->getNumArgs(); ++i) {
          if (i > 0) FuncCall += ", ";
          // В реальности здесь должна быть более сложная логика
          FuncCall += "arg" + std::to_string(i);
        }
        FuncCall += ");\n";
        
        TheRewriter.InsertText(LocStart, FuncCall, true, true);
      }
    }
    return true;
  }
};

// Класс для добавления try-catch блоков
class ExceptionWrapper : public MatchFinder::MatchCallback {
private:
  Rewriter &TheRewriter;
 
public:
  explicit ExceptionWrapper(Rewriter &R) : TheRewriter(R) {}
 
  void run(const MatchFinder::MatchResult &Result) override {
    const CallExpr *Call = Result.Nodes.getNodeAs<CallExpr>("apiCall");
    const Stmt *Parent = Result.Nodes.getNodeAs<Stmt>("parent");
    if (!Call || !Parent || isa<CompoundStmt>(Parent)) 
      return;
 
    // Находим родительское выражение для определения места вставки
    SourceLocation LocStart = Parent->getBeginLoc();
    SourceLocation LocEnd = Parent->getEndLoc();
 
    // Получаем полный текст родительского выражения
    SourceManager &SM = *Result.SourceManager;
    CharSourceRange Range = CharSourceRange::getTokenRange(LocStart, LocEnd);
    StringRef Text = Lexer::getSourceText(Range, SM, Result.Context->getLangOpts());
 
    // Формируем новый код с обработкой исключений
    std::string Replacement = "try {\n  " + Text.str() + ";\n} catch (const std::exception& e) {\n"
                             "  log_error(\"API call failed\", e.what());\n}";
 
    // Выполняем замену
    TheRewriter.ReplaceText(Range, Replacement);
  }
};

// Настраиваем искомые паттерны
MatchFinder Finder;
ExceptionWrapper Callback(TheRewriter);
 
// Ищем вызовы API в не-compound выражениях
auto Matcher = 
  stmt(
    hasDescendant(
      callExpr(
        callee(
          functionDecl(hasAnyName("openConnection", "sendData", "receiveData"))
        )
      ).bind("apiCall")
    ),
    unless(hasAncestor(compoundStmt())),
    unless(hasParent(compoundStmt()))
  ).bind("parent");
 
Finder.addMatcher(Matcher, &Callback);

class CustomLinter : public RecursiveASTVisitor<CustomLinter> {
private:
  ASTContext *Context;
  DiagnosticsEngine &Diags;
  
  // Создаём ID для наших диагностик
  unsigned DiagIDNullptrDeref;
  unsigned DiagIDUninitVar;
  unsigned DiagIDDanglingSemi;
 
public:
  CustomLinter(ASTContext *Ctx, DiagnosticsEngine &DE) 
    : Context(Ctx), Diags(DE) {
    // Регистрируем диагностики
    DiagIDNullptrDeref = Diags.getCustomDiagID(
      DiagnosticsEngine::Warning,
      "Потенциальная разыменование nullptr");
      
    DiagIDUninitVar = Diags.getCustomDiagID(
      DiagnosticsEngine::Warning,
      "Использование неинициализированной переменной");
      
    DiagIDDanglingSemi = Diags.getCustomDiagID(
      DiagnosticsEngine::Warning,
      "Висячая точка с запятой может привести к неожиданному поведению");
  }
 
  // Проверка разыменования указателей
  bool VisitUnaryOperator(UnaryOperator *UO) {
    if (UO->getOpcode() == UO_Deref) {
      Expr *SubExpr = UO->getSubExpr()->IgnoreParenImpCasts();
      
      // Проверяем, не разыменовываем ли мы nullptr
      if (CXXNullPtrLiteralExpr *Nullptr = dyn_cast<CXXNullPtrLiteralExpr>(SubExpr)) {
        Diags.Report(UO->getOperatorLoc(), DiagIDNullptrDeref);
        return true;
      }
      
      // Проверяем, нет ли разыменования результата сравнения с nullptr
      if (BinaryOperator *BO = dyn_cast<BinaryOperator>(SubExpr)) {
        if (BO->getOpcode() == BO_EQ || BO->getOpcode() == BO_NE) {
          if (isa<CXXNullPtrLiteralExpr>(BO->getLHS()->IgnoreParenImpCasts()) ||
              isa<CXXNullPtrLiteralExpr>(BO->getRHS()->IgnoreParenImpCasts())) {
            Diags.Report(UO->getOperatorLoc(), DiagIDNullptrDeref);
          }
        }
      }
    }
    return true;
  }
 
  // Проверка инициализации переменных
  bool VisitDeclRefExpr(DeclRefExpr *DRE) {
    if (VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
      if (!VD->hasInit() && !VD->getType()->isReferenceType() && 
          !VD->hasGlobalStorage() && !VD->isParameterPack() &&
          !VD->isParameter()) {
        // Простейшая эвристика: если переменная используется в выражении присваивания справа от =, 
        // то это может быть неинициализированный доступ
        if (BinaryOperator *BO = dyn_cast<BinaryOperator>(DRE->getParent())) {
          if (BO->getOpcode() != BO_Assign || BO->getRHS() == DRE) {
            Diags.Report(DRE->getLocation(), DiagIDUninitVar);
          }
        } else {
          Diags.Report(DRE->getLocation(), DiagIDUninitVar);
        }
      }
    }
    return true;
  }
 
  // Проверка висячих точек с запятой
  bool VisitNullStmt(NullStmt *NS) {
    // Проверяем, не стоит ли полустатемент после if без else
    SourceLocation Loc = NS->getSemiLoc();
    if (Loc.isValid()) {
      // Проверяем, есть ли поблизости if
      const SourceManager &SM = Context->getSourceManager();
      FileID FID = SM.getFileID(Loc);
      const llvm::MemoryBuffer *Buffer = SM.getBuffer(FID);
      const char *Start = Buffer->getBufferStart();
      const char *Ptr = SM.getCharacterData(Loc);
      
      // Очень простая эвристика - ищем "if" в предыдущих 50 символах
      int LookBack = std::min(50, static_cast<int>(Ptr - Start));
      StringRef PrevText(Ptr - LookBack, LookBack);
      if (PrevText.find("if") != StringRef::npos && 
          PrevText.find("else") == StringRef::npos) {
        Diags.Report(Loc, DiagIDDanglingSemi);
      }
    }
    return true;
  }
};

class CustomLinterConsumer : public ASTConsumer {
private:
  CustomLinter Linter;
 
public:
  CustomLinterConsumer(ASTContext *Context, DiagnosticsEngine &Diags)
    : Linter(Context, Diags) {}
 
  void HandleTranslationUnit(ASTContext &Context) override {
    Linter.TraverseDecl(Context.getTranslationUnitDecl());
  }
};
 
class CustomLinterAction : public PluginASTAction {
protected:
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                StringRef file) override {
    return std::make_unique<CustomLinterConsumer>(
        &CI.getASTContext(), CI.getDiagnostics());
  }
 
  bool ParseArgs(const CompilerInstance &CI,
                const std::vector<std::string> &args) override {
    return true;
  }
};

// Проход для удаления неиспользуемого кода
class DeadCodeEliminator : public RecursiveASTVisitor<DeadCodeEliminator> {
private:
  Rewriter &TheRewriter;
  ASTContext *Context;
  std::unordered_set<const VarDecl*> UsedVars;
  std::vector<const VarDecl*> UnusedVars;
 
public:
  DeadCodeEliminator(Rewriter &R, ASTContext *Ctx) 
    : TheRewriter(R), Context(Ctx) {}
 
  // Собираем все использования переменных
  bool VisitDeclRefExpr(DeclRefExpr *DRE) {
    if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
      UsedVars.insert(VD);
    }
    return true;
  }
 
  // Находим все объявления переменных
  bool VisitVarDecl(VarDecl *VD) {
    // Игнорируем глобальные переменные, параметры функций и т.д.
    if (!VD->hasGlobalStorage() && !VD->isParameterPack() && 
        !VD->isParameter() && VD->getStorageDuration() == SD_Automatic) {
      // Запоминаем для последующей проверки
      if (UsedVars.find(VD) == UsedVars.end()) {
        UnusedVars.push_back(VD);
      }
    }
    return true;
  }
 
  // Удаляем неиспользуемые переменные
  void eliminateDeadCode() {
    for (const VarDecl *VD : UnusedVars) {
      // Проверяем, не использована ли переменная после того, как мы её обнаружили
      if (UsedVars.find(VD) == UsedVars.end()) {
        SourceRange Range = VD->getSourceRange();
        
        // Для простоты заменяем объявление на пустую строку
        // В реальности нужно аккуратно обрабатывать границы и комментарии
        TheRewriter.RemoveText(Range);
        llvm::outs() << "Удалена неиспользуемая переменная: " << 
                     VD->getNameAsString() << " в " << 
                     Context->getSourceManager().getFilename(VD->getLocation()) << "\n";
      }
    }
  }
};

class DeadCodeEliminationConsumer : public ASTConsumer {
private:
  DeadCodeEliminator Eliminator;
 
public:
  DeadCodeEliminationConsumer(Rewriter &TheRewriter, ASTContext *Context)
    : Eliminator(TheRewriter, Context) {}
 
  void HandleTranslationUnit(ASTContext &Context) override {
    Eliminator.TraverseDecl(Context.getTranslationUnitDecl());
    Eliminator.eliminateDeadCode();
  }
};

class LoggingDiagConsumer : public DiagnosticConsumer {
private:
    std::string logFilePath;
    std::ofstream logFile;
 
public:
    LoggingDiagConsumer(const std::string& path) : logFilePath(path) {
        logFile.open(logFilePath, std::ios::out | std::ios::app);
    }
 
    ~LoggingDiagConsumer() {
        if (logFile.is_open()) logFile.close();
    }
 
    void HandleDiagnostic(DiagnosticsEngine::Level level, const Diagnostic &info) override {
        // Стандартная обработка
        DiagnosticConsumer::HandleDiagnostic(level, info);
        
        // Сохраняем в лог с временной меткой
        llvm::SmallString<256> message;
        info.FormatDiagnostic(message);
        
        auto now = std::chrono::system_clock::now();
        std::time_t time = std::chrono::system_clock::to_time_t(now);
        
        logFile << "[" << std::ctime(&time) << "] ";
        logFile << DiagnosticLevelToString(level) << ": " << message.c_str() << "\n";
        logFile.flush();
    }
 
private:
    const char* DiagnosticLevelToString(DiagnosticsEngine::Level level) {
        switch (level) {
            case DiagnosticsEngine::Ignored: return "Ignored";
            case DiagnosticsEngine::Note:    return "Note";
            case DiagnosticsEngine::Warning: return "Warning";
            case DiagnosticsEngine::Error:   return "Error";
            case DiagnosticsEngine::Fatal:   return "Fatal";
            default:                         return "Unknown";
        }
    }
};

// Настраиваем компилятор
CompilerInstance CI;
// ... базовая настройка ...
 
// Проверяем инициализацию препроцессора
CI.createPreprocessor(TranslationUnitKind::TU_Complete);
if (!CI.hasPreprocessor()) {
    llvm::errs() << "Ошибка создания препроцессора\n";
    return 1;
}
 
// Проверяем инициализацию AST-контекста
CI.createASTContext();
if (!CI.hasASTContext()) {
    llvm::errs() << "Ошибка создания AST-контекста\n";
    return 1;
}
 
// и так далее...

// Вывод AST
Context.getTranslationUnitDecl()->dump();
 
// Вывод типа
Type->dump();
 
// Для более читаемого вывода можно направить его в форматированный поток
llvm::raw_string_ostream OS(OutputString);
Type->print(OS, Context.getPrintingPolicy());
OS.flush();

// Для чисто синтаксического анализа без семантики
CI.getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
 
// Для парсинга без полной сборки AST (если нужны только токены)
CI.getPreprocessorOpts().RetainRemappedFileBuffers = true;
Preprocessor &PP = CI.getPreprocessor();
 
// Ручной токенизация 
const FileEntry *File = CI.getFileManager().getFile("input.cpp");
SourceLocation Loc = CI.getSourceManager().getLocForStartOfFile(
    CI.getSourceManager().loadFileID(File, SourceLocation()));
    
PP.EnterSourceFile(CI.getSourceManager().getFileID(Loc), nullptr, Loc);
 
Token Tok;
do {
    PP.Lex(Tok);
    // Работаем с токеном...
} while (Tok.isNot(tok::eof));

// Генерация PCH
CI.getFrontendOpts().ProgramAction = frontend::GeneratePCH;
CI.getFrontendOpts().OutputFile = "headers.pch";
// ... настройка заголовков ...
 
// Использование PCH
CI.getPreprocessorOpts().ImplicitPCHInclude = "headers.pch";

class EfficientMatcher {
private:
    struct MatchResult {
        SourceLocation Loc;
        // Другие нужные данные
    };
    
    std::unordered_map<std::string, std::vector<MatchResult>> MatchCache;
    
public:
    void findMatches(ASTContext &Context, const std::string &PatternID) {
        // Проверяем кеш
        if (MatchCache.find(PatternID) != MatchCache.end()) {
            // Используем кешированные результаты
            for (const auto &Result : MatchCache[PatternID]) {
                // ...
            }
            return;
        }
        
        // Нет в кеше, выполняем поиск
        std::vector<MatchResult> Results;
        
        // Используем эффективные фильтры перед дорогим сопоставлением
        if (PatternID == "функции_с_malloc") {
            for (auto *D : Context.getTranslationUnitDecl()->decls()) {
                if (auto *FD = dyn_cast<FunctionDecl>(D)) {
                    // Быстрая предварительная проверка
                    if (!FD->hasBody()) continue;
                    
                    // Более дорогая проверка для подходящих кандидатов
                    // ...
                    
                    Results.push_back({FD->getLocation(), /* ... */});
                }
            }
        }
        
        // Сохраняем в кеш
        MatchCache[PatternID] = Results;
    }
};

// Включаем отслеживание времени
auto Timer = llvm::TimeRecord::getCurrentTime();
 
// Выполняем операцию
Context.getTranslationUnitDecl()->getASTContext().getSourceManager().getLocForStartOfFile(...);
 
// Вычисляем и выводим затраченное время
auto Elapsed = llvm::TimeRecord::getCurrentTime() - Timer;
llvm::outs() << "Операция заняла " << Elapsed.getProcessTime() << " секунд\n";

// Установка стандарта языка
auto &LO = CI.getLangOpts();
LO.CPlusPlus = true;
LO.CPlusPlus11 = true;
LO.CPlusPlus14 = true;
LO.CPlusPlus17 = true;
LO.CPlusPlus20 = true;
 
// Включение/выключение расширений
LO.GNUMode = true;      // Поддержка расширений GNU
LO.MicrosoftExt = false; // Отключение расширений Microsoft
 
// Включение/выключение гигиенических макросов (C99, C++11)
LO.C99 = true;
LO.Digraphs = true;

// Функция определения оптимального стандарта для файла
LangOptions detectBestLanguageOptions(const std::string &filename) {
    LangOptions LO;
    
    // Простая эвристика по расширению и содержимому
    if (filename.ends_with(".cpp") || filename.ends_with(".cxx") || filename.ends_with(".cc")) {
        // C++ файл
        LO.CPlusPlus = true;
        
        // Проверяем содержимое на использование возможностей C++11/14/17/20
        std::ifstream file(filename);
        std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
        
        if (content.find("auto") != std::string::npos || 
            content.find("nullptr") != std::string::npos) {
            LO.CPlusPlus11 = true;
        }
        
        // ... и так далее для других стандартов
    }
    
    return LO;
}

// Добавление путей поиска системных заголовочных файлов
HeaderSearchOptions &HSO = CI.getHeaderSearchOpts();
 
// Эмуляция поведения clang при поиске системных заголовков
// Это упрощенный пример; в реальности нужно получить правильные пути для конкретной системы
HSO.AddPath("/usr/include", frontend::System, false, false);
HSO.AddPath("/usr/local/include", frontend::System, false, false);