[clang][modules] Don't prevent translation of FW_Private includes when explicitly...

[llvm-project.git] / polly / lib / External / isl / interface / cpp.cc

/*
 * Copyright 2016, 2017 Tobias Grosser. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *    1. Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *
 *    2. Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY TOBIAS GROSSER ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL TOBIAS GROSSER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation
 * are those of the authors and should not be interpreted as
 * representing official policies, either expressed or implied, of
 * Tobias Grosser.
 */

#include <iostream>
#include <string>
#include <vector>

#include "cpp.h"
#include "isl_config.h"

/* Determine the isl types from which the given class can be implicitly
 * constructed using a unary constructor.
 *
 * Look through all constructors for implicit conversion constructors that take
 * an isl type and add those types, along with the corresponding
 * constructor argument.
 */
void cpp_generator::set_class_construction_types(isl_class &clazz)
{
        for (const auto &cons : clazz.constructors) {
                ParmVarDecl *param;
                QualType type;
                std::string arg_type;

                if (!is_implicit_conversion(Method(clazz, cons)))
                        continue;

                param = cons->getParamDecl(0);
                type = param->getOriginalType();
                arg_type = extract_type(type);
                clazz.construction_types.emplace(arg_type, param);
        }
}

/* Determine the isl types from which any (proper) class can be constructed
 * using a unary constructor.
 */
void cpp_generator::set_construction_types()
{
        for (auto &kvp : classes) {
                auto &clazz = kvp.second;
                set_class_construction_types(clazz);
        }
}

/* Construct a generator for C++ bindings.
 *
 * The classes and methods are extracted by the constructor
 * of the generator superclass.
 *
 * Additionally extract information about types
 * that can be converted to a class and copy all methods
 * from superclasses that can be converted to a given class
 * to that class.
 */
cpp_generator::cpp_generator(SourceManager &SM,
        set<RecordDecl *> &exported_types,
        set<FunctionDecl *> exported_functions, set<FunctionDecl *> functions) :
                generator(SM, exported_types, exported_functions, functions)
{
        set_construction_types();
        copy_super_methods();
}

/* Copy the method called "name" described by "fd" from "super" to "clazz"
 * with the distance to the original ancestor given by "depth".
 *
 * In particular, keep track of "fd" as well as the superclass
 * from which it was copied and the distance to the original ancestor.
 */
static void copy_method(isl_class &clazz, const isl_class &super,
        const std::string &name, FunctionDecl *fd, int depth)
{
        clazz.methods[name].insert(fd);
        clazz.copied_from.emplace(fd, super);
        clazz.copy_depth.emplace(fd, depth);
}

/* Do "fd1" and "fd2" have the same signature (ignoring the first argument
 * which represents the object class on which the corresponding method
 * gets called).
 */
static bool same_signature(FunctionDecl *fd1, FunctionDecl *fd2)
{
        int n1 = fd1->getNumParams();
        int n2 = fd2->getNumParams();

        if (n1 != n2)
                return false;

        for (int i = 1; i < n1; ++i) {
                ParmVarDecl *p1 = fd1->getParamDecl(i);
                ParmVarDecl *p2 = fd2->getParamDecl(i);

                if (p1->getOriginalType() != p2->getOriginalType())
                        return false;
        }

        return true;
}

/* Return the distance between "clazz" and the ancestor
 * from which "fd" got copied.
 * If no distance was recorded, then the method has not been copied
 * but appears in "clazz" itself and so the distance is zero.
 */
static int copy_depth(const isl_class &clazz, FunctionDecl *fd)
{
        if (clazz.copy_depth.count(fd) == 0)
                return 0;
        return clazz.copy_depth.at(fd);
}

/* Is the method derived from "fd", with method name "name" and
 * with distance to the original ancestor "depth",
 * overridden by a method already in "clazz"?
 *
 * A method is considered to have been overridden if there
 * is a method with the same name in "clazz" that has the same signature and
 * that comes from an ancestor closer to "clazz",
 * where an ancestor is closer if the distance in the class hierarchy
 * is smaller or the distance is the same and the ancestor appears
 * closer in the declaration of the type (in which case it gets added first).
 *
 * If a method with the same signature has already been added,
 * but it does not override the method derived from "fd",
 * then this method is removed since it is overridden by "fd".
 */
static bool is_overridden(FunctionDecl *fd, isl_class &clazz,
        const std::string &name, int depth)
{
        if (clazz.methods.count(name) == 0)
                return false;

        for (const auto &m : clazz.methods.at(name)) {
                if (!same_signature(fd, m))
                        continue;
                if (copy_depth(clazz, m) <= depth)
                        return true;
                clazz.methods[name].erase(m);
                return false;
        }
        return false;
}

