trick/trick_source/codegen/Interface_Code_Gen/ConstructValues.cpp

221 lines
7.9 KiB
C++
Raw Normal View History

2015-02-26 15:02:31 +00:00
#include <iostream>
#include <sstream>
#include <clang/AST/DeclTemplate.h>
2015-02-26 15:02:31 +00:00
#include "ConstructValues.hh"
//====================================================================================
bool ConstructValues::ContainerClass::extractTemplateArgType(const clang::TemplateArgument& ta) {
clang::QualType qt = ta.getAsType() ;
const clang::Type * t = qt.getTypePtrOrNull() ;
if ( t != NULL ) {
ContainerClass inner_cc ;
if (t->getTypeClass() == clang::Type::Record and t->getAsCXXRecordDecl()) {
clang::CXXRecordDecl * crd = t->getAsCXXRecordDecl() ;
if ( clang::isa<clang::ClassTemplateSpecializationDecl>(crd) ) {
// template argument is a template specialization
if (!inner_cc.extractType(clang::cast<clang::ClassTemplateSpecializationDecl>(crd))) {
return false ;
}
} else {
// template argument record type, but not a template specialization
inner_cc.name = qt.getAsString() ;
}
} else {
// template argument not a record type.
inner_cc.name = qt.getAsString() ;
}
template_args.push_back(inner_cc) ;
}
return true ;
}
bool ConstructValues::ContainerClass::extractType(const clang::RecordDecl * rd) {
if (! rd->getIdentifier()) {
return false ;
}
// Set the name of this type.
name = rd->getName().str() ;
// If this type is a template specialization we need to save the template argument types.
if (const clang::ClassTemplateSpecializationDecl *ctsd = clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(rd)) {
for (const clang::TemplateArgument& ta : ctsd->getTemplateArgs().asArray()) {
if ( ta.getKind() == clang::TemplateArgument::Type ) {
// Class types and intrinsic types
if ( !extractTemplateArgType(ta) ) {
return false ;
}
} else if ( ta.getKind() == clang::TemplateArgument::Pack ) {
// a Pack is the variables in a variadric template
for (const clang::TemplateArgument& pack_ta : ta.getPackAsArray()) {
if ( pack_ta.getKind() == clang::TemplateArgument::Type ) {
if ( !extractTemplateArgType(pack_ta) ) {
return false ;
}
}
}
} else {
// This template argument is not a clang::TemplateArgument::Type. We don't currently handle these.
return false ;
}
}
}
// if we reach the end then we can deal with the class name, return true.
return true ;
}
static void mangle_template_param(std::string &work_string, const std::string & delimiter) {
if ( !delimiter.compare("__") ) {
std::replace( work_string.begin(), work_string.end(), '*', '_') ;
std::replace( work_string.begin(), work_string.end(), '[', '_') ;
std::replace( work_string.begin(), work_string.end(), ']', '_') ;
work_string.erase(std::remove_if(work_string.begin(), work_string.end(),
(int(*)(int))std::isspace), work_string.end()) ;
}
}
void ConstructValues::ContainerClass::printTemplateList(std::ostream& ostream, const std::string& delimiter) {
if ( template_args.size() ) {
std::string obracket("<"), comma(","), cbracket(">"), work_string ;
if ( !delimiter.compare("__") ) {
obracket = comma = cbracket = "_" ;
}
ostream << obracket ;
unsigned int arg_size = template_args.size() - 1 ;
for (unsigned int ii = 0 ; ii < arg_size ; ii++ ) {
work_string = template_args[ii].name ;
mangle_template_param(work_string, delimiter) ;
ostream << work_string ;
template_args[ii].printTemplateList(ostream, delimiter);
ostream << comma ;
}
work_string = template_args[arg_size].name ;
mangle_template_param(work_string, delimiter) ;
ostream << work_string ;
template_args[arg_size].printTemplateList(ostream, delimiter);
ostream << cbracket ;
}
}
void ConstructValues::ContainerClass::printContainerClass(std::ostream& ostream, const std::string& delimiter) {
ostream << name ;
printTemplateList(ostream, delimiter) ;
ostream << delimiter ;
}
//====================================================================================
2015-02-26 15:02:31 +00:00
ConstructValues::ConstructValues() {}
void ConstructValues::setName(std::string in_name) {
name = in_name ;
}
std::string ConstructValues::getName() {
return name ;
}
void ConstructValues::setFileName(std::string in_name) {
file_name = in_name ;
}
std::string ConstructValues::getFileName() {
return file_name ;
}
void ConstructValues::clearNamespacesAndClasses() {
namespaces.clear() ;
container_classes.clear() ;
}
bool ConstructValues::getNamespacesAndClasses( const clang::DeclContext * Ctx ) {
2015-02-26 15:02:31 +00:00
// Save container namespaces and classes.
typedef clang::SmallVector<const clang::DeclContext *, 8> ContextsTy;
ContextsTy Contexts;
// Collect contexts.
while (Ctx && clang::isa<clang::NamedDecl>(Ctx)) {
Contexts.push_back(Ctx);
Ctx = Ctx->getParent();
};
for (ContextsTy::reverse_iterator I = Contexts.rbegin(), E = Contexts.rend(); I != E; ++I) {
if (const clang::NamespaceDecl *nd = clang::dyn_cast<clang::NamespaceDecl>(*I)) {
if (! nd->isAnonymousNamespace()) {
2016-10-31 14:10:33 +00:00
//std::cout << "namespace " << nd->getIdentifier()->getName().str() << std::endl ;
std::string temp_name = nd->getIdentifier()->getName().str() ;
if ( temp_name.compare("std") and temp_name.compare("__1")) {
namespaces.push_back(nd->getIdentifier()->getName().str()) ;
}
2015-02-26 15:02:31 +00:00
}
} else if (const clang::RecordDecl *rd = clang::dyn_cast<clang::RecordDecl>(*I)) {
ContainerClass cc ;
if (!cc.extractType(rd)) {
return false ;
2015-02-26 15:02:31 +00:00
}
container_classes.push_back(cc) ;
2015-02-26 15:02:31 +00:00
}
}
return true ;
2015-02-26 15:02:31 +00:00
}
std::string ConstructValues::getFullyQualifiedName(const std::string& delimiter) {
std::ostringstream oss;
printNamespaces(oss, delimiter);
printContainerClasses(oss, delimiter);
oss << name;
return oss.str();
}
2015-02-26 15:02:31 +00:00
bool ConstructValues::isNameOrFileNameEmpty() {
return name.empty() or file_name.empty();
}
void ConstructValues::printOpenNamespaceBlocks(std::ostream& ostream) {
for (auto name : namespaces) {
ostream << "namespace " << name << " {" << std::endl;
2015-02-26 15:02:31 +00:00
}
}
void ConstructValues::printCloseNamespaceBlocks(std::ostream& ostream) {
for (auto name : namespaces) {
ostream << "}" << std::endl;
2015-02-26 15:02:31 +00:00
}
}
void ConstructValues::printNamespaces(std::ostream& ostream, const std::string& delimiter) {
for (auto name : namespaces) {
ostream << name << delimiter;
}
}
void ConstructValues::printContainerClasses(std::ostream& ostream, const std::string& delimiter) {
for (auto c : container_classes) {
c.printContainerClass(ostream, delimiter);
}
}
void ConstructValues::printNamespacesAndContainerClasses(std::ostream& ostream, const std::string& delimiter) {
printNamespaces(ostream, delimiter);
printContainerClasses(ostream, delimiter);
}
std::string ConstructValues::getNamespacesAndContainerClasses(const std::string& delimiter) {
std::string result = "";
for (auto name : namespaces) {
result += name + delimiter;
}
for (auto c : container_classes) {
std::stringstream ss ;
c.printContainerClass(ss, delimiter);
result += ss.str() ;
}
return result;
}
std::string ConstructValues::getFullyQualifiedTypeName(const std::string& delimiter) {
std::ostringstream oss ;
printNamespacesAndContainerClasses(oss, delimiter) ;
2015-02-26 15:02:31 +00:00
oss << name ;
return oss.str() ;
}