TypeManip.cxx

Go to the documentation of this file.

// Bindings
#include "cpyrt.h"
 
using namespace cppjit;
#include "TypeManip.h"
 
// Standard
#include <algorithm>
#include <ctype.h>
#include <sstream>
 
//- helpers ------------------------------------------------------------------
static inline bool is_varchar(char c) {
  return isalnum((int)c) || c == '_' || c == ')' ||
         c == '(' /* for (anonymous)/(unnamed) */;
}
 
static inline std::string::size_type
find_qualifier_index(const std::string& name) {
  // Find the first location that is not part of the class name proper.
  std::string::size_type i = name.size() - 1;
  bool arr_open = false;
  for (; 0 < i; --i) {
    std::string::value_type c = name[i];
    if (!arr_open && (is_varchar(c) || c == '>')) {
      if (c == 't' && 6 < i && !is_varchar(name[i - 5]) &&
          name.substr(i - 4, 5) == "const")
        i -= 4; // this skips 'const' on a pointer type
      else
        break;
    } else if (c == ']') {
      arr_open = true;
    } else if (c == '[') {
      arr_open = false;
    }
  }
 
  return i + 1;
}
 
static inline void erase_const(std::string& name) {
  // Find and remove all occurrence of 'const'.
  if (name.empty())
    return;
 
  std::string::size_type spos = std::string::npos;
  std::string::size_type start = 0;
  while ((spos = name.find("const", start)) != std::string::npos) {
    // make sure not to erase 'const' as part of the name: if it is
    // connected, before or after, to a variable name, then keep it
    std::string::size_type after = spos + 5;
    if (after < name.size() && is_varchar(name[after])) {
      start = after;
      continue;
    } else if (after == name.size()) {
      if (spos > 0 && is_varchar(name[spos - 1]))
        break;
    }
 
    std::string::size_type i = 5;
    while (name[spos + i] == ' ')
      ++i;
    name.swap(name.erase(spos, i));
  }
}
 
static inline void rstrip(std::string& name) {
  // Remove space from the right side of name.
  std::string::size_type i = name.size();
  for (; 0 < i; --i) {
    if (!isspace(name[i - 1]))
      break;
  }
 
  if (i != name.size())
    name = name.substr(0, i);
}
 
//----------------------------------------------------------------------------
std::string cpyrt::TypeManip::remove_const(const std::string& cppname) {
  // Remove 'const' qualifiers from the given C++ name.
  std::string::size_type tmplt_start = cppname.find('<');
  std::string::size_type type_stop = cppname.rfind('>');
  if (cppname.find("::", type_stop + 1) !=
      std::string::npos) // e.g. klass<T>::some_typedef
    type_stop = cppname.find(' ', type_stop + 1);
  if (tmplt_start != std::string::npos && cppname[tmplt_start + 1] != '<') {
    // only replace const qualifying cppname, not in template parameters
    std::string pre = cppname.substr(0, tmplt_start);
    erase_const(pre);
    std::string post = "";
    if (type_stop != std::string::npos && type_stop != cppname.size() - 1) {
      post = cppname.substr(type_stop + 1, std::string::npos);
      erase_const(post);
    }
 
    return pre + cppname.substr(tmplt_start, type_stop + 1 - tmplt_start) +
           post;
  }
 
  std::string clean_name = cppname;
  erase_const(clean_name);
  return clean_name;
}
 
//----------------------------------------------------------------------------
std::string cpyrt::TypeManip::clean_type(const std::string& cppname,
                                         bool template_strip,
                                         bool const_strip) {
  // Strip C++ name from all qualifiers and compounds.
  std::string::size_type i = find_qualifier_index(cppname);
  std::string name = cppname.substr(0, i);
  rstrip(name);
 
  if (name.back() == ']') { // array type?
    // TODO: this fails templates instantiated on arrays (not common)
    name = name.substr(0, name.find('['));
  } else if (template_strip && name.back() == '>') {
    name = name.substr(0, name.find('<'));
  }
 
  if (const_strip) {
    if (template_strip)
      erase_const(name);
    else
      name = remove_const(name);
  }
 
  return name;
}
 
//----------------------------------------------------------------------------
std::string cpyrt::TypeManip::template_base(const std::string& cppname) {
  // If this is a template, return the underlying template name w/o arguments
  if (cppname.empty() || cppname.back() != '>')
    return cppname;
 
  int tpl_open = 0;
  for (std::string::size_type pos = cppname.size() - 1; 0 < pos; --pos) {
    std::string::value_type c = cppname[pos];
 
    // count '<' and '>' to be able to skip template contents
    if (c == '>')
      --tpl_open;
    else if (c == '<' && cppname[pos + 1] != '<')
      ++tpl_open;
 
    if (tpl_open == 0)
      return cppname.substr(0, pos);
  }
 
  return cppname;
}
 