/* Add the methods "methods" with method name "name" from "super" to "clazz"
 * provided they have not been overridden by a method already in "clazz".
 *
 * Methods that are static in their original class are not copied.
 */
void cpp_generator::copy_methods(isl_class &clazz, const std::string &name,
        const isl_class &super, const function_set &methods)
{
        for (auto fd : methods) {
                int depth;

                if (method2class(fd)->is_static(fd))
                        continue;
                depth = copy_depth(super, fd) + 1;
                if (is_overridden(fd, clazz, name, depth))
                        continue;
                copy_method(clazz, super, name, fd, depth);
        }
}

/* Add all methods from "super" to "clazz" that have not been overridden
 * by a method already in "clazz".
 *
 * Look through all groups of methods with the same name.
 */
void cpp_generator::copy_super_methods(isl_class &clazz, const isl_class &super)
{
        for (const auto &kvp : super.methods) {
                const auto &name = kvp.first;
                const auto &methods = kvp.second;

                copy_methods(clazz, name, super, methods);
        }
}

/* Copy methods from the superclasses of "clazz"
 * if an object of this class can be implicitly converted to an object
 * from the superclass, keeping track
 * of the classes that have already been handled in "done".
 *
 * Make sure the superclasses have copied methods from their superclasses first
 * since those methods could be copied further down to this class.
 *
 * Consider the superclass that appears closest to the subclass first.
 */
void cpp_generator::copy_super_methods(isl_class &clazz, set<string> &done)
{
        auto supers = find_superclasses(clazz.type);

        for (const auto &super : supers)
                if (done.count(super) == 0)
                        copy_super_methods(classes[super], done);
        done.insert(clazz.name);

        for (const auto &super_name : supers) {
                const auto &super = classes[super_name];

                if (super.construction_types.count(clazz.name) == 0)
                        continue;
                copy_super_methods(clazz, super);
        }
}

/* For each (proper) class, copy methods from its superclasses,
 * if an object from the class can be converted to an object
 * from the superclass.
 *
 * Type based subclasses are not considered for now since
 * they do not have any explicit superclasses.
 *
 * Iterate through all (proper) classes and copy methods
 * from their superclasses,
 * unless they have already been determined by a recursive call.
 */
void cpp_generator::copy_super_methods()
{
        set<string> done;

        for (auto &kvp : classes) {
                auto &clazz = kvp.second;

                if (clazz.is_type_subclass())
                        continue;
                if (done.count(clazz.name) != 0)
                        continue;
                copy_super_methods(clazz, done);
        }
}

/* Print declarations or implementations of constructors.
 *
 * For each isl function that is marked as __isl_constructor,
 * add a corresponding C++ constructor.
 *
 * Example of declarations:
 *
 *      inline /\* implicit *\/ union_set(basic_set bset);
 *      inline /\* implicit *\/ union_set(set set);
 *      inline explicit val(ctx ctx, long i);
 *      inline explicit val(ctx ctx, const std::string &str);
 */
void cpp_generator::class_printer::print_constructors()
{
        for (const auto &cons : clazz.constructors)
                print_method(Method(clazz, cons));
}

/* Print declarations or definitions for methods in the class.
 */
void cpp_generator::class_printer::print_methods()
{
        for (const auto &kvp : clazz.methods)
                print_method_group(kvp.second, kvp.first);
}

/* Print declarations or implementations for the methods derived from "fd",
 * which sets an enum.
 *
 * A method is generated for each value in the enum, setting
 * the enum to that value.
 */
void cpp_generator::class_printer::print_set_enums(FunctionDecl *fd)
{
        for (const auto &set : clazz.set_enums.at(fd)) {
                EnumMethod method(clazz, fd, set.method_name, set.name);

                print_method(method);
        }
}

/* Print declarations or implementations for methods derived from functions
 * that set an enum.
 */
void cpp_generator::class_printer::print_set_enums()
{
        for (const auto &kvp : clazz.set_enums)
                print_set_enums(kvp.first);
}

/* Update "convert" to reflect the next combination of automatic conversions
 * for the arguments of "fd",
 * returning false if there are no more combinations.
 *
 * In particular, find the last argument for which an automatic
 * conversion function is available mapping to the type of this argument and
 * that is not already marked for conversion.
 * Mark this argument, if any, for conversion and clear the markings
 * of all subsequent arguments.
 * Repeated calls to this method therefore run through
 * all possible combinations.
 *
 * Note that the first function argument is never considered
 * for automatic conversion since this is the argument
 * from which the isl_ctx used in the conversion is extracted.
 */
bool cpp_generator::class_printer::next_variant(FunctionDecl *fd,
        std::vector<bool> &convert)
{
        size_t n = convert.size();

        for (int i = n - 1; i >= 1; --i) {
                ParmVarDecl *param = fd->getParamDecl(i);
                const Type *type = param->getOriginalType().getTypePtr();

                if (generator.conversions.count(type) == 0)
                        continue;
                if (convert[i])
                        continue;
                convert[i] = true;
                for (size_t j = i + 1; j < n; ++j)
                        convert[j] = false;
                return true;
        }

        return false;
}

