mirror of https://github.com/libAthena/athena.git
1624 lines
78 KiB
C++
1624 lines
78 KiB
C++
#include <cstdio>
|
|
#include <iostream>
|
|
#include "clang/AST/ASTConsumer.h"
|
|
#include "clang/AST/RecursiveASTVisitor.h"
|
|
#include "clang/Frontend/CompilerInstance.h"
|
|
#include "clang/Frontend/FrontendAction.h"
|
|
#include "clang/Frontend/Utils.h"
|
|
#include "clang/Tooling/Tooling.h"
|
|
#include "clang/Lex/Preprocessor.h"
|
|
#include "clang/Sema/Sema.h"
|
|
#include "clang/AST/RecordLayout.h"
|
|
#include "clang/AST/DeclCXX.h"
|
|
#include "clang/AST/TypeLoc.h"
|
|
#include "clang/Basic/Version.h"
|
|
#include "llvm/Support/Format.h"
|
|
#include "llvm/Support/CommandLine.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())
|
|
{
|
|
clang::EnumType* eType = (clang::EnumType*)theType;
|
|
clang::EnumDecl* eDecl = eType->getDecl();
|
|
theType = eDecl->getIntegerType().getCanonicalType().getTypePtr();
|
|
|
|
const clang::BuiltinType* bType = (clang::BuiltinType*)theType;
|
|
if (bType->isBooleanType())
|
|
{
|
|
return 1;
|
|
}
|
|
else if (bType->isUnsignedInteger() || bType->isSignedInteger())
|
|
{
|
|
return width / 8;
|
|
}
|
|
}
|
|
else if (theType->isBuiltinType())
|
|
{
|
|
const clang::BuiltinType* bType = (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 clang::VectorType* vType = (clang::VectorType*)field->getType().getTypePtr();
|
|
if (vType->isVectorType())
|
|
{
|
|
const clang::BuiltinType* eType = (clang::BuiltinType*)vType->getElementType().getTypePtr();
|
|
const uint64_t width = context.getTypeInfo(eType).Width;
|
|
if (!eType->isBuiltinType() || !eType->isFloatingPoint() ||
|
|
(width != 32 && width != 64))
|
|
continue;
|
|
if (vType->getNumElements() == 2)
|
|
{
|
|
return width / 8 * 2;
|
|
}
|
|
else if (vType->getNumElements() == 3)
|
|
{
|
|
return width / 8 * 3;
|
|
}
|
|
else if (vType->getNumElements() == 4)
|
|
{
|
|
return width / 8 * 4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static std::string GetFieldString(const std::string& fieldName)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static std::string GetPropIdExpr(const clang::FieldDecl* field, const std::string& fieldName)
|
|
{
|
|
std::string fieldStr = GetFieldString(fieldName);
|
|
std::string propIdExpr = "\"" + fieldStr + "\"";
|
|
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, int64_t endianVal)
|
|
{
|
|
|
|
return "<Op, "s + (endianVal ? "Endian::Big" : "Endian::Little") + ">({" + propIdExpr + "}, " + fieldName + ", s)";
|
|
}
|
|
|
|
static std::string GetOpString(const std::string& fieldName, const std::string& propIdExpr)
|
|
{
|
|
|
|
return "<Op>({" + propIdExpr + "}, " + fieldName + ", s)";
|
|
}
|
|
|
|
static std::string GetVectorOpString(const std::string& fieldName, const std::string& propIdExpr, const std::string& sizeExpr, int64_t endianVal)
|
|
{
|
|
return "<Op, "s + (endianVal ? "Endian::Big" : "Endian::Little") + ">({" + propIdExpr + "}, " + fieldName + ", " + sizeExpr + ", s)";
|
|
}
|
|
|
|
static std::string GetVectorOpString(const std::string& fieldName, const std::string& propIdExpr, const std::string& sizeExpr)
|
|
{
|
|
return "<Op>({" + propIdExpr + "}, " + fieldName + ", " + sizeExpr + ", 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 + tpParm->getName().data();
|
|
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() + ' ' + nonTypeParm->getName().data();
|
|
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().data()) + '<', 1);
|
|
else
|
|
specializations.emplace_back(parent.first + "::" + rec->getName().data() + '<',
|
|
parent.second + 1);
|
|
bool needsComma = false;
|
|
for (auto it = specParms.begin() + i * numParms;
|
|
it != specParms.end() && it != specParms.begin() + (i + 1) * numParms; ++it)
|
|
{
|
|
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().data(), parent.second);
|
|
else
|
|
specializations.emplace_back(parent.first + "::" + namedDecl->getName().data(), 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{\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, const std::string& fieldName, const std::string& ioOp, bool squelched)
|
|
: m_type(type), m_fieldName(fieldName), m_ioOp(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 */
|
|
if (regType->getTypeClass() == clang::Type::ConstantArray)
|
|
{
|
|
const clang::ConstantArrayType* caType = (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 clang::TemplateSpecializationType* tsType = (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);
|
|
const clang::Expr* endianExpr = nullptr;
|
|
bool defaultEndian = true;
|
|
if (classParms->size() >= 2)
|
|
{
|
|
const clang::NamedDecl* endianParm = classParms->getParam(1);
|
|
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm)
|
|
{
|
|
const clang::NonTypeTemplateParmDecl* nttParm = (clang::NonTypeTemplateParmDecl*)endianParm;
|
|
const clang::Expr* defArg = nttParm->getDefaultArgument();
|
|
endianExpr = defArg;
|
|
if (!defArg->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(defArg->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(defArg->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const clang::TemplateArgument& arg : *tsType)
|
|
{
|
|
if (arg.getKind() == clang::TemplateArgument::Expression)
|
|
{
|
|
const clang::Expr* expr = arg.getAsExpr();
|
|
endianExpr = expr;
|
|
defaultEndian = false;
|
|
if (!expr->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(expr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(expr->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t endianVal = endian.getSExtValue();
|
|
if (endianVal != 0 && endianVal != 1)
|
|
{
|
|
if (endianExpr)
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(endianExpr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(endianExpr->getSourceRange(), true));
|
|
}
|
|
else
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
std::string ioOp;
|
|
bool isDNAType = false;
|
|
for (const clang::TemplateArgument& arg : *tsType)
|
|
{
|
|
if (arg.getKind() == clang::TemplateArgument::Type)
|
|
{
|
|
if (defaultEndian)
|
|
ioOp = GetOpString(fieldName, propIdExpr);
|
|
else
|
|
ioOp = GetOpString(fieldName, propIdExpr, endianVal);
|
|
}
|
|
}
|
|
|
|
if (ioOp.empty())
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Unable to use type '" + tsDecl->getName().str() + "' with Athena");
|
|
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
|
|
outputNodes.emplace_back(NodeType::Do, fieldName, ioOp, false);
|
|
}
|
|
else if (!tsDecl->getName().compare("Vector"))
|
|
{
|
|
llvm::APSInt endian(64, -1);
|
|
const clang::Expr* endianExpr = nullptr;
|
|
bool defaultEndian = true;
|
|
if (classParms->size() >= 3)
|
|
{
|
|
const clang::NamedDecl* endianParm = classParms->getParam(2);
|
|
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm)
|
|
{
|
|
const clang::NonTypeTemplateParmDecl* nttParm = (clang::NonTypeTemplateParmDecl*)endianParm;
|
|
const clang::Expr* defArg = nttParm->getDefaultArgument();
|
|
endianExpr = defArg;
|
|
if (!defArg->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(defArg->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(defArg->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string sizeExpr;
|
|
size_t idx = 0;
|
|
bool bad = false;
|
|
for (const clang::TemplateArgument& arg : *tsType)
|
|
{
|
|
if (arg.getKind() == clang::TemplateArgument::Expression)
|
|
{
|
|
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
|
|
if (idx == 1)
|
|
{
|
|
const clang::UnaryExprOrTypeTraitExpr* uExpr = (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 = ((clang::ParenExpr*)argExpr)->getSubExpr();
|
|
|
|
if (argExpr->getStmtClass() == clang::Stmt::DeclRefExprClass)
|
|
{
|
|
clang::DeclRefExpr* drExpr = (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 strStream(sizeExpr);
|
|
argExpr->printPretty(strStream, nullptr, context.getPrintingPolicy());
|
|
}
|
|
}
|
|
else if (idx == 2)
|
|
{
|
|
defaultEndian = false;
|
|
endianExpr = expr;
|
|
if (!expr->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(expr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(expr->getSourceRange(), true));
|
|
bad = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
++idx;
|
|
}
|
|
if (bad)
|
|
continue;
|
|
|
|
int64_t endianVal = endian.getSExtValue();
|
|
if (endianVal != 0 && endianVal != 1)
|
|
{
|
|
if (endianExpr)
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(endianExpr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(endianExpr->getSourceRange(), true));
|
|
}
|
|
else
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
clang::QualType templateType;
|
|
std::string ioOp;
|
|
bool isDNAType = false;
|
|
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, endianVal);
|
|
}
|
|
}
|
|
|
|
if (ioOp.empty())
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Unable to use type '" + templateType.getAsString() + "' with Athena");
|
|
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
|
|
if (sizeExpr.empty())
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Unable to use count variable with Athena");
|
|
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
|
|
outputNodes.emplace_back(NodeType::Do, fieldName, 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 clang::UnaryExprOrTypeTraitExpr* uExpr = (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 = ((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->getLocStart(), 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->getLocStart(), 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, fieldName, 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 clang::UnaryExprOrTypeTraitExpr* uExpr = (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 = ((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, fieldName, ioOp, false);
|
|
}
|
|
else if (!tsDecl->getName().compare("WString"))
|
|
{
|
|
llvm::APSInt endian(64, -1);
|
|
const clang::Expr* endianExpr = nullptr;
|
|
bool defaultEndian = true;
|
|
if (classParms->size() >= 2)
|
|
{
|
|
const clang::NamedDecl* endianParm = classParms->getParam(1);
|
|
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm)
|
|
{
|
|
const clang::NonTypeTemplateParmDecl* nttParm = (clang::NonTypeTemplateParmDecl*)endianParm;
|
|
const clang::Expr* defArg = nttParm->getDefaultArgument();
|
|
endianExpr = defArg;
|
|
if (!defArg->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(defArg->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(defArg->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string sizeExprStr;
|
|
size_t idx = 0;
|
|
bool bad = false;
|
|
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 clang::UnaryExprOrTypeTraitExpr* uExpr = (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 = ((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);
|
|
}
|
|
}
|
|
else if (idx == 1)
|
|
{
|
|
defaultEndian = false;
|
|
endianExpr = expr;
|
|
if (!expr->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(expr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(expr->getSourceRange(), true));
|
|
bad = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
++idx;
|
|
}
|
|
if (bad)
|
|
continue;
|
|
|
|
int64_t endianVal = endian.getSExtValue();
|
|
if (endianVal != 0 && endianVal != 1)
|
|
{
|
|
if (endianExpr)
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(endianExpr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(endianExpr->getSourceRange(), true));
|
|
}
|
|
else
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
std::string ioOp;
|
|
if (!sizeExprStr.empty())
|
|
{
|
|
if (defaultEndian)
|
|
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr);
|
|
else
|
|
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr, endianVal);
|
|
}
|
|
else
|
|
{
|
|
if (defaultEndian)
|
|
ioOp = GetOpString(fieldName, propIdExpr);
|
|
else
|
|
ioOp = GetOpString(fieldName, propIdExpr, endianVal);
|
|
}
|
|
|
|
outputNodes.emplace_back(NodeType::Do, fieldName, 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 clang::UnaryExprOrTypeTraitExpr* uExpr = (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 = ((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->getLocStart(), 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->getLocStart(), 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->getLocStart(), 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, fieldName, "<Op>("s + offsetExprStr + ", athena::Begin, s)", false);
|
|
else if (directionVal == 1)
|
|
outputNodes.emplace_back(NodeType::DoSeek, fieldName, "<Op>("s + offsetExprStr + ", athena::Current, s)", false);
|
|
else if (directionVal == 2)
|
|
outputNodes.emplace_back(NodeType::DoSeek, fieldName, "<Op>("s + offsetExprStr + ", athena::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->getLocStart(), 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;
|
|
|
|
int64_t alignVal = align.getSExtValue();
|
|
if (alignVal)
|
|
{
|
|
outputNodes.emplace_back(NodeType::DoAlign, fieldName, "<Op>("s + align.toString(10, true) + ", s)", false);
|
|
}
|
|
}
|
|
}
|
|
|
|
else if (regType->getTypeClass() == clang::Type::Record)
|
|
{
|
|
const clang::CXXRecordDecl* cxxRDecl = regType->getAsCXXRecordDecl();
|
|
std::string baseDNA;
|
|
if (cxxRDecl && isDNARecord(cxxRDecl, baseDNA))
|
|
outputNodes.emplace_back(NodeType::Do, 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{\n";
|
|
|
|
if (baseDNA.size())
|
|
fileOut << " if (" << baseDNA << "::Lookup<Op>(hash, s))\n"
|
|
<< " return true;\n";
|
|
|
|
fileOut << " switch (hash)\n"
|
|
<< " {\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 */
|
|
if (regType->getTypeClass() == clang::Type::ConstantArray)
|
|
{
|
|
const clang::ConstantArrayType* caType = (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 clang::TemplateSpecializationType* tsType = (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);
|
|
const clang::Expr* endianExpr = nullptr;
|
|
bool defaultEndian = true;
|
|
if (classParms->size() >= 2)
|
|
{
|
|
const clang::NamedDecl* endianParm = classParms->getParam(1);
|
|
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm)
|
|
{
|
|
const clang::NonTypeTemplateParmDecl* nttParm = (clang::NonTypeTemplateParmDecl*)endianParm;
|
|
const clang::Expr* defArg = nttParm->getDefaultArgument();
|
|
endianExpr = defArg;
|
|
if (!defArg->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(defArg->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(defArg->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const clang::TemplateArgument& arg : *tsType)
|
|
{
|
|
if (arg.getKind() == clang::TemplateArgument::Expression)
|
|
{
|
|
const clang::Expr* expr = arg.getAsExpr();
|
|
endianExpr = expr;
|
|
defaultEndian = false;
|
|
if (!expr->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(expr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(expr->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t endianVal = endian.getSExtValue();
|
|
if (endianVal != 0 && endianVal != 1)
|
|
{
|
|
if (endianExpr)
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(endianExpr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(endianExpr->getSourceRange(), true));
|
|
}
|
|
else
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
std::string ioOp;
|
|
bool isDNAType = false;
|
|
for (const clang::TemplateArgument& arg : *tsType)
|
|
{
|
|
if (arg.getKind() == clang::TemplateArgument::Type)
|
|
{
|
|
if (defaultEndian)
|
|
ioOp = GetOpString(fieldName, propIdExpr);
|
|
else
|
|
ioOp = GetOpString(fieldName, propIdExpr, endianVal);
|
|
}
|
|
}
|
|
|
|
if (ioOp.empty())
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Unable to use type '" + tsDecl->getName().str() + "' 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);
|
|
const clang::Expr* endianExpr = nullptr;
|
|
bool defaultEndian = true;
|
|
if (classParms->size() >= 3)
|
|
{
|
|
const clang::NamedDecl* endianParm = classParms->getParam(2);
|
|
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm)
|
|
{
|
|
const clang::NonTypeTemplateParmDecl* nttParm = (clang::NonTypeTemplateParmDecl*)endianParm;
|
|
const clang::Expr* defArg = nttParm->getDefaultArgument();
|
|
endianExpr = defArg;
|
|
if (!defArg->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(defArg->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(defArg->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string sizeExpr;
|
|
size_t idx = 0;
|
|
bool bad = false;
|
|
for (const clang::TemplateArgument& arg : *tsType)
|
|
{
|
|
if (arg.getKind() == clang::TemplateArgument::Expression)
|
|
{
|
|
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
|
|
if (idx == 1)
|
|
{
|
|
const clang::UnaryExprOrTypeTraitExpr* uExpr = (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 = ((clang::ParenExpr*)argExpr)->getSubExpr();
|
|
llvm::raw_string_ostream strStream(sizeExpr);
|
|
argExpr->printPretty(strStream, nullptr, context.getPrintingPolicy());
|
|
}
|
|
}
|
|
else if (idx == 2)
|
|
{
|
|
endianExpr = expr;
|
|
defaultEndian = false;
|
|
if (!expr->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(expr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(expr->getSourceRange(), true));
|
|
bad = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
++idx;
|
|
}
|
|
if (bad)
|
|
continue;
|
|
|
|
int64_t endianVal = endian.getSExtValue();
|
|
if (endianVal != 0 && endianVal != 1)
|
|
{
|
|
if (endianExpr)
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(endianExpr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(endianExpr->getSourceRange(), true));
|
|
}
|
|
else
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
clang::QualType templateType;
|
|
std::string ioOp;
|
|
bool isDNAType = false;
|
|
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, endianVal);
|
|
}
|
|
}
|
|
|
|
if (ioOp.empty())
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Unable to use type '" + templateType.getAsString() + "' with Athena");
|
|
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
|
|
if (sizeExpr.empty())
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), 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 clang::UnaryExprOrTypeTraitExpr* uExpr = (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 = ((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->getLocStart(), 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->getLocStart(), 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 clang::UnaryExprOrTypeTraitExpr* uExpr = (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 = ((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);
|
|
const clang::Expr* endianExpr = nullptr;
|
|
bool defaultEndian = true;
|
|
if (classParms->size() >= 2)
|
|
{
|
|
const clang::NamedDecl* endianParm = classParms->getParam(1);
|
|
if (endianParm->getKind() == clang::Decl::NonTypeTemplateParm)
|
|
{
|
|
const clang::NonTypeTemplateParmDecl* nttParm = (clang::NonTypeTemplateParmDecl*)endianParm;
|
|
const clang::Expr* defArg = nttParm->getDefaultArgument();
|
|
endianExpr = defArg;
|
|
if (!defArg->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(defArg->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(defArg->getSourceRange(), true));
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string sizeExprStr;
|
|
size_t idx = 0;
|
|
bool bad = false;
|
|
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 clang::UnaryExprOrTypeTraitExpr* uExpr = (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 = ((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);
|
|
}
|
|
}
|
|
else if (idx == 1)
|
|
{
|
|
endianExpr = expr;
|
|
defaultEndian = false;
|
|
if (!expr->isIntegerConstantExpr(endian, context))
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(expr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(expr->getSourceRange(), true));
|
|
bad = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
++idx;
|
|
}
|
|
if (bad)
|
|
continue;
|
|
|
|
int64_t endianVal = endian.getSExtValue();
|
|
if (endianVal != 0 && endianVal != 1)
|
|
{
|
|
if (endianExpr)
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(endianExpr->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(endianExpr->getSourceRange(), true));
|
|
}
|
|
else
|
|
{
|
|
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
|
|
diag.AddString("Endian value must be 'BigEndian' or 'LittleEndian'");
|
|
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
std::string ioOp;
|
|
if (!sizeExprStr.empty())
|
|
{
|
|
if (defaultEndian)
|
|
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr);
|
|
else
|
|
ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr, endianVal);
|
|
}
|
|
else
|
|
{
|
|
if (defaultEndian)
|
|
ioOp = GetOpString(fieldName, propIdExpr);
|
|
else
|
|
ioOp = GetOpString(fieldName, propIdExpr, endianVal);
|
|
}
|
|
|
|
fileOut << " AT_PROP_CASE(" << propIdExpr << "):\n"
|
|
<< " Do" << ioOp << ";\n"
|
|
<< " return true;\n";
|
|
}
|
|
}
|
|
|
|
else if (regType->getTypeClass() == clang::Type::Record)
|
|
{
|
|
const clang::CXXRecordDecl* cxxRDecl = regType->getAsCXXRecordDecl();
|
|
std::string baseDNA;
|
|
if (cxxRDecl && isDNARecord(cxxRDecl, baseDNA))
|
|
{
|
|
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->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{\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.push_back(argv[a]);
|
|
|
|
llvm::IntrusiveRefCntPtr<clang::FileManager> fman(new clang::FileManager(clang::FileSystemOptions()));
|
|
ATDNAAction* action = new ATDNAAction();
|
|
clang::tooling::ToolInvocation TI(args, action, fman.get());
|
|
if (!TI.run())
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|