forked from OSchip/llvm-project
119 lines
3.3 KiB
C++
119 lines
3.3 KiB
C++
#ifndef ISL_INTERFACE_TEMPLATE_CPP_H
|
|
#define ISL_INTERFACE_TEMPLATE_CPP_H
|
|
|
|
#include <initializer_list>
|
|
#include <iostream>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <set>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
|
|
#include "cpp.h"
|
|
|
|
struct Fixed;
|
|
|
|
struct TupleKind;
|
|
|
|
/* A shared pointer to a TupleKind.
|
|
*/
|
|
struct TupleKindPtr : public std::shared_ptr<const TupleKind> {
|
|
using Base = std::shared_ptr<const TupleKind>;
|
|
TupleKindPtr() = default;
|
|
TupleKindPtr(Fixed);
|
|
TupleKindPtr(Base base) : Base(base) {}
|
|
TupleKindPtr(const std::string &name);
|
|
TupleKindPtr(const TupleKindPtr &left, const TupleKindPtr &right);
|
|
};
|
|
|
|
/* A substitution mapping leaf tuple kind names to tuple kinds.
|
|
*/
|
|
using Substitution = std::unordered_map<std::string, TupleKindPtr>;
|
|
|
|
/* A representation of a (possibly improper) tuple kind.
|
|
* That is, this also includes tuple kinds for types
|
|
* that do not have any tuples.
|
|
*
|
|
* The kind could be a name (the base case) or
|
|
* a (currently) unnamed nested pair of tuple kinds.
|
|
*/
|
|
struct TupleKind {
|
|
TupleKind(const std::string &name) : name(name) {}
|
|
|
|
virtual std::string to_string() const;
|
|
virtual std::vector<std::string> params() const;
|
|
virtual TupleKindPtr apply(const Substitution &subs,
|
|
const TupleKindPtr &self) const;
|
|
virtual TupleKindPtr left() const;
|
|
virtual TupleKindPtr right() const;
|
|
|
|
const std::string name;
|
|
};
|
|
|
|
/* A sequence of tuple kinds, representing a kind of objects.
|
|
*/
|
|
struct Kind : public std::vector<TupleKindPtr> {
|
|
Kind() {}
|
|
Kind(std::initializer_list<TupleKindPtr> list) : vector(list) {}
|
|
|
|
bool is_anon() const;
|
|
bool is_set() const;
|
|
bool is_anon_set() const;
|
|
std::vector<std::string> params() const;
|
|
Kind apply(const Substitution &subs) const;
|
|
};
|
|
|
|
/* A representation of a template class.
|
|
*
|
|
* "class_name" is the name of the template class.
|
|
* "super_name" is the (fully qualified) name of the corresponding
|
|
* plain C++ interface class, from which this template class derives.
|
|
* "clazz" describes the plain class.
|
|
*
|
|
* "class_tuples" contains the specializations.
|
|
* It is initialized with a predefined set of specializations,
|
|
* but may be extended during the generations of the specializations.
|
|
*/
|
|
struct template_class {
|
|
const std::string class_name;
|
|
const std::string super_name;
|
|
const isl_class &clazz;
|
|
|
|
std::vector<Kind> class_tuples;
|
|
|
|
bool is_anon() const;
|
|
bool is_anon_set() const;
|
|
void add_specialization(const Kind &kind);
|
|
};
|
|
|
|
/* A generator for templated C++ bindings.
|
|
*
|
|
* "template_classes" contains all generated template classes,
|
|
* keyed on their names.
|
|
*/
|
|
class template_cpp_generator : public cpp_generator {
|
|
struct class_printer;
|
|
struct method_decl_printer;
|
|
struct method_impl_printer;
|
|
struct class_decl_printer;
|
|
struct class_impl_printer;
|
|
|
|
void add_template_class(const isl_class &clazz, const std::string &name,
|
|
const std::vector<Kind> &base_kinds);
|
|
public:
|
|
template_cpp_generator(clang::SourceManager &SM,
|
|
std::set<clang::RecordDecl *> &exported_types,
|
|
std::set<clang::FunctionDecl *> exported_functions,
|
|
std::set<clang::FunctionDecl *> functions);
|
|
|
|
virtual void generate() override;
|
|
void foreach_template_class(
|
|
const std::function<void(const template_class &)> &fn) const;
|
|
void print_forward_declarations(std::ostream &os);
|
|
void print_friends(std::ostream &os);
|
|
|
|
std::map<std::string, template_class> template_classes;
|
|
};
|
|
|
|
#endif
|