/* Print a declaration or definition for a method called "name"
 * derived from "fd".
 *
 * If the method was copied from a superclass, then print a definition
 * that calls the corresponding method in the superclass.
 * Otherwise, for methods that are identified as "get" methods, also
 * print a declaration or definition for the method
 * using a name that includes the "get_" prefix.
 *
 * If the generated method is an object method, then check
 * whether any of its arguments can be automatically converted
 * from something else, and, if so, generate a method
 * for each combination of converted arguments.
 * Do so by constructing a ConversionMethod that changes the converted arguments
 * to those of the sources of the conversions.
 *
 * Note that a method may be both copied from a superclass and
 * have arguments that can be automatically converted.
 * In this case, the conversion methods for the arguments
 * call the corresponding method in this class, which
 * in turn will call the method in the superclass.
 */
void cpp_generator::class_printer::print_method_variants(FunctionDecl *fd,
        const std::string &name)
{
        Method method(clazz, fd, name);
        std::vector<bool> convert(method.num_params());

        if (method.clazz.copied_from.count(method.fd) == 0) {
                print_method(method);
                if (clazz.is_get_method(fd))
                        print_get_method(fd);
        } else {
                auto super = method.clazz.copied_from.at(method.fd);
                print_method(ConversionMethod(method, super.name));
        }
        if (method.kind != Method::Kind::member_method)
                return;
        while (next_variant(fd, convert)) {
                print_method(ConversionMethod(method, [&] (int pos) {
                        return get_param(fd, pos, convert);
                }));
        }
}

/* Given a function declaration representing a method,
 * does this method have a single argument (beyond the object
 * on which the method is called) that corresponds to
 * an isl object?
 */
static bool has_single_isl_argument(FunctionDecl *fd)
{
        ParmVarDecl *param;

        if (fd->getNumParams() != 2)
                return false;

        param = fd->getParamDecl(1);
        return generator::is_isl_type(param->getOriginalType());
}

/* Does the set "methods" contain exactly one function declaration
 * that corresponds to a method of "clazz" itself (i.e., that
 * was not copied from an ancestor)?
 */
static FunctionDecl *single_local(const isl_class &clazz,
        const function_set &methods)
{
        int count = 0;
        FunctionDecl *local;

        for (const auto &fn : methods) {
                if (!clazz.first_arg_matches_class(fn))
                        continue;
                ++count;
                local = fn;
        }

        return count == 1 ? local : NULL;
}

/* Given a function declaration "fd" for a method called "name"
 * with a single argument representing an isl object,
 * generate declarations or definitions for methods with the same name,
 * but with as argument an isl object of a class that can be implicitly
 * converted to that of the original argument.
 * In particular, generate methods for converting this argument.
 */
void cpp_generator::class_printer::print_descendent_overloads(
        FunctionDecl *fd, const std::string &name)
{
        Method method(clazz, fd, name);
        ParmVarDecl *param = fd->getParamDecl(1);
        QualType type = param->getOriginalType();
        std::string arg = type->getPointeeType().getAsString();

        for (const auto &kvp : generator.classes[arg].construction_types) {
                const auto sub = kvp.second;
                print_method(ConversionMethod(method, [&] (int pos) {
                        return sub;
                }));
        }
}

/* Print declarations or definitions for methods called "name"
 * derived from "methods".
 *
 * If want_descendent_overloads signals that variants should be added that take
 * as arguments those types that can be converted to the original argument type
 * through a unary constructor and if only one of the methods in the group
 * was originally defined in "clazz", then effectively add those variants.
 * Only do this for methods with a single (isl object) argument.
 */
void cpp_generator::class_printer::print_method_group(
        const function_set &methods, const std::string &name)
{
        FunctionDecl *local;

        for (const auto &fd : methods)
                print_method_variants(fd, name);
        if (!want_descendent_overloads(methods))
                return;
        local = single_local(clazz, methods);
        if (!local)
                return;
        if (!has_single_isl_argument(local))
                return;
        print_descendent_overloads(local, name);
}

/* Print the use of the argument at position "pos" to "os".
 *
 * Member methods pass the isl object corresponding to "this"
 * as first argument (at position 0).
 * Any other arguments are passed along from the method arguments.
 *
 * If the argument value is loaded from a this pointer, the original
 * value must be preserved and must consequently be copied.  Values that are
 * loaded from method parameters do not need to be preserved, as such values
 * will already be copies of the actual parameters.  It is consequently possible
 * to directly take the pointer from these values, which saves
 * an unnecessary copy.
 *
 * In case the parameter is a callback function, two parameters get printed,
 * a wrapper for the callback function and a pointer to the actual
 * callback function.  The wrapper is expected to be available
 * in a previously declared variable <name>_lambda, while
 * the actual callback function is expected to be stored
 * in a structure called <name>_data.
 * The caller of this function must ensure that these variables exist.
 */