//----------------------------------------------------------------------------
std::string cpyrt::TypeManip::compound(const std::string& name) {
  // FIXME: temporary fix for translation unit decl being passed in
  // CreateExecutor from InitExecutor_ (run test10_object_identity), remove
  // later
  if (name.empty())
    return "";
  // Break down the compound of a fully qualified type name.
  std::string cleanName = remove_const(name);
  auto idx = find_qualifier_index(cleanName);
 
  std::string cpd = cleanName.substr(idx, std::string::npos);
 
  // for easy identification of fixed size arrays
  if (!cpd.empty() && cpd.back() == ']') {
    if (cpd.front() == '[')
      return "[]"; // fixed array any; dimensions handled separately
 
    std::ostringstream scpd;
    scpd << cpd.substr(0, cpd.find('[')) << "[]";
    cpd = scpd.str();
  }
 
  // XXX: remove this hack
  if (!cpd.empty() && cpd[0] == ' ')
    return cpd.substr(1, cpd.length() - 1);
 
  return cpd;
}
 
//----------------------------------------------------------------------------
void cpyrt::TypeManip::cppscope_to_pyscope(std::string& cppscope) {
  // Change '::' in C++ scope into '.' as in a Python scope.
  std::string::size_type pos = 0;
  while ((pos = cppscope.find("::", pos)) != std::string::npos) {
    cppscope.replace(pos, 2, ".");
    pos += 1;
  }
}
 
//----------------------------------------------------------------------------
void cpyrt::TypeManip::cppscope_to_legalname(std::string& cppscope) {
  // Change characters illegal in a variable name into '_' to form a legal name.
  for (char& c : cppscope) {
    for (char needle : {':', '>', '<', ' ', ',', '&', '=', '*', '-'})
      if (c == needle)
        c = '_';
  }
}
 
//----------------------------------------------------------------------------
std::string cpyrt::TypeManip::extract_namespace(const std::string& name) {
  // Find the namespace the named class lives in, take care of templates
  if (name.empty())
    return name;
 
  int tpl_open = 0;
  for (std::string::size_type pos = name.size() - 1; 0 < pos; --pos) {
    std::string::value_type c = name[pos];
 
    // count '<' and '>' to be able to skip template contents
    if (c == '>')
      --tpl_open;
    else if (c == '<' && name[pos + 1] != '<')
      ++tpl_open;
 
    // collect name up to "::"
    else if (tpl_open == 0 && c == ':' && name[pos - 1] == ':') {
      // found the extend of the scope ... done
      return name.substr(0, pos - 1);
    }
  }
 
  // no namespace; assume outer scope
  return "";
}
 
//----------------------------------------------------------------------------
std::vector<std::string>
cpyrt::TypeManip::extract_arg_types(const std::string& sig) {
  // break out the argument types from the signature string
  std::vector<std::string> result;
 
  if (sig.empty() || sig == "()")
    return result;
 
  int tpl_open = 0;
  std::string::size_type start = 1;
  for (std::string::size_type pos = 1; pos < sig.size() - 1; ++pos) {
    std::string::value_type c = sig[pos];
 
    // count '<' and '>' to be able to skip template contents
    if (c == '>')
      --tpl_open;
    else if (c == '<' && sig[pos + 1] != '<')
      ++tpl_open;
 
    // collect type name up to ',' or end ')'
    else if (tpl_open == 0 && c == ',') {
      // found the extend of the scope ... done
      result.push_back(sig.substr(start, pos - start));
      start = pos + 1;
    }
  }
 
  // add last type
  result.push_back(sig.substr(start, sig.rfind(")") - start));
 
  return result;
}
 
//----------------------------------------------------------------------------
Py_ssize_t cpyrt::TypeManip::array_size(const std::string& name) {
  // Extract the array size from a given type name (assumes 1D arrays)
  std::string cleanName = remove_const(name);
  if (cleanName[cleanName.size() - 1] == ']') {
    std::string::size_type idx = cleanName.rfind('[');
    if (idx != std::string::npos) {
      const std::string asize = cleanName.substr(idx + 1, cleanName.size() - 2);
      return strtoul(asize.c_str(), nullptr, 0);
    }
  }
 
  return -1;
}