CPPConstructor.cxx

Go to the documentation of this file.

// Bindings
#include "cpyrt.h"
 
using namespace cppjit;
#include "CPPConstructor.h"
#include "CPPInstance.h"
#include "Executors.h"
#include "MemoryRegulator.h"
#include "ProxyWrappers.h"
#include "PyStrings.h"
 
// Standard
#include <memory>
#include <string>
 
//- data _____________________________________________________________________
namespace cppjit::cpyrt {
extern PyObject* gNullPtrObject;
void* Instance_AsVoidPtr(PyObject* pyobject);
PyObject* Instance_FromVoidPtr(void* addr, interop::TCppScope_t klass_scope,
                               bool python_owns);
} // namespace cppjit::cpyrt
 
//- protected members --------------------------------------------------------
bool cpyrt::CPPConstructor::InitExecutor_(Executor*& executor, CallContext*) {
  // pick up special case new object executor
  executor = CreateExecutor("__init__");
  return true;
}
 
//- public members -----------------------------------------------------------
PyObject* cpyrt::CPPConstructor::GetDocString() {
  // GetMethod() may return an empty function if this is just a special case
  // place holder
  const std::string& clName = interop::GetFinalName(this->GetScope());
  return PyUnicode_FromFormat(
      "%s::%s%s", clName.c_str(), clName.c_str(),
      this->GetMethod() ? this->GetSignatureString().c_str() : "()");
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CPPConstructor::Reflex(interop::Reflex::RequestId_t request,
                                        interop::Reflex::FormatId_t format) {
  // C++ reflection tooling for constructors.
 
  if (request == interop::Reflex::RETURN_TYPE) {
    std::string fn = interop::GetScopedFinalName(this->GetScope());
    if (format == interop::Reflex::OPTIMAL ||
        format == interop::Reflex::AS_TYPE)
      return CreateScopeProxy(this->GetScope());
    else if (format == interop::Reflex::AS_STRING)
      return PyUnicode_FromString(fn.c_str());
  }
 
  return PyCallable::Reflex(request, format);
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CPPConstructor::Call(CPPInstance*& self, cpyrt_PyArgs_t args,
                                      size_t nargsf, PyObject* kwds,
                                      CallContext* ctxt) {
  // setup as necessary
  if (fArgsRequired == -1 && !this->Initialize(ctxt))
    return nullptr; // important: 0, not Py_None
 
  // fetch self, verify, and put the arguments in usable order
  PyCallArgs cargs{self, args, nargsf, kwds};
  if (!this->ProcessArgs(cargs))
    return nullptr;
 
  // verify existence of self (i.e. tp_new called)
  if (!self) {
    PyErr_SetString(PyExc_ReferenceError, "no python object allocated");
    return nullptr;
  }
 
  if (self->GetObject()) {
    PyErr_SetString(
        PyExc_ReferenceError,
        "object already constructed; use __assign__ instead of __init__");
    return nullptr;
  }
 
  const auto cppScopeFlags = ((CPPScope*)Py_TYPE(self))->fFlags;
 
  // Do nothing if the constructor is explicit and we are in an implicit
  // conversion context. See also the ConvertImplicit() helper in
  // Converters.cxx.
  if ((cppScopeFlags & CPPScope::kActiveImplicitCall) &&
      interop::IsExplicit(GetMethod())) {
    // FIXME: Cases with explicit marked std::complex constructors where we
    // expect implicit conversionss
    if (interop::GetMethodSignature(GetMethod(), true).find("std::complex") ==
        std::string::npos)
      return nullptr;
  }
 
  // self provides the python context for lifelines
  if (!ctxt->fPyContext)
    ctxt->fPyContext = (PyObject*)cargs.fSelf; // no Py_INCREF as no ownership
 
  // perform the call, nullptr 'this' makes the other side allocate the memory
  interop::TCppScope_t disp = self->ObjectIsA(false /* check_smart */);
  intptr_t address = 0;
  if (GetScope() != disp) {
    // happens for Python derived types (which have a dispatcher inserted that
    // is not otherwise user-visible: call it instead) and C++ derived classes
    // without public constructors
 
    // first, check whether we at least had a proper meta class, or whether that
    // was also replaced user-side
    if (!GetScope() || !disp) {
      PyErr_SetString(PyExc_TypeError,
                      "can not construct incomplete C++ class");
      return nullptr;
    }
 
    // get the dispatcher class and verify
    PyObject* dispproxy = cpyrt::GetScopeProxy(disp);
    if (!dispproxy) {
      PyErr_SetString(PyExc_TypeError, "dispatcher proxy was never created");
      return nullptr;
    }
 
    if (!(((CPPClass*)dispproxy)->fFlags & CPPScope::kIsPython)) {
      PyErr_SetString(PyExc_TypeError,
                      const_cast<char*>(("constructor for " +
                                         interop::GetScopedFinalName(disp) +
                                         " is not a dispatcher")
                                            .c_str()));
      return nullptr;
    }
 
    PyObject* pyobj =
        cpyrt_PyObject_Call(dispproxy, cargs.fArgs, cargs.fNArgsf, kwds);
    if (!pyobj)
      return nullptr;
 
    // retrieve the actual pointer, take over control, and set set
    // _internal_self
    address = (intptr_t)((CPPInstance*)pyobj)->GetObject();
    if (address) {
      ((CPPInstance*)pyobj)
          ->CppOwns(); // b/c self will control the object on address
      PyObject* res = PyObject_CallMethodObjArgs(
          dispproxy, PyStrings::gDispInit, pyobj, (PyObject*)self, nullptr);
      Py_XDECREF(res);
    }
    Py_DECREF(dispproxy);
 
  } else {
    // translate the arguments
    if (cppScopeFlags & CPPScope::kActiveImplicitCall)
      ctxt->fFlags |= CallContext::kNoImplicit;
    if (!this->ConvertAndSetArgs(cargs.fArgs, cargs.fNArgsf, ctxt))
      return nullptr;
 
    address = (intptr_t)this->Execute(nullptr, 0, ctxt);
  }
 
  // return object if successful, lament if not
  if (address) {
    Py_INCREF(self);
 
    // note: constructors are no longer set to take ownership by default;
    // instead that is decided by the method proxy (which carries a creator
    // flag) upon return
    self->Set((void*)address);
 
    // mark as actual to prevent needless auto-casting and register on its class
    self->fFlags |= CPPInstance::kIsActual;
    if (!(((CPPClass*)Py_TYPE(self))->fFlags & CPPScope::kIsSmart))
      MemoryRegulator::RegisterPyObject(self,
                                        interop::TCppObject_t((void*)address));
 
    // handling smart types this way is deeply fugly, but if CPPInstance sets
    // the proper types in op_new first, then the wrong init is called
    if (((CPPClass*)Py_TYPE(self))->fFlags & CPPScope::kIsSmart) {
      PyObject* pyclass =
          CreateScopeProxy(((CPPSmartClass*)Py_TYPE(self))->fUnderlyingType);
      if (pyclass) {
        self->SetSmart((PyObject*)Py_TYPE(self));
        Py_DECREF((PyObject*)Py_TYPE(self));
        Py_SET_TYPE(self, (PyTypeObject*)pyclass);
      }
    }
 
    // done with self
    Py_DECREF(self);
 
    Py_RETURN_NONE; // by definition
  }
 
  if (!PyErr_Occurred()) // should be set, otherwise write a generic error msg
    PyErr_SetString(PyExc_TypeError,
                    const_cast<char*>((interop::GetScopedFinalName(GetScope()) +
                                       " constructor failed")
                                          .c_str()));
 
  // do not throw an exception, nullptr might trigger the overload handler to
  // choose a different constructor, which if all fails will throw an exception
  return nullptr;
}
 
//----------------------------------------------------------------------------
cpyrt::CPPMultiConstructor::CPPMultiConstructor(interop::TCppScope_t scope,
                                                interop::TCppMethod_t method)
    : CPPConstructor(scope, method) {
  fNumBases = interop::GetNumBases(scope);
}
 
//----------------------------------------------------------------------------
cpyrt::CPPMultiConstructor::CPPMultiConstructor(const CPPMultiConstructor& s)
    : CPPConstructor(s), fNumBases(s.fNumBases) {}
 
//----------------------------------------------------------------------------
cpyrt::CPPMultiConstructor&
cpyrt::CPPMultiConstructor::operator=(const CPPMultiConstructor& s) {
  if (this != &s) {
    CPPConstructor::operator=(s);
    fNumBases = s.fNumBases;
  }
  return *this;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CPPMultiConstructor::Call(CPPInstance*& self,
                                           cpyrt_PyArgs_t argsin, size_t nargsf,
                                           PyObject* kwds, CallContext* ctxt) {
  // By convention, initialization parameters of multiple base classes are
  // grouped by target base class. Here, we disambiguate and put in "sentinel"
  // parameters that allow the dispatcher to propagate them.
 
  // Three options supported:
  //  0. empty args: default constructor call
  //  1. fNumBases tuples, each handed to individual constructors
  //  2. less than fNumBases, assuming (void) for the missing base constructors
  //  3. normal arguments, going to the first base only
 
  // TODO: this way of forwarding is expensive as the loop is external to this
  // call; it would be more efficient to have the argument handling happen
  // beforehand
 
  // fetch self, verify, and put the arguments in usable order (if self is not
  // handled first, arguments can not be reordered with sentinels in place)
  PyCallArgs cargs{self, argsin, nargsf, kwds};
  if (!this->ProcessArgs(cargs))
    return nullptr;
 
  // to re-use the argument handling, simply change the argument array into a
  // tuple (the benefits of not allocating the tuple are relatively minor in
  // this case)
  Py_ssize_t nargs = cpyrt_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf);
  PyObject* args = PyTuple_New(nargs);
  for (Py_ssize_t i = 0; i < nargs; ++i) {
    Py_INCREF(cargs.fArgs[i]);
    PyTuple_SET_ITEM(args, i, cargs.fArgs[i]);
  }
 
  // copy out self as it may have been updated
  self = cargs.fSelf;
 
  if (PyTuple_CheckExact(args) &&
      PyTuple_GET_SIZE(args)) { // case 0. falls through
    Py_ssize_t nArgs = PyTuple_GET_SIZE(args);
 
    bool isAllTuples = true;
    Py_ssize_t nArgsTot = 0;
    for (Py_ssize_t i = 0; i < nArgs; ++i) {
      PyObject* argi = PyTuple_GET_ITEM(args, i);
      if (!PyTuple_CheckExact(argi)) {
        isAllTuples = false;
        break;
      }
      nArgsTot += PyTuple_GET_SIZE(argi);
    }
 
    if (isAllTuples) {
      // copy over the arguments, while filling in the sentinels (case 1. & 2.),
      // with just sentinels for the remaining (void) calls (case 2.)
      PyObject* newArgs = PyTuple_New(nArgsTot + fNumBases - 1);
      Py_ssize_t idx = 0;
      for (Py_ssize_t i = 0; i < nArgs; ++i) {
        if (i != 0) {
          // add sentinel
          Py_INCREF(gNullPtrObject);
          PyTuple_SET_ITEM(newArgs, idx, gNullPtrObject);
          idx += 1;
        }
 
        PyObject* argi = PyTuple_GET_ITEM(args, i);
        for (Py_ssize_t j = 0; j < PyTuple_GET_SIZE(argi); ++j) {
          PyObject* item = PyTuple_GET_ITEM(argi, j);
          Py_INCREF(item);
          PyTuple_SET_ITEM(newArgs, idx, item);
          idx += 1;
        }
      }
 
      // add final sentinels as needed
      while (idx < (nArgsTot + fNumBases - 1)) {
        Py_INCREF(gNullPtrObject);
        PyTuple_SET_ITEM(newArgs, idx, gNullPtrObject);
        idx += 1;
      }
 
      Py_DECREF(args);
      args = newArgs;
    } else { // case 3. add sentinels
             // copy arguments as-is, then add sentinels at the end
      PyObject* newArgs = PyTuple_New(PyTuple_GET_SIZE(args) + fNumBases - 1);
      for (Py_ssize_t i = 0; i < nArgs; ++i) {
        PyObject* item = PyTuple_GET_ITEM(args, i);
        Py_INCREF(item);
        PyTuple_SET_ITEM(newArgs, i, item);
      }
      for (Py_ssize_t i = 0; i < fNumBases - 1; ++i) {
        Py_INCREF(gNullPtrObject);
        PyTuple_SET_ITEM(newArgs, i + nArgs, gNullPtrObject);
      }
      Py_DECREF(args);
      args = newArgs;
    }
  }
 
  nargs = PyTuple_GET_SIZE(args);
 
  // now unroll the new args tuple into a vector of objects
  auto argsu = std::unique_ptr<PyObject*[]>{new PyObject*[nargs]};
  for (Py_ssize_t i = 0; i < nargs; ++i)
    argsu[i] = PyTuple_GET_ITEM(args, i);
  cpyrt_PyArgs_t _args = argsu.get();
 
  PyObject* result = CPPConstructor::Call(self, _args, nargs, kwds, ctxt);
  Py_DECREF(args);
 
  return result;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CPPAbstractClassConstructor::Call(CPPInstance*& self,
                                                   cpyrt_PyArgs_t args,
                                                   size_t nargsf,
                                                   PyObject* kwds,
                                                   CallContext* ctxt) {
  // do not allow instantiation of abstract classes
  if ((self && GetScope() != self->ObjectIsA()) ||
      (!self && !(ctxt->fFlags & CallContext::kFromDescr) &&
       cpyrt_PyArgs_GET_SIZE(args, nargsf) && CPPInstance_Check(args[0]) &&
       GetScope() != ((CPPInstance*)args[0])->ObjectIsA())) {
    // happens if a dispatcher is inserted; allow constructor call
    return CPPConstructor::Call(self, args, nargsf, kwds, ctxt);
  }
 
  PyErr_Format(PyExc_TypeError,
               "cannot instantiate abstract class \'%s\'"
               " (from derived classes, use super() instead)",
               interop::GetScopedFinalName(this->GetScope()).c_str());
  return nullptr;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CPPNamespaceConstructor::Call(CPPInstance*&, cpyrt_PyArgs_t,
                                               size_t, PyObject*,
                                               CallContext*) {
  // do not allow instantiation of namespaces
  PyErr_Format(PyExc_TypeError, "cannot instantiate namespace \'%s\'",
               interop::GetScopedFinalName(this->GetScope()).c_str());
  return nullptr;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CPPIncompleteClassConstructor::Call(CPPInstance*&,
                                                     cpyrt_PyArgs_t, size_t,
                                                     PyObject*, CallContext*) {
  // do not allow instantiation of incomplete (forward declared) classes)
  PyErr_Format(PyExc_TypeError, "cannot instantiate incomplete class \'%s\'",
               interop::GetScopedFinalName(this->GetScope()).c_str());
  return nullptr;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CPPAllPrivateClassConstructor::Call(CPPInstance*&,
                                                     cpyrt_PyArgs_t, size_t,
                                                     PyObject*, CallContext*) {
  // do not allow instantiation of classes with only private constructors
  PyErr_Format(
      PyExc_TypeError,
      "cannot instantiate class \'%s\' that has no public constructors",
      interop::GetScopedFinalName(this->GetScope()).c_str());
  return nullptr;
}