void Method::print_param_use(ostream &os, int pos) const
{
        ParmVarDecl *param = fd->getParamDecl(pos);
        bool load_from_this_ptr = pos == 0 && kind == member_method;
        string name = param->getName().str();
        QualType type = param->getOriginalType();

        if (type->isIntegerType()) {
                os << name;
                return;
        }

        if (generator::is_string(type)) {
                os << name << ".c_str()";
                return;
        }

        if (generator::is_callback(type)) {
                os << name << "_lambda, ";
                os << "&" << name << "_data";
                return;
        }

        if (!load_from_this_ptr)
                os << name << ".";

        if (generator::keeps(param)) {
                os << "get()";
        } else {
                if (load_from_this_ptr)
                        os << "copy()";
                else
                        os << "release()";
        }
}

/* Does the isl function from which this method is derived
 * modify an object of a subclass based on a type function?
 */
bool Method::is_subclass_mutator() const
{
        return clazz.is_type_subclass() && generator::is_mutator(clazz, fd);
}

/* Return the C++ return type of the method "method".
 *
 * If the corresponding function modifies an object of a subclass, then return
 * the type of this subclass.
 * Otherwise, return the C++ counterpart of the actual return type.
 */
std::string cpp_type_printer::return_type(const Method &method) const
{
        if (method.is_subclass_mutator())
                return cpp_generator::type2cpp(method.clazz);
        else
                return param(-1, method.fd->getReturnType());
}

/* Return the formal parameter at position "pos" of "fd".
 * However, if this parameter should be converted, as indicated
 * by "convert", then return the second formal parameter
 * of the conversion function instead.
 */
ParmVarDecl *cpp_generator::class_printer::get_param(FunctionDecl *fd,
        int pos, const std::vector<bool> &convert)
{
        ParmVarDecl *param = fd->getParamDecl(pos);

        if (!convert[pos])
                return param;
        return generator.conversions[param->getOriginalType().getTypePtr()];
}

/* Print the header for "method", without newline or semicolon,
 * using "type_printer" to print argument and return types.
 *
 * Print the header of a declaration if this->declarations is set,
 * otherwise print the header of a method definition.
 *
 * This function prints headers for member methods, static methods, and
 * constructors, either for their declaration or definition.
 *
 * Member functions are declared as "const", as they do not change the current
 * object, but instead create a new object. They always retrieve the first
 * parameter of the original isl function from the this-pointer of the object,
 * such that only starting at the second parameter the parameters of the
 * original function become part of the method's interface.
 *
 * A function
 *
 *      __isl_give isl_set *isl_set_intersect(__isl_take isl_set *s1,
 *              __isl_take isl_set *s2);
 *
 * is translated into:
 *
 *      inline set intersect(set set2) const
 *
 * For static functions and constructors all parameters of the original isl
 * function are exposed.
 *
 * Parameters of which no copy is required, are passed
 * as const reference, which allows the compiler to optimize the parameter
 * transfer.
 *
 * Constructors are marked as explicit using the C++ keyword 'explicit' or as
 * implicit using a comment in place of the explicit keyword. By annotating
 * implicit constructors with a comment, users of the interface are made
 * aware of the potential danger that implicit construction is possible
 * for these constructors, whereas without a comment not every user would
 * know that implicit construction is allowed in absence of an explicit keyword.
 *
 * Note that in case "method" is a ConversionMethod, the argument returned
 * by Method::get_param may be different from the original argument.
 * The name of the argument is, however, derived from the original
 * function argument.
 */
void cpp_generator::class_printer::print_method_header(
        const Method &method, const cpp_type_printer &type_printer)
{
        string rettype_str = type_printer.return_type(method);

        if (declarations) {
                os << "  ";

                if (method.kind == Method::Kind::static_method)
                        os << "static ";

                os << "inline ";

                if (method.kind == Method::Kind::constructor) {
                        if (generator.is_implicit_conversion(method))
                                os << "/* implicit */ ";
                        else
                                os << "explicit ";
                }
        }

        if (method.kind != Method::Kind::constructor)
                os << rettype_str << " ";

        if (!declarations)
                os << type_printer.class_type(cppstring) << "::";

        if (method.kind != Method::Kind::constructor)
                os << method.name;
        else
                os << cppstring;

        method.print_cpp_arg_list(os, [&] (int i, int arg) {
                std::string name = method.fd->getParamDecl(i)->getName().str();
                ParmVarDecl *param = method.get_param(i);
                QualType type = param->getOriginalType();
                string cpptype = type_printer.param(arg, type);

                if (!method.param_needs_copy(i))
                        os << "const " << cpptype << " &" << name;
                else
                        os << cpptype << " " << name;
        });

        if (method.kind == Method::Kind::member_method)
                os << " const";
}

