cpp.cc

Go to the documentation of this file.

/*
 * 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)
{
}