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

1797 lines
96 KiB
C++
Raw Normal View History

Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
#include <stdio.h>
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendAction.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"
static unsigned AthenaError = 0;
#define ATHENA_DNA_BASETYPE "struct Athena::io::DNA"
#define ATHENA_DNA_YAMLTYPE "struct Athena::io::DNAYaml"
#define ATHENA_DNA_READER "__dna_reader"
#define ATHENA_DNA_WRITER "__dna_writer"
#define ATHENA_YAML_READER "__dna_docin"
#define ATHENA_YAML_WRITER "__dna_docout"
#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);
OS X support for atdna macro; dependency resolution fix
2015-09-02 18:49:23 +00:00
static llvm::cl::opt<bool> Verbose("v", llvm::cl::desc("verbose mode"));
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
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::OneOrMore);
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"));
OS X support for atdna macro; dependency resolution fix
2015-09-02 18:49:23 +00:00
static llvm::cl::opt<std::string> StandardCXXLib("stdlib",
llvm::cl::desc("Standard C++ library"));
static llvm::cl::list<std::string> SystemIncRoot("isysroot",
llvm::cl::desc("System include root"));
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
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, bool& isYAML)
{
for (const clang::CXXBaseSpecifier& base : record->bases())
{
const clang::QualType qtp = base.getType().getCanonicalType();
if (!qtp.getAsString().compare(0, sizeof(ATHENA_DNA_YAMLTYPE)-1, ATHENA_DNA_YAMLTYPE))
{
isYAML = true;
return true;
}
}
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, isYAML))
{
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)
baseDNA = rDecl->getName();
return true;
}
}
}
}
return false;
}
std::string GetOpString(const clang::Type* theType, unsigned width,
const std::string& fieldName, bool writerPass,
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
const std::string& funcPrefix, bool& isDNATypeOut)
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
{
isDNATypeOut = false;
if (writerPass)
{
added casts for proper enum conversion
2015-08-20 22:23:19 +00:00
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 ATHENA_DNA_WRITER ".writeBool(bool(" + fieldName + "));";
}
else if (bType->isUnsignedInteger())
{
if (width == 8)
return ATHENA_DNA_WRITER ".writeUByte(atUint8(" + fieldName + "));";
else if (width == 16)
return ATHENA_DNA_WRITER ".writeUint16" + funcPrefix + "(atUint16(" + fieldName + "));";
else if (width == 32)
return ATHENA_DNA_WRITER ".writeUint32" + funcPrefix + "(atUint32(" + fieldName + "));";
else if (width == 64)
return ATHENA_DNA_WRITER ".writeUint64" + funcPrefix + "(atUint64(" + fieldName + "));";
}
else if (bType->isSignedInteger())
{
if (width == 8)
return ATHENA_DNA_WRITER ".writeByte(atInt8(" + fieldName + "));";
else if (width == 16)
return ATHENA_DNA_WRITER ".writeInt16" + funcPrefix + "(atInt16(" + fieldName + "));";
else if (width == 32)
return ATHENA_DNA_WRITER ".writeInt32" + funcPrefix + "(atInt32(" + fieldName + "));";
else if (width == 64)
return ATHENA_DNA_WRITER ".writeInt64" + funcPrefix + "(atInt64(" + fieldName + "));";
}
}
else if (theType->isBuiltinType())
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
{
const clang::BuiltinType* bType = (clang::BuiltinType*)theType;
if (bType->isBooleanType())
{
return ATHENA_DNA_WRITER ".writeBool(" + fieldName + ");";
}
else if (bType->isUnsignedInteger())
{
if (width == 8)
return ATHENA_DNA_WRITER ".writeUByte(" + fieldName + ");";
else if (width == 16)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeUint16" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (width == 32)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeUint32" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (width == 64)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeUint64" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
else if (bType->isSignedInteger())
{
if (width == 8)
return ATHENA_DNA_WRITER ".writeByte(" + fieldName + ");";
else if (width == 16)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeInt16" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (width == 32)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeInt32" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (width == 64)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeInt64" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
else if (bType->isFloatingPoint())
{
if (width == 32)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeFloat" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (width == 64)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeDouble" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
}
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();
if (!eType->isBuiltinType() || !eType->isFloatingPoint() ||
context.getTypeInfo(eType).Width != 32)
continue;
if (vType->getNumElements() == 2)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeVec2f" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (vType->getNumElements() == 3)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeVec3f" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (vType->getNumElements() == 4)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_WRITER ".writeVec4f" + funcPrefix + "(" + fieldName + ");";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
}
}
std::string baseDNA;
bool isYAML = false;
if (isDNARecord(rDecl, baseDNA, isYAML))
{
isDNATypeOut = true;
return "write(" ATHENA_DNA_WRITER ");";
}
}
}
else
{
added casts for proper enum conversion
2015-08-20 22:23:19 +00:00
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 eDecl->getName().str() + "(" ATHENA_DNA_READER ".readBool())";
}
else if (bType->isUnsignedInteger())
{
if (width == 8)
return eDecl->getName().str() + "(" ATHENA_DNA_READER ".readUByte())";
else if (width == 16)
return eDecl->getName().str() + "(" ATHENA_DNA_READER ".readUint16" + funcPrefix + "())";
else if (width == 32)
return eDecl->getName().str() + "(" ATHENA_DNA_READER ".readUint32" + funcPrefix + "())";
else if (width == 64)
return eDecl->getName().str() + "(" ATHENA_DNA_READER ".readUint64" + funcPrefix + "())";
}
else if (bType->isSignedInteger())
{
if (width == 8)
return eDecl->getName().str() + "(" ATHENA_DNA_READER ".readByte()";
else if (width == 16)
return eDecl->getName().str() + "(" ATHENA_DNA_READER ".readInt16" + funcPrefix + "())";
else if (width == 32)
return eDecl->getName().str() + "(" ATHENA_DNA_READER ".readInt32" + funcPrefix + "())";
else if (width == 64)
return eDecl->getName().str() + "(" ATHENA_DNA_READER ".readInt64" + funcPrefix + "())";
}
}
else if (theType->isBuiltinType())
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
{
const clang::BuiltinType* bType = (clang::BuiltinType*)theType;
if (bType->isBooleanType())
{
return ATHENA_DNA_READER ".readBool()";
}
else if (bType->isUnsignedInteger())
{
if (width == 8)
return ATHENA_DNA_READER ".readUByte()";
else if (width == 16)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readUint16" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (width == 32)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readUint32" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (width == 64)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readUint64" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
else if (bType->isSignedInteger())
{
if (width == 8)
return ATHENA_DNA_READER ".readByte()";
else if (width == 16)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readInt16" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (width == 32)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readInt32" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (width == 64)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readInt64" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
else if (bType->isFloatingPoint())
{
if (width == 32)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readFloat" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (width == 64)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readDouble" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
}
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();
if (!eType->isBuiltinType() || !eType->isFloatingPoint() ||
context.getTypeInfo(eType).Width != 32)
continue;
if (vType->getNumElements() == 2)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readVec2f" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (vType->getNumElements() == 3)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readVec3f" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else if (vType->getNumElements() == 4)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
return ATHENA_DNA_READER ".readVec4f" + funcPrefix + "()";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
}
}
std::string baseDNA;
bool isYAML = false;
if (isDNARecord(rDecl, baseDNA, isYAML))
{
isDNATypeOut = true;
return "read(" ATHENA_DNA_READER ");";
}
}
}
return std::string();
}
std::string GetYAMLString(const clang::Type* theType, unsigned width,
const std::string& fieldName, const std::string& bareFieldName,
bool writerPass, bool& isDNATypeOut)
{
isDNATypeOut = false;
if (writerPass)
{
added casts for proper enum conversion
2015-08-20 22:23:19 +00:00
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 ATHENA_YAML_WRITER ".writeBool(\"" + bareFieldName + "\", bool(" + fieldName + "));";
}
else if (bType->isUnsignedInteger())
{
if (width == 8)
return ATHENA_YAML_WRITER ".writeUByte(\"" + bareFieldName + "\", atUint8(" + fieldName + "));";
else if (width == 16)
return ATHENA_YAML_WRITER ".writeUint16(\"" + bareFieldName + "\", atUint16(" + fieldName + "));";
else if (width == 32)
return ATHENA_YAML_WRITER ".writeUint32(\"" + bareFieldName + "\", atUint32(" + fieldName + "));";
else if (width == 64)
return ATHENA_YAML_WRITER ".writeUint64(\"" + bareFieldName + "\", atUint64(" + fieldName + "));";
}
else if (bType->isSignedInteger())
{
if (width == 8)
return ATHENA_YAML_WRITER ".writeByte(\"" + bareFieldName + "\", atInt8(" + fieldName + "));";
else if (width == 16)
return ATHENA_YAML_WRITER ".writeInt16(\"" + bareFieldName + "\", atInt16(" + fieldName + "));";
else if (width == 32)
return ATHENA_YAML_WRITER ".writeInt32(\"" + bareFieldName + "\", atInt32(" + fieldName + "));";
else if (width == 64)
return ATHENA_YAML_WRITER ".writeInt64(\"" + bareFieldName + "\", atInt64(" + fieldName + "));";
}
}
else if (theType->isBuiltinType())
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
{
const clang::BuiltinType* bType = (clang::BuiltinType*)theType;
if (bType->isBooleanType())
{
return ATHENA_YAML_WRITER ".writeBool(\"" + bareFieldName + "\", " + fieldName + ");";
}
else if (bType->isUnsignedInteger())
{
if (width == 8)
return ATHENA_YAML_WRITER ".writeUByte(\"" + bareFieldName + "\", " + fieldName + ");";
else if (width == 16)
return ATHENA_YAML_WRITER ".writeUint16(\"" + bareFieldName + "\", " + fieldName + ");";
else if (width == 32)
return ATHENA_YAML_WRITER ".writeUint32(\"" + bareFieldName + "\", " + fieldName + ");";
else if (width == 64)
return ATHENA_YAML_WRITER ".writeUint64(\"" + bareFieldName + "\", " + fieldName + ");";
}
else if (bType->isSignedInteger())
{
if (width == 8)
return ATHENA_YAML_WRITER ".writeByte(\"" + bareFieldName + "\", " + fieldName + ");";
else if (width == 16)
return ATHENA_YAML_WRITER ".writeInt16(\"" + bareFieldName + "\", " + fieldName + ");";
else if (width == 32)
return ATHENA_YAML_WRITER ".writeInt32(\"" + bareFieldName + "\", " + fieldName + ");";
else if (width == 64)
return ATHENA_YAML_WRITER ".writeInt64(\"" + bareFieldName + "\", " + fieldName + ");";
}
else if (bType->isFloatingPoint())
{
if (width == 32)
return ATHENA_YAML_WRITER ".writeFloat(\"" + bareFieldName + "\", " + fieldName + ");";
else if (width == 64)
return ATHENA_YAML_WRITER ".writeDouble(\"" + bareFieldName + "\", " + fieldName + ");";
}
}
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();
if (!eType->isBuiltinType() || !eType->isFloatingPoint() ||
context.getTypeInfo(eType).Width != 32)
continue;
if (vType->getNumElements() == 2)
return ATHENA_YAML_WRITER ".writeVec2f(\"" + bareFieldName + "\", " + fieldName + ");";
else if (vType->getNumElements() == 3)
return ATHENA_YAML_WRITER ".writeVec3f(\"" + bareFieldName + "\", " + fieldName + ");";
else if (vType->getNumElements() == 4)
return ATHENA_YAML_WRITER ".writeVec4f(\"" + bareFieldName + "\", " + fieldName + ");";
}
}
}
std::string baseDNA;
bool isYAML = false;
if (isDNARecord(rDecl, baseDNA, isYAML))
{
isDNATypeOut = true;
return "toYAML(" ATHENA_YAML_WRITER ");";
}
}
}
else
{
added casts for proper enum conversion
2015-08-20 22:23:19 +00:00
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 eDecl->getName().str() + "(" ATHENA_YAML_READER ".readBool(\"" + bareFieldName + "\"))";
}
else if (bType->isUnsignedInteger())
{
if (width == 8)
return eDecl->getName().str() + "(" ATHENA_YAML_READER ".readUByte(\"" + bareFieldName + "\"))";
else if (width == 16)
return eDecl->getName().str() + "(" ATHENA_YAML_READER ".readUint16(\"" + bareFieldName + "\"))";
else if (width == 32)
return eDecl->getName().str() + "(" ATHENA_YAML_READER ".readUint32(\"" + bareFieldName + "\"))";
else if (width == 64)
return eDecl->getName().str() + "(" ATHENA_YAML_READER ".readUint64(\"" + bareFieldName + "\"))";
}
else if (bType->isSignedInteger())
{
if (width == 8)
return eDecl->getName().str() + "(" ATHENA_YAML_READER ".readByte(\"" + bareFieldName + "\"))";
else if (width == 16)
return eDecl->getName().str() + "(" ATHENA_YAML_READER ".readInt16(\"" + bareFieldName + "\"))";
else if (width == 32)
return eDecl->getName().str() + "(" ATHENA_YAML_READER ".readInt32(\"" + bareFieldName + "\"))";
else if (width == 64)
return eDecl->getName().str() + "(" ATHENA_YAML_READER ".readInt64(\"" + bareFieldName + "\"))";
}
}
else if (theType->isBuiltinType())
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
{
const clang::BuiltinType* bType = (clang::BuiltinType*)theType;
if (bType->isBooleanType())
{
return ATHENA_YAML_READER ".readBool(\"" + bareFieldName + "\")";
}
else if (bType->isUnsignedInteger())
{
if (width == 8)
return ATHENA_YAML_READER ".readUByte(\"" + bareFieldName + "\")";
else if (width == 16)
return ATHENA_YAML_READER ".readUint16(\"" + bareFieldName + "\")";
else if (width == 32)
return ATHENA_YAML_READER ".readUint32(\"" + bareFieldName + "\")";
else if (width == 64)
return ATHENA_YAML_READER ".readUint64(\"" + bareFieldName + "\")";
}
else if (bType->isSignedInteger())
{
if (width == 8)
return ATHENA_YAML_READER ".readByte(\"" + bareFieldName + "\")";
else if (width == 16)
return ATHENA_YAML_READER ".readInt16(\"" + bareFieldName + "\")";
else if (width == 32)
return ATHENA_YAML_READER ".readInt32(\"" + bareFieldName + "\")";
else if (width == 64)
return ATHENA_YAML_READER ".readInt64(\"" + bareFieldName + "\")";
}
else if (bType->isFloatingPoint())
{
if (width == 32)
return ATHENA_YAML_READER ".readFloat(\"" + bareFieldName + "\")";
else if (width == 64)
return ATHENA_YAML_READER ".readDouble(\"" + bareFieldName + "\")";
}
}
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();
if (!eType->isBuiltinType() || !eType->isFloatingPoint() ||
context.getTypeInfo(eType).Width != 32)
continue;
if (vType->getNumElements() == 2)
return ATHENA_YAML_READER ".readVec2f(\"" + bareFieldName + "\")";
else if (vType->getNumElements() == 3)
return ATHENA_YAML_READER ".readVec3f(\"" + bareFieldName + "\")";
else if (vType->getNumElements() == 4)
return ATHENA_YAML_READER ".readVec4f(\"" + bareFieldName + "\")";
}
}
}
std::string baseDNA;
bool isYAML = false;
if (isDNARecord(rDecl, baseDNA, isYAML))
{
isDNATypeOut = true;
return "fromYAML(" ATHENA_YAML_READER ");";
}
}
}
return std::string();
}
void emitIOFuncs(clang::CXXRecordDecl* decl, const std::string& baseDNA)
{
/* Two passes - read then write */
for (int p=0 ; p<2 ; ++p)
{
if (p)
fileOut << "void " << decl->getQualifiedNameAsString() << "::write(Athena::io::IStreamWriter& " ATHENA_DNA_WRITER ") const\n{\n";
else
fileOut << "void " << decl->getQualifiedNameAsString() << "::read(Athena::io::IStreamReader& " ATHENA_DNA_READER ")\n{\n";
if (baseDNA.size())
{
if (p)
fileOut << " " << baseDNA << "::write(" ATHENA_DNA_WRITER ");\n";
else
fileOut << " " << baseDNA << "::read(" ATHENA_DNA_READER ");\n";
}
for (const clang::FieldDecl* field : decl->fields())
{
clang::QualType qualType = field->getType();
clang::TypeInfo regTypeInfo = context.getTypeInfo(qualType);
const clang::Type* regType = qualType.getTypePtrOrNull();
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
while (regType->getTypeClass() == clang::Type::Elaborated ||
regType->getTypeClass() == clang::Type::Typedef)
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
regType = regType->getUnqualifiedDesugaredType();
/* Resolve constant array */
size_t arraySize = 1;
bool isArray = false;
if (regType->getTypeClass() == clang::Type::ConstantArray)
{
isArray = true;
const clang::ConstantArrayType* caType = (clang::ConstantArrayType*)regType;
arraySize = caType->getSize().getZExtValue();
qualType = caType->getElementType();
regTypeInfo = context.getTypeInfo(qualType);
regType = qualType.getTypePtrOrNull();
if (regType->getTypeClass() == clang::Type::Elaborated)
regType = regType->getUnqualifiedDesugaredType();
}
for (int e=0 ; e<arraySize ; ++e)
{
std::string fieldName;
if (isArray)
{
char subscript[16];
snprintf(subscript, 16, "[%d]", e);
fieldName = field->getName().str() + subscript;
}
else
fieldName = field->getName();
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;
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))
{
if (!p)
{
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)
{
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
if (arg.getKind() == clang::TemplateArgument::Expression)
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
{
const clang::Expr* expr = arg.getAsExpr();
endianExpr = expr;
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
if (!expr->isIntegerConstantExpr(endian, context))
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
{
if (!p)
{
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;
}
}
}
int endianVal = endian.getSExtValue();
if (endianVal != 0 && endianVal != 1)
{
if (!p)
{
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;
}
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
std::string funcPrefix;
if (endianVal == 0)
funcPrefix = "Little";
else if (endianVal == 1)
funcPrefix = "Big";
clang::QualType templateType;
std::string ioOp;
bool isDNAType = false;
const clang::TemplateArgument* typeArg = nullptr;
for (const clang::TemplateArgument& arg : *tsType)
{
if (arg.getKind() == clang::TemplateArgument::Type)
{
typeArg = &arg;
templateType = arg.getAsType().getCanonicalType();
const clang::Type* type = arg.getAsType().getCanonicalType().getTypePtr();
ioOp = GetOpString(type, regTypeInfo.Width, fieldName, p, funcPrefix, isDNAType);
}
}
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
if (ioOp.empty())
{
if (!p)
{
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 << " /* " << fieldName << " */\n";
if (!p)
fileOut << " " << fieldName << " = " << ioOp << ";\n";
else
fileOut << " " << ioOp << "\n";
}
else if (!tsDecl->getName().compare("Vector"))
{
llvm::APSInt endian(64, -1);
const clang::Expr* endianExpr = nullptr;
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))
{
if (!p)
{
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;
const clang::TemplateArgument* sizeArg = nullptr;
size_t idx = 0;
bool bad = false;
for (const clang::TemplateArgument& arg : *tsType)
{
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
if (arg.getKind() == clang::TemplateArgument::Expression)
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
{
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
if (idx == 1)
{
sizeArg = &arg;
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;
if (!expr->isIntegerConstantExpr(endian, context))
{
if (!p)
{
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;
int endianVal = endian.getSExtValue();
if (endianVal != 0 && endianVal != 1)
{
if (!p)
{
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;
}
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
std::string funcPrefix;
if (endianVal == 0)
funcPrefix = "Little";
else if (endianVal == 1)
funcPrefix = "Big";
clang::QualType templateType;
std::string ioOp;
bool isDNAType = false;
const clang::TemplateArgument* typeArg = nullptr;
for (const clang::TemplateArgument& arg : *tsType)
{
if (arg.getKind() == clang::TemplateArgument::Type)
{
typeArg = &arg;
templateType = arg.getAsType().getCanonicalType();
clang::TypeInfo typeInfo = context.getTypeInfo(templateType);
static const std::string elemStr = "elem";
ioOp = GetOpString(templateType.getTypePtr(), typeInfo.Width, elemStr, p, funcPrefix, isDNAType);
}
}
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
if (ioOp.empty())
{
if (!p)
{
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())
{
if (!p)
{
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;
}
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
if (isDNAType)
funcPrefix.clear();
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
fileOut << " /* " << fieldName << " */\n";
if (!p)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
fileOut << " " ATHENA_DNA_READER ".enumerate" << funcPrefix << "(" << fieldName << ", " << sizeExpr << ");\n";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
fileOut << " " ATHENA_DNA_WRITER ".enumerate" << funcPrefix << "(" << fieldName << ");\n";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
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 (!p)
{
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;
}
fileOut << " /* " << fieldName << " */\n";
if (!p)
{
fileOut << " " << fieldName << ".reset(new atUint8[" << sizeExprStr << "]);\n"
" " ATHENA_DNA_READER ".readUBytesToBuf(" << fieldName << ".get(), " << sizeExprStr << ");\n";
}
else
{
fileOut << " " ATHENA_DNA_WRITER ".writeUBytes(" << fieldName << ".get(), " << sizeExprStr << ");\n";
}
}
else if (!tsDecl->getName().compare("String"))
{
const clang::Expr* sizeExpr = nullptr;
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();
sizeExpr = argExpr;
llvm::raw_string_ostream strStream(sizeExprStr);
argExpr->printPretty(strStream, nullptr, context.getPrintingPolicy());
}
else if (expr->isIntegerConstantExpr(sizeLiteral, context))
{
sizeExprStr = sizeLiteral.toString(10);
}
}
}
fileOut << " /* " << fieldName << " */\n";
if (!p)
fileOut << " " << fieldName << " = " ATHENA_DNA_READER ".readString(" << sizeExprStr << ");\n";
else
{
fileOut << " " ATHENA_DNA_WRITER ".writeString(" << fieldName;
if (sizeExprStr.size())
fileOut << ", " << sizeExprStr;
fileOut << ");\n";
}
}
else if (!tsDecl->getName().compare("WString"))
{
llvm::APSInt endian(64, -1);
const clang::Expr* endianExpr = nullptr;
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))
{
if (!p)
{
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;
}
}
}
const clang::Expr* sizeExpr = nullptr;
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();
sizeExpr = argExpr;
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;
if (!expr->isIntegerConstantExpr(endian, context))
{
if (!p)
{
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;
int endianVal = endian.getSExtValue();
if (endianVal != 0 && endianVal != 1)
{
if (!p)
{
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;
}
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
std::string funcPrefix;
if (endianVal == 0)
funcPrefix = "Little";
else if (endianVal == 1)
funcPrefix = "Big";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
fileOut << " /* " << fieldName << " */\n";
if (!p)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
fileOut << " " << fieldName << " = " ATHENA_DNA_READER ".readWString" << funcPrefix << "(" << sizeExprStr << ");\n";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else
{
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
fileOut << " " ATHENA_DNA_WRITER ".writeWString" << funcPrefix << "(" << fieldName;
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
if (sizeExprStr.size())
fileOut << ", " << sizeExprStr;
fileOut << ");\n";
}
}
else if (!tsDecl->getName().compare("WStringAsString"))
{
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
llvm::APSInt endian(64, -1);
const clang::Expr* endianExpr = nullptr;
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))
{
if (!p)
{
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;
}
}
}
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
const clang::Expr* sizeExpr = nullptr;
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();
sizeExpr = argExpr;
llvm::raw_string_ostream strStream(sizeExprStr);
argExpr->printPretty(strStream, nullptr, context.getPrintingPolicy());
}
else if (expr->isIntegerConstantExpr(sizeLiteral, context))
{
sizeExprStr = sizeLiteral.toString(10);
}
}
}
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
int endianVal = endian.getSExtValue();
if (endianVal != 0 && endianVal != 1)
{
if (!p)
{
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 funcPrefix;
if (endianVal == 0)
funcPrefix = "Little";
else if (endianVal == 1)
funcPrefix = "Big";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
fileOut << " /* " << fieldName << " */\n";
if (!p)
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
fileOut << " " << fieldName << " = " ATHENA_DNA_READER ".readWStringAsString" << funcPrefix << "(" << sizeExprStr << ");\n";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else
{
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
fileOut << " " ATHENA_DNA_WRITER ".writeStringAsWString" << funcPrefix << "(" << fieldName;
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
if (sizeExprStr.size())
fileOut << ", " << sizeExprStr;
fileOut << ");\n";
}
}
else if (!tsDecl->getName().compare("Seek"))
{
size_t idx = 0;
const clang::Expr* offsetExpr = nullptr;
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)
{
offsetExpr = expr;
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();
offsetExpr = argExpr;
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))
{
if (!p)
{
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 (!p)
{
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;
}
fileOut << " /* " << fieldName << " */\n";
if (directionVal == 0)
{
if (!p)
fileOut << " " ATHENA_DNA_READER ".seek(" << offsetExprStr << ", Athena::Begin);\n";
else
fileOut << " " ATHENA_DNA_WRITER ".seek(" << offsetExprStr << ", Athena::Begin);\n";
}
else if (directionVal == 1)
{
if (!p)
fileOut << " " ATHENA_DNA_READER ".seek(" << offsetExprStr << ", Athena::Current);\n";
else
fileOut << " " ATHENA_DNA_WRITER ".seek(" << offsetExprStr << ", Athena::Current);\n";
}
else if (directionVal == 2)
{
if (!p)
fileOut << " " ATHENA_DNA_READER ".seek(" << offsetExprStr << ", Athena::End);\n";
else
fileOut << " " ATHENA_DNA_WRITER ".seek(" << offsetExprStr << ", Athena::End);\n";
}
}
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))
{
if (!p)
{
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)
{
fileOut << " /* " << fieldName << " */\n";
if (alignVal == 32)
{
if (!p)
fileOut << " " ATHENA_DNA_READER ".seekAlign32();\n";
else
fileOut << " " ATHENA_DNA_WRITER ".seekAlign32();\n";
}
else if (align.isPowerOf2())
{
if (!p)
fileOut << " " ATHENA_DNA_READER ".seek((" ATHENA_DNA_READER ".position() + " << alignVal-1 << ") & ~" << alignVal-1 << ", Athena::Begin);\n";
else
fileOut << " " ATHENA_DNA_WRITER ".seek((" ATHENA_DNA_WRITER ".position() + " << alignVal-1 << ") & ~" << alignVal-1 << ", Athena::Begin);\n";
}
else
{
if (!p)
fileOut << " " ATHENA_DNA_READER ".seek((" ATHENA_DNA_READER ".position() + " << alignVal-1 << ") / " << alignVal << " * " << alignVal << ", Athena::Begin);\n";
else
fileOut << " " ATHENA_DNA_WRITER ".seek((" ATHENA_DNA_WRITER ".position() + " << alignVal-1 << ") / " << alignVal << " * " << alignVal << ", Athena::Begin);\n";
}
}
}
}
else if (regType->getTypeClass() == clang::Type::Record)
{
const clang::CXXRecordDecl* cxxRDecl = regType->getAsCXXRecordDecl();
std::string baseDNA;
bool isYAML = false;
if (cxxRDecl && isDNARecord(cxxRDecl, baseDNA, isYAML))
{
fileOut << " /* " << fieldName << " */\n"
" " << fieldName << (p ? ".write(" ATHENA_DNA_WRITER ");\n" : ".read(" ATHENA_DNA_READER ");\n");
break;
}
}
}
}
fileOut << "}\n\n";
}
}
void emitYAMLFuncs(clang::CXXRecordDecl* decl, const std::string& baseDNA)
{
/* Two passes - read then write */
for (int p=0 ; p<2 ; ++p)
{
if (p)
fileOut << "void " << decl->getQualifiedNameAsString() << "::toYAML(Athena::io::YAMLDocWriter& " ATHENA_YAML_WRITER ") const\n{\n";
else
fileOut << "void " << decl->getQualifiedNameAsString() << "::fromYAML(Athena::io::YAMLDocReader& " ATHENA_YAML_READER ")\n{\n";
if (baseDNA.size())
{
if (p)
fileOut << " " << baseDNA << "::toYAML(" ATHENA_YAML_WRITER ");\n";
else
fileOut << " " << baseDNA << "::fromYAML(" ATHENA_YAML_READER ");\n";
}
for (const clang::FieldDecl* field : decl->fields())
{
clang::QualType qualType = field->getType();
clang::TypeInfo regTypeInfo = context.getTypeInfo(qualType);
const clang::Type* regType = qualType.getTypePtrOrNull();
Added explicit Big/Little method suffix
2015-08-14 02:58:04 +00:00
while (regType->getTypeClass() == clang::Type::Elaborated ||
regType->getTypeClass() == clang::Type::Typedef)
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
regType = regType->getUnqualifiedDesugaredType();
/* Resolve constant array */
size_t arraySize = 1;
bool isArray = false;
if (regType->getTypeClass() == clang::Type::ConstantArray)
{
isArray = true;
const clang::ConstantArrayType* caType = (clang::ConstantArrayType*)regType;
arraySize = caType->getSize().getZExtValue();
qualType = caType->getElementType();
regTypeInfo = context.getTypeInfo(qualType);
regType = qualType.getTypePtrOrNull();
if (regType->getTypeClass() == clang::Type::Elaborated)
regType = regType->getUnqualifiedDesugaredType();
if (!p)
fileOut << " " ATHENA_YAML_READER ".enterSubVector(\"" << field->getName() << "\");\n";
else
fileOut << " " ATHENA_YAML_WRITER ".enterSubVector(\"" << field->getName() << "\");\n";
}
for (int e=0 ; e<arraySize ; ++e)
{
std::string fieldNameBare = field->getName();
std::string fieldName;
if (isArray)
{
char subscript[16];
snprintf(subscript, 16, "[%d]", e);
fieldName = fieldNameBare + subscript;
}
else
fieldName = fieldNameBare;
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;
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))
continue;
}
}
clang::QualType templateType;
std::string ioOp;
bool isDNAType = false;
const clang::TemplateArgument* typeArg = nullptr;
for (const clang::TemplateArgument& arg : *tsType)
{
if (arg.getKind() == clang::TemplateArgument::Type)
{
typeArg = &arg;
templateType = arg.getAsType().getCanonicalType();
const clang::Type* type = arg.getAsType().getCanonicalType().getTypePtr();
ioOp = GetYAMLString(type, regTypeInfo.Width, fieldName, fieldNameBare, p, isDNAType);
}
else if (arg.getKind() == clang::TemplateArgument::Expression)
{
const clang::Expr* expr = arg.getAsExpr();
endianExpr = expr;
if (expr->isIntegerConstantExpr(endian, context))
continue;
}
}
int endianVal = endian.getSExtValue();
if (endianVal != 0 && endianVal != 1)
continue;
if (ioOp.empty())
continue;
fileOut << " /* " << fieldName << " */\n";
if (!p)
fileOut << " " << fieldName << " = " << ioOp << ";\n";
else
fileOut << " " << ioOp << "\n";
}
else if (!tsDecl->getName().compare("Vector"))
{
llvm::APSInt endian(64, -1);
const clang::Expr* endianExpr = nullptr;
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))
continue;
}
}
clang::QualType templateType;
std::string ioOp;
bool isDNAType = false;
std::string sizeExpr;
const clang::TemplateArgument* typeArg = nullptr;
const clang::TemplateArgument* sizeArg = nullptr;
size_t idx = 0;
bool bad = false;
for (const clang::TemplateArgument& arg : *tsType)
{
if (arg.getKind() == clang::TemplateArgument::Type)
{
typeArg = &arg;
templateType = arg.getAsType().getCanonicalType();
clang::TypeInfo typeInfo = context.getTypeInfo(templateType);
ioOp = GetYAMLString(templateType.getTypePtr(), typeInfo.Width, "elem", fieldNameBare, p, isDNAType);
}
else if (arg.getKind() == clang::TemplateArgument::Expression)
{
const clang::Expr* expr = arg.getAsExpr()->IgnoreImpCasts();
if (idx == 1)
{
sizeArg = &arg;
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;
if (!expr->isIntegerConstantExpr(endian, context))
{
bad = true;
break;
}
}
}
++idx;
}
if (bad)
continue;
int endianVal = endian.getSExtValue();
if (endianVal != 0 && endianVal != 1)
continue;
if (ioOp.empty())
continue;
if (sizeExpr.empty())
continue;
fileOut << " /* " << fieldName << " */\n";
if (!p)
Added some SFINAE parameters for smart IO templates
2015-08-08 23:25:18 +00:00
fileOut << " " ATHENA_YAML_READER ".enumerate(\"" << fieldNameBare << "\", " << fieldName << ", " << sizeExpr << ");\n";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
else
Added some SFINAE parameters for smart IO templates
2015-08-08 23:25:18 +00:00
fileOut << " " ATHENA_YAML_WRITER ".enumerate(\"" << fieldNameBare << "\", " << fieldName << ");\n";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
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())
continue;
fileOut << " /* " << fieldName << " */\n";
if (!p)
fileOut << " " << fieldName << " = " ATHENA_YAML_READER ".readUBytes(\"" << fieldNameBare << "\");\n";
else
fileOut << " " ATHENA_YAML_WRITER ".writeUBytes(\"" << fieldNameBare << "\", " << fieldName << ", " << sizeExprStr << ");\n";
}
else if (!tsDecl->getName().compare("String") ||
!tsDecl->getName().compare("WStringAsString"))
{
fileOut << " /* " << fieldName << " */\n";
if (!p)
fileOut << " " << fieldName << " = " ATHENA_YAML_READER ".readString(\"" << fieldNameBare << "\");\n";
else
fileOut << " " ATHENA_YAML_WRITER ".writeString(\"" << fieldNameBare << "\", " << fieldName << ");\n";
}
else if (!tsDecl->getName().compare("WString"))
{
llvm::APSInt endian(64, -1);
const clang::Expr* endianExpr = nullptr;
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))
continue;
}
}
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)
{
endianExpr = expr;
if (!expr->isIntegerConstantExpr(endian, context))
{
bad = true;
break;
}
}
}
++idx;
}
if (bad)
continue;
int endianVal = endian.getSExtValue();
if (endianVal != 0 && endianVal != 1)
continue;
fileOut << " /* " << fieldName << " */\n";
if (!p)
fileOut << " " << fieldName << " = " ATHENA_YAML_READER ".readWString(\"" << fieldNameBare << "\");\n";
else
fileOut << " " ATHENA_YAML_WRITER ".writeWString(\"" << fieldNameBare << "\", " << fieldName << ");\n";
}
}
else if (regType->getTypeClass() == clang::Type::Record)
{
const clang::CXXRecordDecl* cxxRDecl = regType->getAsCXXRecordDecl();
std::string baseDNA;
bool isYAML = false;
if (cxxRDecl && isDNARecord(cxxRDecl, baseDNA, isYAML))
{
if (!p)
{
fileOut << " /* " << fieldName << " */\n"
Added some SFINAE parameters for smart IO templates
2015-08-08 23:25:18 +00:00
" " ATHENA_YAML_READER ".enumerate(\"" << fieldNameBare << "\", " << fieldName << ");\n";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
else
{
fileOut << " /* " << fieldName << " */\n"
Added some SFINAE parameters for smart IO templates
2015-08-08 23:25:18 +00:00
" " ATHENA_YAML_WRITER ".enumerate(\"" << fieldNameBare << "\", " << fieldName << ");\n";
Embedded atdna in Athena
2015-08-03 01:42:47 +00:00
}
break;
}
}
}
if (isArray)
{
if (!p)
fileOut << " " ATHENA_YAML_READER ".leaveSubVector();\n";
else
fileOut << " " ATHENA_YAML_WRITER ".leaveSubVector();\n";
}
}
fileOut << "}\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())
return true;
if (!decl->getNumBases())
return true;
/* First ensure this inherits from struct Athena::io::DNA */
std::string baseDNA;
bool isYAML = false;
if (!isDNARecord(decl, baseDNA, isYAML))
return true;
/* Make sure there aren't namespace conflicts or Delete meta type */
for (const clang::FieldDecl* field : decl->fields())
{
if (!field->getName().compare(ATHENA_DNA_READER) ||
!field->getName().compare(ATHENA_DNA_WRITER))
{
clang::DiagnosticBuilder diag = context.getDiagnostics().Report(field->getLocStart(), AthenaError);
diag.AddString("Field may not be named '" ATHENA_DNA_READER "' or '" ATHENA_DNA_WRITER "'");
diag.AddSourceRange(clang::CharSourceRange(field->getSourceRange(), true));
return true;
}
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;
}
}
}
}
}
emitIOFuncs(decl, baseDNA);
if (isYAML)
emitYAMLFuncs(decl, baseDNA);
return true;
}
};
class ATDNAConsumer : public clang::ASTConsumer
{
ATDNAEmitVisitor emitVisitor;
StreamOut& fileOut;
public:
explicit ATDNAConsumer(clang::ASTContext& context, StreamOut& fo)
: emitVisitor(context, fo),
fileOut(fo) {}
void HandleTranslationUnit(clang::ASTContext& context)
{
/* Write file head */
fileOut << "/* Auto generated atdna implementation */\n"
"#include <Athena/Global.hpp>\n"
"#include <Athena/IStreamReader.hpp>\n"
"#include <Athena/IStreamWriter.hpp>\n\n";
for (const std::string& inputf : InputFilenames)
fileOut << "#include \"" << inputf << "\"\n";
fileOut << "\n";
/* Emit file */
emitVisitor.TraverseDecl(context.getTranslationUnitDecl());
}
};
class ATDNAAction : public clang::ASTFrontendAction
{
public:
explicit ATDNAAction() {}
std::unique_ptr<clang::ASTConsumer> CreateASTConsumer(clang::CompilerInstance& compiler,
llvm::StringRef /*filename*/)
{
StreamOut* fileout;
if (OutputFilename.size())
fileout = compiler.createOutputFile(OutputFilename, false, true, "", "", true);
else
fileout = compiler.createDefaultOutputFile(false, "a", "cpp");
AthenaError = compiler.getASTContext().getDiagnostics().getCustomDiagID(clang::DiagnosticsEngine::Error, "Athena error: %0");
return std::unique_ptr<clang::ASTConsumer>(new ATDNAConsumer(compiler.getASTContext(), *fileout));
}
};
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",
"-fsyntax-only",
"-std=c++11",
"-D__atdna__=1",
"-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()));
clang::tooling::ToolInvocation TI(args, new ATDNAAction, fman.get());
if (!TI.run())
return 1;
return 0;
}