/* Generate the list of argument types for a callback function of
 * type "type", appearing in argument position "arg".
 * If "cpp" is set, then generate the C++ type list, otherwise
 * the C type list.
 *
 * For a callback of type
 *
 *      isl_stat (*)(__isl_take isl_map *map, void *user)
 *
 * the following C++ argument list is generated:
 *
 *      map
 *
 * The arguments of the callback are considered to appear
 * after the position of the callback itself.
 */
std::string cpp_type_printer::generate_callback_args(int arg, QualType type,
        bool cpp) const
{
        std::string type_str;
        const FunctionProtoType *callback;
        int num_params;

        callback = generator::extract_prototype(type);
        num_params = callback->getNumArgs();
        if (cpp)
                num_params--;

        for (long i = 0; i < num_params; i++) {
                QualType type = callback->getArgType(i);

                if (cpp)
                        type_str += param(arg + 1 + i, type);
                else
                        type_str += type.getAsString();

                if (!cpp)
                        type_str += "arg_" + ::to_string(i);

                if (i != num_params - 1)
                        type_str += ", ";
        }

        return type_str;
}

/* Generate the full cpp type of a callback function of type "type",
 * appearing in argument position "arg".
 *
 * For a callback of type
 *
 *      isl_stat (*)(__isl_take isl_map *map, void *user)
 *
 * the following type is generated:
 *
 *      std::function<stat(map)>
 */
std::string cpp_type_printer::generate_callback_type(int arg, QualType type)
        const
{
        std::string type_str;
        const FunctionProtoType *callback = generator::extract_prototype(type);
        QualType return_type = callback->getReturnType();
        string rettype_str = param(arg, return_type);

        type_str = "std::function<";
        type_str += rettype_str;
        type_str += "(";
        type_str += generate_callback_args(arg, type, true);
        type_str += ")>";

        return type_str;
}

/* An array listing functions that must be renamed and the function name they
 * should be renamed to. We currently rename functions in case their name would
 * match a reserved C++ keyword, which is not allowed in C++.
 */
static const char *rename_map[][2] = {
        { "union", "unite" },
};

/* Rename method "name" in case the method name in the C++ bindings should not
 * match the name in the C bindings. We do this for example to avoid
 * C++ keywords.
 */
static std::string rename_method(std::string name)
{
        for (size_t i = 0; i < sizeof(rename_map) / sizeof(rename_map[0]); i++)
                if (name.compare(rename_map[i][0]) == 0)
                        return rename_map[i][1];

        return name;
}

/* Translate isl class "clazz" to its corresponding C++ type.
 * Use the name of the type based subclass, if any.
 */
string cpp_generator::type2cpp(const isl_class &clazz)
{
        return type2cpp(clazz.subclass_name);
}

/* Translate type string "type_str" to its C++ name counterpart.
*/
string cpp_generator::type2cpp(string type_str)
{
        return type_str.substr(4);
}

/* Return the C++ counterpart to the isl_bool type.
 *
 * By default, this is simply "bool" since
 * the exceptional case is handled through exceptions.
 */
std::string cpp_type_printer::isl_bool() const
{
        return "bool";
}

/* Return the C++ counterpart to the isl_stat type.
 *
 * By default, this is simply "void" since
 * the exceptional case is handled through exceptions.
 */
string cpp_type_printer::isl_stat() const
{
        return "void";
}

/* Return the C++ counterpart to the isl_size type.
 *
 * By default, this is simply "unsigned" since
 * the exceptional case is handled through exceptions.
 */
string cpp_type_printer::isl_size() const
{
        return "unsigned";
}

/* Return the namespace of the generated C++ bindings.
 *
 * By default, this is "isl::".
 */
std::string cpp_type_printer::isl_namespace() const
{
        return "isl::";
}

/* Return the class type given the C++ name.
 *
 * By default, directly use the C++ name.
 */
std::string cpp_type_printer::class_type(const std::string &cpp_name) const
{
        return cpp_name;
}

/* Return the qualified form of the given C++ isl type name appearing
 * in argument position "arg" (-1 for return type).
 *
 * By default, the argument position is ignored.
 */
std::string cpp_type_printer::qualified(int arg, const std::string &cpp_type)
        const
{
        return isl_namespace() + cpp_type;
}

/* Return the C++ counterpart to the given isl type appearing
 * in argument position "arg" (-1 for return type).
 */
std::string cpp_type_printer::isl_type(int arg, QualType type) const
{
        auto name = type->getPointeeType().getAsString();
        return qualified(arg, cpp_generator::type2cpp(name));
}

