consumer.cpp

Go to the documentation of this file.

#include "./consumer.h"
#include "./codefactory.h"
 
#include <clang/AST/ASTContext.h>
#include <clang/AST/DeclCXX.h>
#include <clang/AST/DeclGroup.h>
#include <clang/AST/DeclTemplate.h>
#include <clang/Basic/MacroBuilder.h>
#include <clang/Sema/Sema.h>
 
using namespace std;
 
namespace ReflectiveRapidJSON {
 
bool Consumer::shouldParseDecl(clang::Decl *declaration)
{
    const clang::SourceManager &sourceManager = m_compilerInstance.getSourceManager();
    return sourceManager.getFileID(sourceManager.getExpansionLoc(declaration->getSourceRange().getBegin())) == sourceManager.getMainFileID();
}
 
bool Consumer::HandleTopLevelDecl(clang::DeclGroupRef groupRefDecl)
{
    for (clang::Decl *decl : groupRefDecl) {
        if (clang::NamespaceDecl *namespaceDecl = llvm::dyn_cast<clang::NamespaceDecl>(decl)) {
            if (!shouldParseDecl(namespaceDecl)) {
                continue;
            }
        }
    }
    return clang::ASTConsumer::HandleTopLevelDecl(groupRefDecl);
}
 
void Consumer::HandleTranslationUnit(clang::ASTContext &context)
{
    m_visitor.TraverseDecl(context.getTranslationUnitDecl());
    m_factory.generate();
}
 
void DiagConsumer::BeginSourceFile(const clang::LangOptions &langOpts, const clang::Preprocessor *pp)
{
    m_proxy->BeginSourceFile(langOpts, pp);
}
 
void DiagConsumer::clear()
{
    m_proxy->clear();
}
 
void DiagConsumer::EndSourceFile()
{
    m_proxy->EndSourceFile();
}
 
#if CLANG_VERSION_MAJOR <= 22
void DiagConsumer::finish()
{
    m_proxy->finish();
}
#endif

void DiagConsumer::HandleDiagnostic(clang::DiagnosticsEngine::Level diagLevel, const clang::Diagnostic &info)
{
    bool shouldReset = false;
    if (m_errorResilient) {
        const auto diagId = info.getID();
        const auto category = info.getDiags()->getDiagnosticIDs()->getCategoryNumberForDiag(diagId);
 
        if (diagLevel >= clang::DiagnosticsEngine::Error) {
            if (category == 2 /* 2 means "Semantic Issue" */) {
                if (!m_realErrorCount) {
                    shouldReset = true;
                }
                diagLevel = clang::DiagnosticsEngine::Warning;
            } else {
                ++m_realErrorCount;
            }
        }
    }
 
    DiagnosticConsumer::HandleDiagnostic(diagLevel, info);
    m_proxy->HandleDiagnostic(diagLevel, info);
 
    if (shouldReset) {
        // FIXME: is there another way to ignore errors?
        const_cast<clang::DiagnosticsEngine *>(info.getDiags())->Reset();
    }
}
 
} // namespace ReflectiveRapidJSON