DispatchPtr.cxx

Go to the documentation of this file.

// Bindings
#include "cpyrt.h"
 
using namespace cppjit;
#define CPYRT_INTERNAL 1
#include "cpyrt/DispatchPtr.h"
#undef CPYRT_INTERNAL
#include "CPPInstance.h"
#include "CPPScope.h"
 
//-----------------------------------------------------------------------------
PyObject* cppjit::cpyrt::DispatchPtr::Get(bool borrowed) const {
  PythonGILRAII python_gil_raii;
  if (fPyHardRef) {
    if (!borrowed)
      Py_INCREF(fPyHardRef);
    return fPyHardRef;
  }
  if (fPyWeakRef) {
    PyObject* disp = cpyrt_GetWeakRef(fPyWeakRef);
    if (disp) { // dispatcher object disappeared?
      if (borrowed)
        Py_DECREF(disp);
      return disp;
    }
  }
  return nullptr;
}
 
//-----------------------------------------------------------------------------
cppjit::cpyrt::DispatchPtr::DispatchPtr(PyObject* pyobj, bool strong)
    : fPyHardRef(nullptr) {
  PythonGILRAII python_gil_raii;
  if (strong) {
    Py_INCREF(pyobj);
    fPyHardRef = pyobj;
    fPyWeakRef = nullptr;
  } else {
    fPyHardRef = nullptr;
    fPyWeakRef = PyWeakref_NewRef(pyobj, nullptr);
  }
  ((CPPInstance*)pyobj)->SetDispatchPtr(this);
}
 
//-----------------------------------------------------------------------------
cppjit::cpyrt::DispatchPtr::DispatchPtr(const DispatchPtr& other, void* cppinst)
    : fPyWeakRef(nullptr) {
  PythonGILRAII python_gil_raii;
  PyObject* pyobj = other.Get(false /* not borrowed */);
  fPyHardRef =
      pyobj ? (PyObject*)((CPPInstance*)pyobj)->Copy(cppinst) : nullptr;
  if (fPyHardRef)
    ((CPPInstance*)fPyHardRef)->SetDispatchPtr(this);
  Py_XDECREF(pyobj);
}
 
//-----------------------------------------------------------------------------
cppjit::cpyrt::DispatchPtr::~DispatchPtr() {
  // if we're holding a hard reference, or holding weak reference while being
  // part of a dispatcher intermediate, then this delete is from the C++ side,
  // and Python is "notified" by nulling out the reference and an exception will
  // be raised on continued access
  PythonGILRAII python_gil_raii;
  if (fPyWeakRef) {
    PyObject* pyobj = cpyrt_GetWeakRef(fPyWeakRef);
    if (pyobj && ((CPPScope*)Py_TYPE(pyobj))->fFlags & CPPScope::kIsPython)
      ((CPPInstance*)pyobj)->GetObjectRaw() = nullptr;
    Py_XDECREF(pyobj);
    Py_DECREF(fPyWeakRef);
  } else if (fPyHardRef) {
    ((CPPInstance*)fPyHardRef)->GetObjectRaw() = nullptr;
    Py_DECREF(fPyHardRef);
  }
}
 
//-----------------------------------------------------------------------------
cppjit::cpyrt::DispatchPtr&
cppjit::cpyrt::DispatchPtr::assign(const DispatchPtr& other, void* cppinst) {
  PythonGILRAII python_gil_raii;
  if (this != &other) {
    Py_XDECREF(fPyWeakRef);
    fPyWeakRef = nullptr;
    Py_XDECREF(fPyHardRef);
    PyObject* pyobj = other.Get(false /* not borrowed */);
    fPyHardRef =
        pyobj ? (PyObject*)((CPPInstance*)pyobj)->Copy(cppinst) : nullptr;
    if (fPyHardRef)
      ((CPPInstance*)fPyHardRef)->SetDispatchPtr(this);
    Py_XDECREF(pyobj);
  }
  return *this;
}
 
//-----------------------------------------------------------------------------
void cppjit::cpyrt::DispatchPtr::PythonOwns() {
  PythonGILRAII python_gil_raii;
  // Python maintains the hardref, so only allowed a weakref here
  if (fPyHardRef) {
    fPyWeakRef = PyWeakref_NewRef(fPyHardRef, nullptr);
    Py_DECREF(fPyHardRef);
    fPyHardRef = nullptr;
  }
}
 
//-----------------------------------------------------------------------------
void cppjit::cpyrt::DispatchPtr::CppOwns() {
  PythonGILRAII python_gil_raii;
  // C++ maintains the hardref, keeping the PyObject alive w/o outstanding ref
  if (fPyWeakRef) {
    fPyHardRef = cpyrt_GetWeakRef(fPyWeakRef);
    Py_DECREF(fPyWeakRef);
    fPyWeakRef = nullptr;
  }
}