/* Translate parameter or return type "type" to its C++ name counterpart.
 * "arg" is the position of the argument, or -1 in case of the return type.
 * If any callback is involved, then the return type and arguments types
 * of the callback are considered to start at the position of the callback.
 */
std::string cpp_type_printer::param(int arg, QualType type) const
{
        if (cpp_generator::is_isl_type(type))
                return isl_type(arg, type);

        if (cpp_generator::is_isl_bool(type))
                return isl_bool();

        if (cpp_generator::is_isl_stat(type))
                return isl_stat();

        if (cpp_generator::is_isl_size(type))
                return isl_size();

        if (type->isIntegerType())
                return type.getAsString();

        if (cpp_generator::is_string(type))
                return "std::string";

        if (cpp_generator::is_callback(type))
                return generate_callback_type(arg, type);

        generator::die("Cannot convert type to C++ type");
}

/* Check if "subclass_type" is a subclass of "class_type".
 */
bool cpp_generator::is_subclass(QualType subclass_type,
        const isl_class &class_type)
{
        std::string type_str = subclass_type->getPointeeType().getAsString();
        std::vector<std::string> superclasses;
        std::vector<const isl_class *> parents;
        std::vector<std::string>::iterator ci;

        superclasses = generator::find_superclasses(classes[type_str].type);

        for (ci = superclasses.begin(); ci < superclasses.end(); ci++)
                parents.push_back(&classes[*ci]);

        while (!parents.empty()) {
                const isl_class *candidate = parents.back();

                parents.pop_back();

                if (&class_type == candidate)
                        return true;

                superclasses = generator::find_superclasses(candidate->type);

                for (ci = superclasses.begin(); ci < superclasses.end(); ci++)
                        parents.push_back(&classes[*ci]);
        }

        return false;
}

/* Check if "cons" is an implicit conversion constructor of class "clazz".
 *
 * An implicit conversion constructor is generated in case "cons" has a single
 * parameter, where the parameter type is a subclass of the class that is
 * currently being generated.
 */
bool cpp_generator::is_implicit_conversion(const Method &cons)
{
        const auto &clazz = cons.clazz;
        ParmVarDecl *param = cons.fd->getParamDecl(0);
        QualType type = param->getOriginalType();

        int num_params = cons.fd->getNumParams();
        if (num_params != 1)
                return false;

        if (is_isl_type(type) && !is_isl_ctx(type) && is_subclass(type, clazz))
                return true;

        return false;
}

/* Construct a list combiner for printing a list.
 */
Method::list_combiner Method::print_combiner(std::ostream &os)
{
        return {
                [&] () { os << "("; },
                [&] () { os << ", "; },
                [&] () { os << ")"; }
        };
}

/* Construct a list combiner for simply iterating over a list.
 */
Method::list_combiner Method::empty_combiner()
{
        return { [&] () { }, [&] () { }, [&] () { } };
}

/* Get kind of "method" in "clazz".
 *
 * Given the declaration of a static or member method, returns its kind.
 */
static Method::Kind get_kind(const isl_class &clazz, FunctionDecl *method)
{
        if (generator::is_constructor(method))
                return Method::Kind::constructor;
        else if (generator::is_static(clazz, method))
                return Method::Kind::static_method;
        else
                return Method::Kind::member_method;
}

/* Return the callback arguments of "fd".
 */
static std::vector<ParmVarDecl *> find_callback_args(FunctionDecl *fd)
{
        std::vector<ParmVarDecl *> callbacks;
        int num_params = fd->getNumParams();

        for (int i = 0; i < num_params; ++i) {
                ParmVarDecl *param = fd->getParamDecl(i);
                if (generator::is_callback(param->getType()))
                        callbacks.emplace_back(param);
        }

        return callbacks;
}

/* Construct a C++ method object from the class to which is belongs,
 * the isl function from which it is derived and the method name.
 *
 * Perform any renaming of the method that may be required and
 * determine the type of the method.
 */
Method::Method(const isl_class &clazz, FunctionDecl *fd,
        const std::string &name) :
                clazz(clazz), fd(fd), name(rename_method(name)),
                kind(get_kind(clazz, fd)),
                callbacks(find_callback_args(fd))
{
}

/* Construct a C++ method object from the class to which is belongs and
 * the isl function from which it is derived.
 *
 * Obtain the default method name and continue
 * with the generic constructor.
 */
Method::Method(const isl_class &clazz, FunctionDecl *fd) :
        Method(clazz, fd, clazz.method_name(fd))
{
}

/* Return the number of parameters of the corresponding C function.
 *
 * This number includes any possible user pointers that follow callback
 * arguments.  These are skipped by Method::print_fd_arg_list
 * during the actual argument printing.
 */
int Method::c_num_params() const
{
        return fd->getNumParams();
}

/* Return the number of parameters of the method
 * (including the implicit "this").
 *
 * By default, it is the same as the number of parameters
 * of the corresponding C function.
 */
int Method::num_params() const
{
        return c_num_params();
}

/* Call "on_arg_skip_next" on the arguments from "start" (inclusive)
 * to "end" (exclusive), calling the methods of "combiner"
 * before, between and after the arguments.
 * If "on_arg_skip_next" returns true then the next argument is skipped.
 */
void Method::on_arg_list(int start, int end,
        const Method::list_combiner &combiner,
        const std::function<bool(int i)> &on_arg_skip_next)
{
        combiner.before();
        for (int i = start; i < end; ++i) {
                if (i != start)
                        combiner.between();
                if (on_arg_skip_next(i))
                        ++i;
        }
        combiner.after();
}

/* Print the arguments from "start" (inclusive) to "end" (exclusive)
 * as arguments to a method of C function call, using "print_arg_skip_next"
 * to print each individual argument.  If this callback return true
 * then the next argument is skipped.
 */
void Method::print_arg_list(std::ostream &os, int start, int end,
        const std::function<bool(int i)> &print_arg_skip_next)
{
        on_arg_list(start, end, print_combiner(os), [&] (int i) {
                return print_arg_skip_next(i);
        });
}

/* Call "on_arg" on the arguments from "start" (inclusive) to "end" (exclusive),
 * calling the methods of "combiner" before, between and after the arguments.
 * The first argument to "on_arg" is the position of the argument
 * in this->fd.
 * The second argument is the (first) position in the list of arguments
 * with all callback arguments spliced in.
 *
 * Call on_arg_list to do the actual iteration over the arguments, skipping
 * the user argument that comes after every callback argument.
 * On the C++ side no user pointer is needed, as arguments can be forwarded
 * as part of the std::function argument which specifies the callback function.
 * The user pointer is also removed from the number of parameters
 * of the C function because the pair of callback and user pointer
 * is considered as a single argument that is printed as a whole
 * by Method::print_param_use.
 *
 * In case of a callback argument, the second argument to "print_arg"
 * is also adjusted to account for the spliced-in arguments of the callback.
 * The return value takes the place of the callback itself,
 * while the arguments (excluding the final user pointer)
 * take the following positions.
 */
void Method::on_fd_arg_list(int start, int end,
        const Method::list_combiner &combiner,
        const std::function<void(int i, int arg)> &on_arg) const
{
        int arg = start;

        on_arg_list(start, end, combiner, [this, &on_arg, &arg] (int i) {
                auto type = fd->getParamDecl(i)->getType();

                on_arg(i, arg++);
                if (!generator::is_callback(type))
                        return false;
                arg += generator::prototype_n_args(type) - 1;
                return true;
        });
}

/* Print the arguments from "start" (inclusive) to "end" (exclusive)
 * as arguments to a method of C function call, using "print_arg"
 * to print each individual argument.
 * The first argument to this callback is the position of the argument
 * in this->fd.
 * The second argument is the (first) position in the list of arguments
 * with all callback arguments spliced in.
 */
void Method::print_fd_arg_list(std::ostream &os, int start, int end,
        const std::function<void(int i, int arg)> &print_arg) const
{
        on_fd_arg_list(start, end, print_combiner(os), print_arg);
}

/* Call "on_arg" on the arguments to the method call,
 * calling the methods of "combiner" before, between and after the arguments.
 * The first argument to "on_arg" is the position of the argument
 * in this->fd.
 * The second argument is the (first) position in the list of arguments
 * with all callback arguments spliced in.
 */
void Method::on_cpp_arg_list(const Method::list_combiner &combiner,
        const std::function<void(int i, int arg)> &on_arg) const
{
        int first_param = kind == member_method ? 1 : 0;
        on_fd_arg_list(first_param, num_params(), combiner, on_arg);
}

/* Call "on_arg" on the arguments to the method call.
 * The first argument to "on_arg" is the position of the argument
 * in this->fd.
 * The second argument is the (first) position in the list of arguments
 * with all callback arguments spliced in.
 */
void Method::on_cpp_arg_list(
        const std::function<void(int i, int arg)> &on_arg) const
{
        on_cpp_arg_list(empty_combiner(), on_arg);
}

/* Print the arguments to the method call, using "print_arg"
 * to print each individual argument.
 * The first argument to this callback is the position of the argument
 * in this->fd.
 * The second argument is the (first) position in the list of arguments
 * with all callback arguments spliced in.
 */
void Method::print_cpp_arg_list(std::ostream &os,
        const std::function<void(int i, int arg)> &print_arg) const
{
        on_cpp_arg_list(print_combiner(os), print_arg);
}

/* Should the parameter at position "pos" be a copy (rather than
 * a const reference)?
 *
 * Strictly speaking, a copy is only needed on isl types that are
 * not marked __isl_keep, since those will be release()'d
 * by code printed by Method::print_param_use.
 *
 * However, there may be other arguments such as integer types
 * that are more naturally passed as a copy.
 * The default is therefore to require a copy, except for
 * arguments marked __isl_keep, string arguments or callback arguments.
 */
bool Method::param_needs_copy(int pos) const
{
        ParmVarDecl *param = get_param(pos);
        QualType type = param->getOriginalType();

        if (generator::keeps(param))
                return false;
        if (generator::is_string(type) || generator::is_callback(type))
                return false;
        return true;
}

/* Return the method argument at position "pos".
 */
clang::ParmVarDecl *Method::get_param(int pos) const
{
        return fd->getParamDecl(pos);
}

/* Construct a method that performs one or more conversions
 * from the original Method (without conversions),
 * the name of the type to which "this" should be converted and
 * a function for determining the arguments of the constructed method.
 */
ConversionMethod::ConversionMethod(const Method &method,
        const std::string &this_type,
        const std::function<clang::ParmVarDecl *(int pos)> &get_param) :
                NoCopyMethod(method), this_type(this_type),
                get_param_fn(get_param)
{
}

/* Construct a method that only performs a conversion on "this"
 * from the original Method (without conversions) and
 * the name of the type to which "this" should be converted.
 *
 * Call the generic constructor with
 * a function for determining the arguments of the constructed method
 * that performs no conversion.
 */
ConversionMethod::ConversionMethod(const Method &method,
        const std::string &this_type) :
                ConversionMethod(method, this_type, [this] (int pos) {
                        return Method::get_param(pos);
                })
{
}

/* Construct a method that performs one or more argument conversions
 * from the original Method (without conversions) and
 * a function for determining the arguments of the constructed method.
 *
 * Call the generic constructor with method.clazz.name as "this" type,
 * indicating that "this" should not be converted.
 */
ConversionMethod::ConversionMethod(const Method &method,
        const std::function<clang::ParmVarDecl *(int pos)> &get_param) :
                ConversionMethod(method, method.clazz.name, get_param)
{
}

/* Should the parameter at position "pos" be a copy (rather than
 * a const reference)?
 *
 * Parameters of isl type do not need to be a copy.
 * For other types, use the same defaults as Method.
 */
bool NoCopyMethod::param_needs_copy(int pos) const
{
        ParmVarDecl *param = get_param(pos);
        QualType type = param->getOriginalType();

        if (generator::is_isl_type(type))
                return false;

        return Method::param_needs_copy(pos);
}

/* Return the method argument at position "pos".
 *
 * Call get_param_fn to determine this argument.
 */
clang::ParmVarDecl *ConversionMethod::get_param(int pos) const
{
        return get_param_fn(pos);
}

/* Print a call to the method (without the arguments),
 * with "ns" the namespace of the generated C++ bindings.
 *
 * If "this_type" is different from the name of the class of the method,
 * then "this" needs to be converted to that type before
 * the call is performed.
 */
void ConversionMethod::print_call(std::ostream &os, const std::string &ns) const
{
        if (clazz.name == this_type) {
                os << "this->";
        } else {
                auto cpp_type = ns + cpp_generator::type2cpp(this_type);
                os << cpp_type << "(*this).";
        }
        os << name;
}

/* Construct an object representing a C++ method for setting an enum
 * from the class to which is belongs,
 * the isl function from which it is derived and the method and enum names.
 */
EnumMethod::EnumMethod(const isl_class &clazz, FunctionDecl *fd,
        const std::string &method_name, const std::string &enum_name) :
                Method(clazz, fd, method_name), enum_name(enum_name)
{
}

/* Print the use of the argument at position "pos" to "os".
 *
 * If the position is beyond the number of method arguments,
 * then it corresponds to the enum value corresponding to this EnumMethod.
 * Otherwise, delegate to Method::print_param_use.
 */
void EnumMethod::print_param_use(ostream &os, int pos) const
{
        if (pos == num_params())
                os << enum_name;
        else
                Method::print_param_use(os, pos);
}

/* Return the number of parameters of the method
 * (including the implicit "this").
 *
 * The last argument of the C function does not appear in the method call,
 * because it is replaced by a break-up into several methods.
 */
int EnumMethod::num_params() const
{
        return Method::num_params() - 1;
}

/* Initialize a class method printer from the stream onto which the methods
 * are printed, the class method description and the C++ interface generator.
 */
cpp_generator::class_printer::class_printer(std::ostream &os,
                const isl_class &clazz, cpp_generator &generator,
                bool declarations) :
        os(os), clazz(clazz), cppstring(type2cpp(clazz)), generator(generator),
        declarations(declarations)
{
}