libAthena
/
athena
mirror of https://github.com/libAthena/athena.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
athena/atdna/main.cpp

1224 lines
54 KiB
C++
Raw Blame History

#include <cstdint>
#include <cstdio>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <clang/AST/ASTConsumer.h>
#include <clang/AST/DeclCXX.h>
#include <clang/AST/RecursiveASTVisitor.h>
#include <clang/Basic/Version.h>
#include <clang/Frontend/CompilerInstance.h>
#include <clang/Frontend/FrontendAction.h>
#include <clang/Frontend/Utils.h>
#include <clang/Sema/Sema.h>
#include <clang/Tooling/Tooling.h>
#include <llvm/Support/CommandLine.h>
#include <llvm/Support/Format.h>
using namespace std::literals;
static unsigned AthenaError = 0;
#define ATHENA_DNA_BASETYPE "struct athena::io::DNA"
#ifndef INSTALL_PREFIX
#define INSTALL_PREFIX / usr / local
#endif
#define XSTR(s) STR(s)
#define STR(s) #s
static llvm::cl::opt<bool> Help("h", llvm::cl::desc("Alias for -help"), llvm::cl::Hidden);
static llvm::cl::opt<bool> Verbose("v", llvm::cl::desc("verbose mode"));
static llvm::cl::OptionCategory ATDNAFormatCategory("atdna options");
static llvm::cl::opt<std::string> OutputFilename("o", llvm::cl::desc("Specify output filename"),
llvm::cl::value_desc("filename"), llvm::cl::Prefix);
static llvm::cl::opt<bool> FExceptions("fexceptions", llvm::cl::desc("Enable C++ Exceptions"));
static llvm::cl::opt<bool> FMSCompat("fms-compatibility", llvm::cl::desc("Enable MS header compatibility"));
static llvm::cl::opt<std::string>
FMSCompatVersion("fms-compatibility-version",
llvm::cl::desc("Specify MS compatibility version (18.00 for VS2013, 19.00 for VS2015)"));
static llvm::cl::list<std::string> InputFilenames(llvm::cl::Positional, llvm::cl::desc("<Input files>"),
llvm::cl::ZeroOrMore);
static llvm::cl::list<std::string> IncludeSearchPaths("I", llvm::cl::desc("Header search path"), llvm::cl::Prefix);
static llvm::cl::list<std::string> SystemIncludeSearchPaths("isystem", llvm::cl::desc("System Header search path"));
static llvm::cl::opt<std::string> StandardCXXLib("stdlib", llvm::cl::desc("Standard C++ library"));
static llvm::cl::opt<bool> DepFile("MD", llvm::cl::desc("Make Dependency file"));
static llvm::cl::opt<std::string> DepFileOut("MF", llvm::cl::desc("Dependency file out path"));
static llvm::cl::list<std::string> DepFileTargets("MT", llvm::cl::desc("Dependency file targets"));
static llvm::cl::list<std::string> SystemIncRoot("isysroot", llvm::cl::desc("System include root"));
static llvm::cl::list<std::string> PreprocessorDefines("D", llvm::cl::desc("Preprocessor define"), llvm::cl::Prefix);
static llvm::cl::opt<bool> EmitIncludes("emit-includes",
llvm::cl::desc("Emit DNA for included files (not just main file)"));
/* LLVM 3.7 changed the stream type */
#if LLVM_VERSION_MAJOR > 3 || (LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR >= 7)
using StreamOut = llvm::raw_pwrite_stream;
#else
using StreamOut = llvm::raw_fd_ostream;
#endif
class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
clang::ASTContext& context;
StreamOut& fileOut;
bool isDNARecord(const clang::CXXRecordDecl* record, std::string& baseDNA) {
for (const clang::CXXBaseSpecifier& base : record->bases()) {
const clang::QualType qtp = base.getType().getCanonicalType();
if (!qtp.getAsString().compare(0, sizeof(ATHENA_DNA_BASETYPE) - 1, ATHENA_DNA_BASETYPE))
return true;
}
for (const clang::CXXBaseSpecifier& base : record->bases()) {
clang::QualType qtp = base.getType().getCanonicalType();
const clang::Type* tp = qtp.getTypePtrOrNull();
if (tp) {
const clang::CXXRecordDecl* rDecl = tp->getAsCXXRecordDecl();
if (rDecl) {
if (isDNARecord(rDecl, baseDNA)) {
bool hasRead = false;
bool hasWrite = false;
for (const clang::CXXMethodDecl* method : rDecl->methods()) {
std::string compName = method->getDeclName().getAsString();
if (!compName.compare("read"))
hasRead = true;
else if (!compName.compare("write"))
hasWrite = true;
}
if (hasRead && hasWrite) {
std::string templateStmt;
GetNestedTypeName(rDecl, templateStmt, baseDNA);
}
return true;
}
}
}
}
return false;
}
int64_t GetSizeValue(const clang::Type* theType, unsigned width) {
if (theType->isEnumeralType()) {
const auto* eType = static_cast<const clang::EnumType*>(theType);
clang::EnumDecl* eDecl = eType->getDecl();
theType = eDecl->getIntegerType().getCanonicalType().getTypePtr();
const auto* bType = static_cast<const clang::BuiltinType*>(theType);
if (bType->isBooleanType()) {
return 1;
} else if (bType->isUnsignedInteger() || bType->isSignedInteger()) {
return width / 8;
}
} else if (theType->isBuiltinType()) {
const auto* bType = static_cast<const clang::BuiltinType*>(theType);
if (bType->isBooleanType()) {
return 1;
} else if (bType->isUnsignedInteger() || bType->isSignedInteger() || bType->isFloatingPoint()) {
return width / 8;
}
} else if (theType->isRecordType()) {
const clang::CXXRecordDecl* rDecl = theType->getAsCXXRecordDecl();
for (const clang::FieldDecl* field : rDecl->fields()) {
if (!field->getName().compare("clangVec")) {
const auto* vType = static_cast<const clang::VectorType*>(field->getType().getTypePtr());
if (vType->isVectorType()) {
const auto* eType = static_cast<const clang::BuiltinType*>(vType->getElementType().getTypePtr());
const uint64_t typeWidth = context.getTypeInfo(eType).Width;
if (!eType->isBuiltinType() || !eType->isFloatingPoint() || (typeWidth != 32 && typeWidth != 64))
continue;
if (vType->getNumElements() == 2) {
return typeWidth / 8 * 2;
} else if (vType->getNumElements() == 3) {
return typeWidth / 8 * 3;
} else if (vType->getNumElements() == 4) {
return typeWidth / 8 * 4;
}
}
}
}
}
return 0;
}
static std::string GetFieldString(const std::string& fieldName) {
#if 0
size_t underscorePos = fieldName.find('_');
std::string idString = fieldName;
if (underscorePos != std::string::npos && underscorePos != fieldName.size() - 1)
idString.assign(fieldName.begin() + underscorePos + 1, fieldName.end());
return idString;
#endif
return fieldName;
}
static std::string GetPropIdExpr(const clang::FieldDecl* field, const std::string& fieldName) {
std::string fieldStr = GetFieldString(fieldName);
std::string propIdExpr = "\""s.append(fieldStr).append(1, '\"');
for (clang::Attr* attr : field->attrs()) {
if (clang::AnnotateAttr* annot = clang::dyn_cast_or_null<clang::AnnotateAttr>(attr)) {
llvm::StringRef textRef = annot->getAnnotation();
if (textRef.startswith_lower("rcrc32=")) {
unsigned long num = strtoul(textRef.data() + 7, nullptr, 16);
std::string tmpS;
llvm::raw_string_ostream s(tmpS);
s << llvm::format("\"%s\", 0x%08X", fieldStr.c_str(), num);
propIdExpr = s.str();
break;
}
}
}
return propIdExpr;
}
static std::string GetOpString(const std::string& fieldName, const std::string& propIdExpr,
const std::string& endianExpr) {
return "<Op, "s.append(endianExpr)
.append(">(athena::io::PropId(")
.append(propIdExpr)
.append("), ")
.append(fieldName)
.append(", s)");
}
static std::string GetOpString(const std::string& fieldName, const std::string& propIdExpr) {
return "<Op>(athena::io::PropId("s.append(propIdExpr).append("), ").append(fieldName).append(", s)");
}
static std::string GetVectorOpString(const std::string& fieldName, const std::string& propIdExpr,
const std::string& sizeExpr, const std::string& endianExpr) {
return "<Op, "s.append(endianExpr)
.append(">(athena::io::PropId(")
.append(propIdExpr)
.append("), ")
.append(fieldName)
.append(", ")
.append(sizeExpr)
.append(", s)");
}
static std::string GetVectorOpString(const std::string& fieldName, const std::string& propIdExpr,
const std::string& sizeExpr) {
return "<Op>(athena::io::PropId("s.append(propIdExpr)
.append("), ")
.append(fieldName)
.append(", ")
.append(sizeExpr)
.append(", s)");
}
static void RecurseNestedTypeName(const clang::DeclContext* decl, std::string& templateStmt, std::string& qualType) {
if (!decl)
return;
RecurseNestedTypeName(decl->getParent(), templateStmt, qualType);
if (const clang::CXXRecordDecl* rec = clang::dyn_cast_or_null<clang::CXXRecordDecl>(decl)) {
if (!qualType.empty())
qualType += "::";
qualType += rec->getName();
if (const clang::ClassTemplateDecl* ct = rec->getDescribedClassTemplate()) {
templateStmt += "template <";
qualType += '<';
bool needsComma = false;
for (const clang::NamedDecl* parm : *ct->getTemplateParameters()) {
if (const clang::TemplateTypeParmDecl* tpParm = clang::dyn_cast_or_null<clang::TemplateTypeParmDecl>(parm)) {
if (needsComma) {
templateStmt += ", ";
qualType += ", ";
}
templateStmt += "class "s.append(tpParm->getName().str());
qualType += tpParm->getName();
needsComma = true;
} else if (const clang::NonTypeTemplateParmDecl* nonTypeParm =
clang::dyn_cast_or_null<clang::NonTypeTemplateParmDecl>(parm)) {
if (needsComma) {
templateStmt += ", ";
qualType += ", ";
}
templateStmt += nonTypeParm->getType().getAsString().append(1, ' ').append(nonTypeParm->getName().str());
qualType += nonTypeParm->getName();
needsComma = true;
}
}
templateStmt += ">\n";
qualType += '>';
}
} else if (const clang::NamedDecl* namedDecl = clang::dyn_cast_or_null<clang::NamedDecl>(decl)) {
if (!qualType.empty())
qualType += "::";
qualType += namedDecl->getName();
}
}
static void GetNestedTypeName(const clang::DeclContext* decl, std::string& templateStmt, std::string& qualType) {
templateStmt.clear();
qualType.clear();
RecurseNestedTypeName(decl, templateStmt, qualType);
}
static void RecurseNestedTypeSpecializations(const clang::DeclContext* decl,
std::vector<std::pair<std::string, int>>& specializations) {
if (!decl) {
specializations.emplace_back();
return;
}
std::vector<std::pair<std::string, int>> parentSpecializations;
RecurseNestedTypeSpecializations(decl->getParent(), parentSpecializations);
bool foundSpecializations = false;
if (const clang::CXXRecordDecl* rec = clang::dyn_cast_or_null<clang::CXXRecordDecl>(decl)) {
if (const clang::ClassTemplateDecl* ct = rec->getDescribedClassTemplate()) {
int numParms = 0;
for (const clang::NamedDecl* parm : *ct->getTemplateParameters())
if (clang::dyn_cast_or_null<clang::TemplateTypeParmDecl>(parm) ||
clang::dyn_cast_or_null<clang::NonTypeTemplateParmDecl>(parm))
++numParms;
for (clang::Attr* attr : rec->attrs()) {
if (clang::AnnotateAttr* annot = clang::dyn_cast_or_null<clang::AnnotateAttr>(attr)) {
llvm::StringRef textRef = annot->getAnnotation();
if (textRef.startswith_lower("specparms=")) {
llvm::SmallVector<llvm::StringRef, 16> specParms;
textRef.substr(10).split(specParms, ',');
int numTuples = int(specParms.size()) / numParms;
for (const auto& parent : parentSpecializations) {
for (int i = 0; i < numTuples; ++i) {
if (parent.first.empty()) {
specializations.emplace_back(std::string(rec->getName().str()).append(1, '<'), 1);
} else {
auto specialization =
std::string(parent.first).append("::").append(rec->getName().str()).append(1, '<');
specializations.emplace_back(std::move(specialization), parent.second + 1);
}
bool needsComma = false;
for (auto it = specParms.begin() + i * numParms;
it != specParms.end() && it != specParms.begin() + (i + 1) * numParms; ++it) {
llvm::StringRef trimmed = it->trim();
if (needsComma)
specializations.back().first += ", ";
specializations.back().first += trimmed;
needsComma = true;
}
specializations.back().first += '>';
}
}
foundSpecializations = true;
break;
}
}
}
}
}
if (!foundSpecializations) {
for (const auto& parent : parentSpecializations) {
if (const clang::NamedDecl* namedDecl = clang::dyn_cast_or_null<clang::NamedDecl>(decl)) {
if (parent.first.empty()) {
specializations.emplace_back(namedDecl->getName().str(), parent.second);
} else {
specializations.emplace_back(std::string(parent.first).append("::").append(namedDecl->getName().str()),
parent.second);
}
} else {
specializations.push_back(parent);
}
}
}
}
static std::vector<std::pair<std::string, int>> GetNestedTypeSpecializations(const clang::DeclContext* decl) {
std::vector<std::pair<std::string, int>> ret;
RecurseNestedTypeSpecializations(decl, ret);
return ret;
}
void emitEnumerateFunc(clang::CXXRecordDecl* decl, const std::string& baseDNA) {
std::string templateStmt;
std::string qualTypeStr;
GetNestedTypeName(decl, templateStmt, qualTypeStr);
fileOut << templateStmt;
fileOut << "template <class Op>\nvoid " << qualTypeStr << "::Enumerate(typename Op::StreamT& s) {\n";
if (baseDNA.size())
fileOut << " " << baseDNA << "::Enumerate<Op>(s);\n";
enum class NodeType { Do, DoSeek, DoAlign };
struct OutputNode {
NodeType m_type = NodeType::Do;
std::string m_fieldName;
std::string m_ioOp;
bool m_squelched = false;
OutputNode(NodeType type, std::string fieldName, std::string ioOp, bool squelched)
: m_type(type), m_fieldName(std::move(fieldName)), m_ioOp(std::move(ioOp)), m_squelched(squelched) {}
};
std::vector<OutputNode> outputNodes;
for (const clang::FieldDecl* field : decl->fields()) {
clang::QualType qualType = field->getType();
const clang::Type* regType = qualType.getTypePtrOrNull();
if (!regType || regType->getTypeClass() == clang::Type::TemplateTypeParm)
continue;
while (regType->getTypeClass() == clang::Type::Elaborated || regType->getTypeClass() == clang::Type::Typedef)
regType = regType->getUnqualifiedDesugaredType();
/* Resolve constant array */
while (regType->getTypeClass() == clang::Type::ConstantArray) {
const auto* caType = static_cast<const clang::ConstantArrayType*>(regType);
qualType = caType->getElementType();
regType = qualType.getTypePtrOrNull();
if (regType->getTypeClass() == clang::Type::Elaborated)
regType = regType->getUnqualifiedDesugaredType();
}
std::string fieldName = field->getName();
std::string propIdExpr = GetPropIdExpr(field, fieldName);
if (regType->getTypeClass() == clang::Type::TemplateSpecialization) {
const auto* tsType = static_cast<const clang::TemplateSpecializationType*>(regType);
const clang::TemplateDecl* tsDecl = tsType->getTemplateName().getAsTemplateDecl();
const clang::TemplateParameterList* classParms = tsDecl->getTemplateParameters();
if (!tsDecl->getName().compare("Value")) {
llvm::APSInt endian(64, -1);
std::string endianExprStr;
bool defaultEndian = true;
if (classParms->size() >= 2) {
const clang::NamedDecl* endianParm = classParms->getParam(1);
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm) {
const auto* nttParm = static_cast<const clang::NonTypeTemplateParmDecl*>(endianParm);
llvm::raw_string_ostream strStream(endianExprStr);
nttParm->print(strStream, context.getPrintingPolicy());
}
}
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const clang::Expr* expr = arg.getAsExpr();
llvm::raw_string_ostream strStream(endianExprStr);
expr->printPretty(strStream, nullptr, context.getPrintingPolicy());
defaultEndian = false;
}
}
std::string ioOp;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Type) {
if (defaultEndian) {
ioOp = GetOpString(fieldName, propIdExpr);
} else {
ioOp = GetOpString(fieldName, propIdExpr, endianExprStr);
}
}
}
if (ioOp.empty()) {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocation(), AthenaError);
diag.AddString("Unable to use type '"s.append(tsDecl->getName().str()).append("' with Athena"));
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
continue;
}
outputNodes.emplace_back(NodeType::Do, std::move(fieldName), std::move(ioOp), false);
} else if (!tsDecl->getName().compare("Vector")) {
llvm::APSInt endian(64, -1);
std::string endianExprStr;
bool defaultEndian = true;
if (classParms->size() >= 3) {
const clang::NamedDecl* endianParm = classParms->getParam(2);
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm) {
const auto* nttParm = static_cast<const clang::NonTypeTemplateParmDecl*>(endianParm);
llvm::raw_string_ostream strStream(endianExprStr);
nttParm->print(strStream, context.getPrintingPolicy());
}
}
std::string sizeExpr;
size_t idx = 0;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
if (idx == 1) {
const auto* uExpr = static_cast<const clang::UnaryExprOrTypeTraitExpr*>(expr);
if (uExpr->getStmtClass() == clang::Stmt::UnaryExprOrTypeTraitExprClass &&
uExpr->getKind() == clang::UETT_SizeOf) {
const clang::Expr* argExpr = uExpr->getArgumentExpr();
while (argExpr->getStmtClass() == clang::Stmt::ParenExprClass)
argExpr = static_cast<const clang::ParenExpr*>(argExpr)->getSubExpr();
if (argExpr->getStmtClass() == clang::Stmt::DeclRefExprClass) {
const auto* drExpr = static_cast<const clang::DeclRefExpr*>(argExpr);
std::string testName = drExpr->getFoundDecl()->getNameAsString();
for (auto i = outputNodes.rbegin(); i != outputNodes.rend(); ++i) {
if (i->m_fieldName == testName) {
i->m_squelched = true;
break;
}
}
}
llvm::raw_string_ostream strStream2(sizeExpr);
argExpr->printPretty(strStream2, nullptr, context.getPrintingPolicy());
}
} else if (idx == 2) {
defaultEndian = false;
llvm::raw_string_ostream strStream(endianExprStr);
expr->printPretty(strStream, nullptr, context.getPrintingPolicy());
}
}
++idx;
}
clang::QualType templateType;
std::string ioOp;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Type) {
templateType = arg.getAsType().getCanonicalType();
if (defaultEndian) {
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExpr);
} else {
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExpr, endianExprStr);
}
}
}
if (ioOp.empty()) {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocation(), AthenaError);
diag.AddString("Unable to use type '"s.append(templateType.getAsString()).append("' with Athena"));
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
continue;
}
if (sizeExpr.empty()) {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocation(), AthenaError);
diag.AddString("Unable to use count variable with Athena");
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
continue;
}
outputNodes.emplace_back(NodeType::Do, std::move(fieldName), std::move(ioOp), false);
} else if (!tsDecl->getName().compare("Buffer")) {
const clang::Expr* sizeExpr = nullptr;
std::string sizeExprStr;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const auto* uExpr = static_cast<const clang::UnaryExprOrTypeTraitExpr*>(arg.getAsExpr()->IgnoreImpCasts());
if (uExpr->getStmtClass() == clang::Stmt::UnaryExprOrTypeTraitExprClass &&
uExpr->getKind() == clang::UETT_SizeOf) {
const clang::Expr* argExpr = uExpr->getArgumentExpr();
while (argExpr->getStmtClass() == clang::Stmt::ParenExprClass)
argExpr = static_cast<const clang::ParenExpr*>(argExpr)->getSubExpr();
sizeExpr = argExpr;
llvm::raw_string_ostream strStream(sizeExprStr);
argExpr->printPretty(strStream, nullptr, context.getPrintingPolicy());
}
}
}
if (sizeExprStr.empty()) {
if (sizeExpr) {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(sizeExpr->getExprLoc(), AthenaError);
diag.AddString("Unable to use size variable with Athena");
diag.AddSourceRange(clang::CharSourceRange(sizeExpr->getSourceRange(), true));
} else {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocation(), AthenaError);
diag.AddString("Unable to use size variable with Athena");
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
}
continue;
}
std::string ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr);
outputNodes.emplace_back(NodeType::Do, std::move(fieldName), std::move(ioOp), false);
} else if (!tsDecl->getName().compare("String")) {
std::string sizeExprStr;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
const auto* uExpr = static_cast<const clang::UnaryExprOrTypeTraitExpr*>(expr);
llvm::APSInt sizeLiteral;
if (expr->getStmtClass() == clang::Stmt::UnaryExprOrTypeTraitExprClass &&
uExpr->getKind() == clang::UETT_SizeOf) {
const clang::Expr* argExpr = uExpr->getArgumentExpr();
while (argExpr->getStmtClass() == clang::Stmt::ParenExprClass)
argExpr = static_cast<const clang::ParenExpr*>(argExpr)->getSubExpr();
llvm::raw_string_ostream strStream(sizeExprStr);
argExpr->printPretty(strStream, nullptr, context.getPrintingPolicy());
} else if (expr->isIntegerConstantExpr(sizeLiteral, context)) {
sizeExprStr = sizeLiteral.toString(10);
}
}
}
std::string ioOp;
if (!sizeExprStr.empty()) {
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr);
} else {
ioOp = GetOpString(fieldName, propIdExpr);
}
outputNodes.emplace_back(NodeType::Do, std::move(fieldName), std::move(ioOp), false);
} else if (!tsDecl->getName().compare("WString")) {
llvm::APSInt endian(64, -1);
std::string endianExprStr;
bool defaultEndian = true;
if (classParms->size() >= 2) {
const clang::NamedDecl* endianParm = classParms->getParam(1);
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm) {
const auto* nttParm = static_cast<const clang::NonTypeTemplateParmDecl*>(endianParm);
llvm::raw_string_ostream strStream(endianExprStr);
nttParm->print(strStream, context.getPrintingPolicy());
}
}
std::string sizeExprStr;
size_t idx = 0;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
if (idx == 0) {
llvm::APSInt sizeLiteral;
const auto* uExpr = static_cast<const clang::UnaryExprOrTypeTraitExpr*>(expr);
if (expr->getStmtClass() == clang::Stmt::UnaryExprOrTypeTraitExprClass &&
uExpr->getKind() == clang::UETT_SizeOf) {
const clang::Expr* argExpr = uExpr->getArgumentExpr();
while (argExpr->getStmtClass() == clang::Stmt::ParenExprClass)
argExpr = static_cast<const clang::ParenExpr*>(argExpr)->getSubExpr();
llvm::raw_string_ostream strStream2(sizeExprStr);
argExpr->printPretty(strStream2, nullptr, context.getPrintingPolicy());
} else if (expr->isIntegerConstantExpr(sizeLiteral, context)) {
sizeExprStr = sizeLiteral.toString(10);
}
} else if (idx == 1) {
defaultEndian = false;
llvm::raw_string_ostream strStream(endianExprStr);
expr->printPretty(strStream, nullptr, context.getPrintingPolicy());
}
}
++idx;
}
std::string ioOp;
if (!sizeExprStr.empty()) {
if (defaultEndian) {
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr);
} else {
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr, endianExprStr);
}
} else {
if (defaultEndian) {
ioOp = GetOpString(fieldName, propIdExpr);
} else {
ioOp = GetOpString(fieldName, propIdExpr, endianExprStr);
}
}
outputNodes.emplace_back(NodeType::Do, std::move(fieldName), std::move(ioOp), false);
} else if (!tsDecl->getName().compare("Seek")) {
size_t idx = 0;
std::string offsetExprStr;
llvm::APSInt direction(64, 0);
const clang::Expr* directionExpr = nullptr;
bool bad = false;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
if (!idx) {
const auto* uExpr = static_cast<const clang::UnaryExprOrTypeTraitExpr*>(expr);
llvm::APSInt offsetLiteral;
if (expr->getStmtClass() == clang::Stmt::UnaryExprOrTypeTraitExprClass &&
uExpr->getKind() == clang::UETT_SizeOf) {
const clang::Expr* argExpr = uExpr->getArgumentExpr();
while (argExpr->getStmtClass() == clang::Stmt::ParenExprClass)
argExpr = static_cast<const clang::ParenExpr*>(argExpr)->getSubExpr();
llvm::raw_string_ostream strStream(offsetExprStr);
argExpr->printPretty(strStream, nullptr, context.getPrintingPolicy());
} else if (expr->isIntegerConstantExpr(offsetLiteral, context)) {
offsetExprStr = offsetLiteral.toString(10);
}
} else {
directionExpr = expr;
if (!expr->isIntegerConstantExpr(direction, context)) {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(expr->getExprLoc(), AthenaError);
diag.AddString("Unable to use non-constant direction expression in Athena");
diag.AddSourceRange(clang::CharSourceRange(expr->getSourceRange(), true));
bad = true;
break;
}
}
}
++idx;
}
if (bad)
continue;
int64_t directionVal = direction.getSExtValue();
if (directionVal < 0 || directionVal > 2) {
if (directionExpr) {
clang::DiagnosticBuilder diag =
context.getDiagnostics().Report(directionExpr->getExprLoc(), AthenaError);
diag.AddString("Direction parameter must be 'Begin', 'Current', or 'End'");
diag.AddSourceRange(clang::CharSourceRange(directionExpr->getSourceRange(), true));
} else {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocation(), AthenaError);
diag.AddString("Direction parameter must be 'Begin', 'Current', or 'End'");
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
}
continue;
}
if (directionVal == 0) {
outputNodes.emplace_back(NodeType::DoSeek, std::move(fieldName),
"<Op>("s.append(offsetExprStr).append(", athena::SeekOrigin::Begin, s)"), false);
} else if (directionVal == 1) {
outputNodes.emplace_back(NodeType::DoSeek, std::move(fieldName),
"<Op>("s.append(offsetExprStr).append(", athena::SeekOrigin::Current, s)"), false);
} else if (directionVal == 2) {
outputNodes.emplace_back(NodeType::DoSeek, std::move(fieldName),
"<Op>("s.append(offsetExprStr).append(", athena::SeekOrigin::End, s)"), false);
}
} else if (!tsDecl->getName().compare("Align")) {
llvm::APSInt align(64, 0);
bool bad = false;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const clang::Expr* expr = arg.getAsExpr();
if (!expr->isIntegerConstantExpr(align, context)) {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(expr->getExprLoc(), AthenaError);
diag.AddString("Unable to use non-constant align expression in Athena");
diag.AddSourceRange(clang::CharSourceRange(expr->getSourceRange(), true));
bad = true;
break;
}
}
}
if (bad)
continue;
const int64_t alignVal = align.getSExtValue();
if (alignVal) {
outputNodes.emplace_back(NodeType::DoAlign, std::move(fieldName),
"<Op>("s.append(align.toString(10, true)).append(", s)"), false);
}
} else {
const clang::NamedDecl* nd = tsDecl->getTemplatedDecl();
if (const clang::CXXRecordDecl* rd = clang::dyn_cast_or_null<clang::CXXRecordDecl>(nd)) {
std::string baseDNA2;
if (isDNARecord(rd, baseDNA2)) {
outputNodes.emplace_back(NodeType::Do, std::move(fieldName), GetOpString(fieldName, propIdExpr), false);
}
}
}
} else if (regType->getTypeClass() == clang::Type::Record) {
const clang::CXXRecordDecl* cxxRDecl = regType->getAsCXXRecordDecl();
std::string baseDNA2;
if (cxxRDecl && isDNARecord(cxxRDecl, baseDNA2)) {
outputNodes.emplace_back(NodeType::Do, std::move(fieldName), GetOpString(fieldName, propIdExpr), false);
}
}
}
for (const OutputNode& node : outputNodes) {
switch (node.m_type) {
case NodeType::Do:
if (node.m_squelched)
fileOut << " DoSize" << node.m_ioOp << ";\n";
else
fileOut << " Do" << node.m_ioOp << ";\n";
break;
case NodeType::DoSeek:
fileOut << " DoSeek" << node.m_ioOp << ";\n";
break;
case NodeType::DoAlign:
fileOut << " DoAlign" << node.m_ioOp << ";\n";
break;
}
}
fileOut << "}\n\n";
}
void emitLookupFunc(clang::CXXRecordDecl* decl, const std::string& baseDNA) {
std::string templateStmt;
std::string qualTypeStr;
GetNestedTypeName(decl, templateStmt, qualTypeStr);
fileOut << templateStmt;
fileOut << "template <class Op>\nbool " << qualTypeStr << "::Lookup(uint64_t hash, typename Op::StreamT& s) {\n";
if (baseDNA.size())
fileOut << " if (" << baseDNA << "::Lookup<Op>(hash, s))\n"
<< " return true;\n";
fileOut << " switch (hash) {\n";
for (const clang::FieldDecl* field : decl->fields()) {
clang::QualType qualType = field->getType();
const clang::Type* regType = qualType.getTypePtrOrNull();
if (!regType || regType->getTypeClass() == clang::Type::TemplateTypeParm)
continue;
while (regType->getTypeClass() == clang::Type::Elaborated || regType->getTypeClass() == clang::Type::Typedef)
regType = regType->getUnqualifiedDesugaredType();
/* Resolve constant array */
while (regType->getTypeClass() == clang::Type::ConstantArray) {
const auto* caType = static_cast<const clang::ConstantArrayType*>(regType);
qualType = caType->getElementType();
regType = qualType.getTypePtrOrNull();
if (regType->getTypeClass() == clang::Type::Elaborated)
regType = regType->getUnqualifiedDesugaredType();
}
std::string fieldName = field->getName();
std::string propIdExpr = GetPropIdExpr(field, fieldName);
if (regType->getTypeClass() == clang::Type::TemplateSpecialization) {
const auto* tsType = static_cast<const clang::TemplateSpecializationType*>(regType);
const clang::TemplateDecl* tsDecl = tsType->getTemplateName().getAsTemplateDecl();
const clang::TemplateParameterList* classParms = tsDecl->getTemplateParameters();
if (!tsDecl->getName().compare("Value")) {
llvm::APSInt endian(64, -1);
std::string endianExprStr;
bool defaultEndian = true;
if (classParms->size() >= 2) {
const clang::NamedDecl* endianParm = classParms->getParam(1);
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm) {
const auto* nttParm = static_cast<const clang::NonTypeTemplateParmDecl*>(endianParm);
llvm::raw_string_ostream strStream(endianExprStr);
nttParm->print(strStream, context.getPrintingPolicy());
}
}
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const clang::Expr* expr = arg.getAsExpr();
llvm::raw_string_ostream strStream(endianExprStr);
expr->printPretty(strStream, nullptr, context.getPrintingPolicy());
defaultEndian = false;
}
}
std::string ioOp;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Type) {
if (defaultEndian)
ioOp = GetOpString(fieldName, propIdExpr);
else
ioOp = GetOpString(fieldName, propIdExpr, endianExprStr);
}
}
if (ioOp.empty()) {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocation(), AthenaError);
diag.AddString("Unable to use type '"s.append(tsDecl->getName().str()).append("' with Athena"));
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
continue;
}
fileOut << " AT_PROP_CASE(" << propIdExpr << "):\n"
<< " Do" << ioOp << ";\n"
<< " return true;\n";
} else if (!tsDecl->getName().compare("Vector")) {
llvm::APSInt endian(64, -1);
std::string endianExprStr;
bool defaultEndian = true;
if (classParms->size() >= 3) {
const clang::NamedDecl* endianParm = classParms->getParam(2);
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm) {
const auto* nttParm = static_cast<const clang::NonTypeTemplateParmDecl*>(endianParm);
llvm::raw_string_ostream strStream(endianExprStr);
nttParm->print(strStream, context.getPrintingPolicy());
}
}
std::string sizeExpr;
size_t idx = 0;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
if (idx == 1) {
const auto* uExpr = static_cast<const clang::UnaryExprOrTypeTraitExpr*>(expr);
if (uExpr->getStmtClass() == clang::Stmt::UnaryExprOrTypeTraitExprClass &&
uExpr->getKind() == clang::UETT_SizeOf) {
const clang::Expr* argExpr = uExpr->getArgumentExpr();
while (argExpr->getStmtClass() == clang::Stmt::ParenExprClass)
argExpr = static_cast<const clang::ParenExpr*>(argExpr)->getSubExpr();
llvm::raw_string_ostream strStream2(sizeExpr);
argExpr->printPretty(strStream2, nullptr, context.getPrintingPolicy());
}
} else if (idx == 2) {
llvm::raw_string_ostream strStream(endianExprStr);
expr->printPretty(strStream, nullptr, context.getPrintingPolicy());
defaultEndian = false;
}
}
++idx;
}
clang::QualType templateType;
std::string ioOp;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Type) {
templateType = arg.getAsType().getCanonicalType();
if (defaultEndian)
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExpr);
else
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExpr, endianExprStr);
}
}
if (ioOp.empty()) {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocation(), AthenaError);
diag.AddString("Unable to use type '"s.append(templateType.getAsString()).append("' with Athena"));
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
continue;
}
if (sizeExpr.empty()) {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocation(), AthenaError);
diag.AddString("Unable to use count variable with Athena");
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
continue;
}
fileOut << " AT_PROP_CASE(" << propIdExpr << "):\n"
<< " Do" << ioOp << ";\n"
<< " return true;\n";
} else if (!tsDecl->getName().compare("Buffer")) {
const clang::Expr* sizeExpr = nullptr;
std::string sizeExprStr;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const auto* uExpr = static_cast<const clang::UnaryExprOrTypeTraitExpr*>(arg.getAsExpr()->IgnoreImpCasts());
if (uExpr->getStmtClass() == clang::Stmt::UnaryExprOrTypeTraitExprClass &&
uExpr->getKind() == clang::UETT_SizeOf) {
const clang::Expr* argExpr = uExpr->getArgumentExpr();
while (argExpr->getStmtClass() == clang::Stmt::ParenExprClass)
argExpr = static_cast<const clang::ParenExpr*>(argExpr)->getSubExpr();
sizeExpr = argExpr;
llvm::raw_string_ostream strStream(sizeExprStr);
argExpr->printPretty(strStream, nullptr, context.getPrintingPolicy());
}
}
}
if (sizeExprStr.empty()) {
if (sizeExpr) {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(sizeExpr->getExprLoc(), AthenaError);
diag.AddString("Unable to use size variable with Athena");
diag.AddSourceRange(clang::CharSourceRange(sizeExpr->getSourceRange(), true));
} else {
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocation(), AthenaError);
diag.AddString("Unable to use size variable with Athena");
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
}
continue;
}
std::string ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr);
fileOut << " AT_PROP_CASE(" << propIdExpr << "):\n"
<< " Do" << ioOp << ";\n"
<< " return true;\n";
} else if (!tsDecl->getName().compare("String")) {
std::string sizeExprStr;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
const auto* uExpr = static_cast<const clang::UnaryExprOrTypeTraitExpr*>(expr);
llvm::APSInt sizeLiteral;
if (expr->getStmtClass() == clang::Stmt::UnaryExprOrTypeTraitExprClass &&
uExpr->getKind() == clang::UETT_SizeOf) {
const clang::Expr* argExpr = uExpr->getArgumentExpr();
while (argExpr->getStmtClass() == clang::Stmt::ParenExprClass)
argExpr = static_cast<const clang::ParenExpr*>(argExpr)->getSubExpr();
llvm::raw_string_ostream strStream(sizeExprStr);
argExpr->printPretty(strStream, nullptr, context.getPrintingPolicy());
} else if (expr->isIntegerConstantExpr(sizeLiteral, context)) {
sizeExprStr = sizeLiteral.toString(10);
}
}
}
std::string ioOp;
if (!sizeExprStr.empty())
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr);
else
ioOp = GetOpString(fieldName, propIdExpr);
fileOut << " AT_PROP_CASE(" << propIdExpr << "):\n"
<< " Do" << ioOp << ";\n"
<< " return true;\n";
} else if (!tsDecl->getName().compare("WString")) {
llvm::APSInt endian(64, -1);
std::string endianExprStr;
bool defaultEndian = true;
if (classParms->size() >= 2) {
const clang::NamedDecl* endianParm = classParms->getParam(1);
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm) {
const auto* nttParm = static_cast<const clang::NonTypeTemplateParmDecl*>(endianParm);
llvm::raw_string_ostream strStream(endianExprStr);
nttParm->print(strStream, context.getPrintingPolicy());
}
}
std::string sizeExprStr;
size_t idx = 0;
for (const clang::TemplateArgument& arg : *tsType) {
if (arg.getKind() == clang::TemplateArgument::Expression) {
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
if (idx == 0) {
llvm::APSInt sizeLiteral;
const auto* uExpr = static_cast<const clang::UnaryExprOrTypeTraitExpr*>(expr);
if (expr->getStmtClass() == clang::Stmt::UnaryExprOrTypeTraitExprClass &&
uExpr->getKind() == clang::UETT_SizeOf) {
const clang::Expr* argExpr = uExpr->getArgumentExpr();
while (argExpr->getStmtClass() == clang::Stmt::ParenExprClass)
argExpr = static_cast<const clang::ParenExpr*>(argExpr)->getSubExpr();
llvm::raw_string_ostream strStream2(sizeExprStr);
argExpr->printPretty(strStream2, nullptr, context.getPrintingPolicy());
} else if (expr->isIntegerConstantExpr(sizeLiteral, context)) {
sizeExprStr = sizeLiteral.toString(10);
}
} else if (idx == 1) {
llvm::raw_string_ostream strStream(endianExprStr);
expr->printPretty(strStream, nullptr, context.getPrintingPolicy());
defaultEndian = false;
}
}
++idx;
}
std::string ioOp;
if (!sizeExprStr.empty()) {
if (defaultEndian)
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr);
else
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr, endianExprStr);
} else {
if (defaultEndian)
ioOp = GetOpString(fieldName, propIdExpr);
else
ioOp = GetOpString(fieldName, propIdExpr, endianExprStr);
}
fileOut << " AT_PROP_CASE(" << propIdExpr << "):\n"
<< " Do" << ioOp << ";\n"
<< " return true;\n";
} else {
const clang::NamedDecl* nd = tsDecl->getTemplatedDecl();
if (const clang::CXXRecordDecl* rd = clang::dyn_cast_or_null<clang::CXXRecordDecl>(nd)) {
std::string baseDNA2;
if (isDNARecord(rd, baseDNA2)) {
fileOut << " AT_PROP_CASE(" << propIdExpr << "):\n"
<< " Do" << GetOpString(fieldName, propIdExpr) << ";\n"
<< " return true;\n";
}
}
}
} else if (regType->getTypeClass() == clang::Type::Record) {
const clang::CXXRecordDecl* cxxRDecl = regType->getAsCXXRecordDecl();
std::string baseDNA2;
if (cxxRDecl && isDNARecord(cxxRDecl, baseDNA2)) {
fileOut << " AT_PROP_CASE(" << propIdExpr << "):\n"
<< " Do" << GetOpString(fieldName, propIdExpr) << ";\n"
<< " return true;\n";
}
}
}
fileOut << " default:\n return false;\n }\n}\n\n";
}
public:
explicit ATDNAEmitVisitor(clang::ASTContext& ctxin, StreamOut& fo) : context(ctxin), fileOut(fo) {}
bool VisitCXXRecordDecl(clang::CXXRecordDecl* decl) {
if (!EmitIncludes && !context.getSourceManager().isInMainFile(decl->getLocation()))
return true;
if (decl->isInvalidDecl() || !decl->hasDefinition() || !decl->isCompleteDefinition())
return true;
if (!decl->getNumBases())
return true;
/* First ensure this inherits from struct athena::io::DNA */
std::string baseDNA;
if (!isDNARecord(decl, baseDNA))
return true;
/* Determine if is is a YAML DNA */
bool isYamlDNA = false;
for (const clang::CXXMethodDecl* method : decl->methods())
if (method->getDeclName().isIdentifier() &&
(!method->getName().compare(llvm::StringLiteral("read")) ||
!method->getName().compare(llvm::StringLiteral("write"))) &&
method->getNumParams() == 1 &&
method->getParamDecl(0)->getType().getAsString() == "athena::io::YAMLDocReader &") {
isYamlDNA = true;
break;
}
/* Determine if this is a regular DNA or PropDNA */
bool isPropDNA = false;
for (const clang::Decl* d : decl->decls())
if (const clang::FunctionTemplateDecl* m = clang::dyn_cast_or_null<clang::FunctionTemplateDecl>(d))
if (m->getDeclName().isIdentifier() && !m->getName().compare(llvm::StringLiteral("Lookup"))) {
isPropDNA = true;
break;
}
/* Make sure there isn't Delete meta type */
for (const clang::FieldDecl* field : decl->fields()) {
clang::QualType qualType = field->getType().getCanonicalType();
const clang::Type* regType = qualType.getTypePtrOrNull();
if (regType) {
const clang::CXXRecordDecl* rDecl = regType->getAsCXXRecordDecl();
if (rDecl) {
if (!rDecl->getName().compare("Delete")) {
const clang::CXXRecordDecl* rParentDecl = llvm::dyn_cast_or_null<clang::CXXRecordDecl>(rDecl->getParent());
if (rParentDecl) {
std::string parentCheck = rParentDecl->getTypeForDecl()->getCanonicalTypeInternal().getAsString();
if (!parentCheck.compare(0, sizeof(ATHENA_DNA_BASETYPE) - 1, ATHENA_DNA_BASETYPE))
return true;
}
}
}
}
}
std::vector<std::pair<std::string, int>> specializations = GetNestedTypeSpecializations(decl);
emitEnumerateFunc(decl, baseDNA);
if (isPropDNA) {
emitLookupFunc(decl, baseDNA);
for (const auto& specialization : specializations)
fileOut << "AT_SPECIALIZE_PROPDNA(" << specialization.first << ")\n";
} else if (isYamlDNA) {
for (const auto& specialization : specializations)
fileOut << "AT_SPECIALIZE_DNA_YAML(" << specialization.first << ")\n";
} else {
for (const auto& specialization : specializations)
fileOut << "AT_SPECIALIZE_DNA(" << specialization.first << ")\n";
}
fileOut << "\n\n";
for (const auto& specialization : specializations) {
for (int i = 0; i < specialization.second; ++i)
fileOut << "template <>\n";
fileOut << "const char* " << specialization.first << "::DNAType() {\n return \"" << specialization.first
<< "\";\n}\n";
}
fileOut << "\n\n";
return true;
}
};
class ATDNAConsumer : public clang::ASTConsumer {
std::unique_ptr<StreamOut> fileOut;
StreamOut& fileOutOld;
ATDNAEmitVisitor emitVisitor;
public:
explicit ATDNAConsumer(clang::ASTContext& context, std::unique_ptr<StreamOut>&& fo, StreamOut* foOld)
: fileOut(std::move(fo)), fileOutOld(*foOld), emitVisitor(context, *foOld) {}
void HandleTranslationUnit(clang::ASTContext& context) override {
/* Write file head */
fileOutOld << "/* Auto generated atdna implementation */\n"
"#include \"athena/DNAOp.hpp\"\n";
for (const std::string& inputf : InputFilenames)
fileOutOld << "#include \"" << inputf << "\"\n";
fileOutOld << "\n";
/* Emit file */
emitVisitor.TraverseDecl(context.getTranslationUnitDecl());
}
};
class ATDNAAction : public clang::ASTFrontendAction {
/* Used by LLVM 3.9+; client owns stream */
std::unique_ptr<StreamOut> MakeStreamOut(std::unique_ptr<StreamOut>&& so, StreamOut*& outPtr) {
outPtr = so.get();
return std::move(so);
}
/* Used by previous versions of LLVM; CompilerInstance owns stream */
std::unique_ptr<StreamOut> MakeStreamOut(StreamOut* so, StreamOut*& outPtr) {
outPtr = so;
return {};
}
std::unique_ptr<clang::DependencyFileGenerator> TheDependencyFileGenerator;
public:
explicit ATDNAAction() = default;
std::unique_ptr<clang::ASTConsumer> CreateASTConsumer(clang::CompilerInstance& compiler,
llvm::StringRef /*filename*/) override {
clang::DependencyOutputOptions DepOpts;
DepOpts.OutputFile = DepFileOut.getValue();
DepOpts.Targets = DepFileTargets;
if (!DepOpts.OutputFile.empty())
TheDependencyFileGenerator.reset(
clang::DependencyFileGenerator::CreateAndAttachToPreprocessor(compiler.getPreprocessor(), DepOpts));
std::unique_ptr<StreamOut> fileout;
StreamOut* fileoutOld;
if (OutputFilename.size())
fileout = MakeStreamOut(compiler.createOutputFile(OutputFilename, false, true, "", "", true), fileoutOld);
else
fileout = MakeStreamOut(compiler.createDefaultOutputFile(false, "a", "cpp"), fileoutOld);
AthenaError =
compiler.getASTContext().getDiagnostics().getCustomDiagID(clang::DiagnosticsEngine::Error, "Athena error: %0");
return std::unique_ptr<clang::ASTConsumer>(
new ATDNAConsumer(compiler.getASTContext(), std::move(fileout), fileoutOld));
}
};
int main(int argc, const char** argv) {
llvm::cl::ParseCommandLineOptions(argc, argv, "Athena DNA Generator");
if (Help)
llvm::cl::PrintHelpMessage();
std::vector<std::string> args = {
"clang-tool",
#ifdef __linux__
"--gcc-toolchain=/usr",
#endif
"-fsyntax-only",
"-std=c++1z",
"-D__atdna__=1",
"-Wno-expansion-to-defined",
"-Wno-nullability-completeness",
"-Werror=shadow-field",
"-I" XSTR(INSTALL_PREFIX) "/lib/clang/" CLANG_VERSION_STRING "/include",
"-I" XSTR(INSTALL_PREFIX) "/include/Athena",
};
for (int a = 1; a < argc; ++a) {
args.emplace_back(argv[a]);
}
llvm::IntrusiveRefCntPtr<clang::FileManager> fman(new clang::FileManager(clang::FileSystemOptions()));
ATDNAAction* action = new ATDNAAction();
clang::tooling::ToolInvocation TI(std::move(args), action, fman.get());
if (!TI.run())
return 1;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink