[Backport] Replace NULL with nullptr

(cherry-picked and adapted from MeVisLab/pythonqt@c00ebf4)

It replaces occurrences of NULL with nullptr, switches from usage of "0"
to nullptr where a pointer is expected and fixes indentation of comments
in type structure (e.g PythonQtSlotFunction_Type)

It replaces comment "/* tp_print */" with "/* tp_vectorcall_offset */".
Starting with Python 3.0, the slot was unused. Then it was renamed in
Python 3.8 to support the new "vectorcall" protocol.
See https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_vectorcall_offset
and https://peps.python.org/pep-0590/#changes-to-the-pytypeobject-struct

It resolves conflicts in PythonQt.cpp maintaining changes introduced in this fork.

Author: mrbean-bremen

src/PythonQt.cpp

@@ -144,7 +144,7 @@ template<class T1, class T2> int PythonQtUpcastingOffset() {
 typedef QObject* PythonQtQObjectCreatorFunctionCB();
 
 //! helper template to create a derived QObject class
-template<class T> QObject* PythonQtCreateObject() { return new T(); };
+template<class T> QObject* PythonQtCreateObject() { return new T(); }
 
 //! Helper define to convert from QString to Python C-API
 #ifdef PY3K
@@ -260,7 +260,7 @@ class PYTHONQT_EXPORT PythonQt : public QObject {
 
   //! Overwrite default handling of stdin using a custom callback. It internally backup
   //! the original 'sys.stdin' into 'sys.pythonqt_original_stdin'
-  void setRedirectStdInCallback(PythonQtInputChangedCB* callback, void * callbackData = 0);
+  void setRedirectStdInCallback(PythonQtInputChangedCB* callback, void * callbackData = nullptr);
 
   //! Enable or disable stdin custom callback. It resets 'sys.stdin' using either 'sys.pythonqt_stdin'
   //! or 'sys.pythonqt_original_stdin'
@@ -331,7 +331,7 @@ class PYTHONQT_EXPORT PythonQt : public QObject {
   //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
   /* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
    you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
-  void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
+  void registerClass(const QMetaObject* metaobject, const char* package = nullptr, PythonQtQObjectCreatorFunctionCB* wrapperCreator = nullptr, PythonQtShellSetInstanceWrapperCB* shell = nullptr);
 
   //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
   //! (ownership of wrapper is passed to PythonQt)
@@ -341,7 +341,7 @@ class PYTHONQT_EXPORT PythonQt : public QObject {
    All slots that take a pointer to typeName as the first argument will be callable from Python on
    a variant object that contains such a type.
    */
-  void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
+  void registerCPPClass(const char* typeName, const char* parentTypeName = nullptr, const char* package = nullptr, PythonQtQObjectCreatorFunctionCB* wrapperCreator = nullptr, PythonQtShellSetInstanceWrapperCB* shell = nullptr);
 
   //! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
   //! and it will register the classes when it first sees a pointer to such a derived class
@@ -377,7 +377,7 @@ class PYTHONQT_EXPORT PythonQt : public QObject {
 
   //! evaluates the given script code and returns the result value
   QVariant evalScript(PyObject* object, const QString& script, int start = Py_file_input);
-  
+
   //! evaluates the given script code in context of given globals and locals and returns the result value
   QVariant evalScript(const QString& script, PyObject* globals, PyObject* locals, int start);
 
@@ -548,7 +548,7 @@ class PYTHONQT_EXPORT PythonQt : public QObject {
   //! the default importer allows to import files from anywhere QFile can read from,
   //! including the Qt resource system using ":". Keep in mind that you need to extend
   //! "sys.path" with ":" to be able to import from the Qt resources.
-  void installDefaultImporter() { setImporter(NULL); }
+  void installDefaultImporter() { setImporter(nullptr); }
 
   //! set paths that the importer should ignore
   void setImporterIgnorePaths(const QStringList& paths);
@@ -731,7 +731,7 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
   //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
   /* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
      you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
-  void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
+  void registerClass(const QMetaObject* metaobject, const char* package = nullptr, PythonQtQObjectCreatorFunctionCB* wrapperCreator = nullptr, PythonQtShellSetInstanceWrapperCB* shell = nullptr, PyObject* module = nullptr, int typeSlots = 0);
 
   //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
   //! (ownership of wrapper is passed to PythonQt)
@@ -741,7 +741,7 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
    All slots that take a pointer to typeName as the first argument will be callable from Python on
    a variant object that contains such a type.
    */
-  void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
+  void registerCPPClass(const char* typeName, const char* parentTypeName = nullptr, const char* package = nullptr, PythonQtQObjectCreatorFunctionCB* wrapperCreator = nullptr, PythonQtShellSetInstanceWrapperCB* shell = nullptr, PyObject* module = nullptr, int typeSlots = 0);
 
   //! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
   //! and it will register the classes when it first sees a pointer to such a derived class
@@ -760,7 +760,7 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
   static PyObject* createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject);
 
   //! helper method that creates a PythonQtInstanceWrapper object and registers it in the object map
-  PythonQtInstanceWrapper* createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);
+  PythonQtInstanceWrapper* createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = nullptr);
 
   //! get the class info for a meta object (if available)
   PythonQtClassInfo* getClassInfo(const QMetaObject* meta);
@@ -799,13 +799,13 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
   //! get the dynamic meta object for the given wrapper. It will contain the signals/slots that have been added in Python
   const QMetaObject* getDynamicMetaObject(PythonQtInstanceWrapper* wrapper, const QMetaObject* prototypeMetaObject);
 
-  //! recursively creates the dynamic meta object chain down to the Qt class wrapper. 
+  //! recursively creates the dynamic meta object chain down to the Qt class wrapper.
   const QMetaObject* setupDynamicMetaObjectChain(PythonQtClassWrapper* type, const QMetaObject* prototypeMetaObject);
 
   //! builds and returns the dynamic meta object for the given type, derived from prototypeMetaObject.
   const QMetaObject* buildDynamicMetaObject(PythonQtClassWrapper* type, const QMetaObject* prototypeMetaObject);
 
-  //! redirected from shell classes, tries to call the given meta call on the Python wrapper. 
+  //! redirected from shell classes, tries to call the given meta call on the Python wrapper.
   int handleMetaCall(QObject* object, PythonQtInstanceWrapper* wrapper, QMetaObject::Call call, int id, void** args);
 
   //! calls the given method on Python function with same name.
@@ -816,7 +816,7 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
   void setupSharedLibrarySuffixes();
 
   //! create a new pythonqt class wrapper and place it in the pythonqt module
-  void createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module = NULL);
+  void createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module = nullptr);
 
   //! get/create new package module (the returned object is a borrowed reference)
   PyObject* packageByName(const char* name);

src/PythonQt.h

@@ -66,54 +66,54 @@ static int PythonQtBoolResult_nonzero(PyObject *obj)
 
 // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr
 static PyNumberMethods PythonQtBoolResult_as_number = {
-  0,      /* nb_add */
-  0,      /* nb_subtract */
-  0,      /* nb_multiply */
+  nullptr,      /* nb_add */
+  nullptr,      /* nb_subtract */
+  nullptr,      /* nb_multiply */
 #ifndef PY3K
-  0,      /* nb_divide */
+  nullptr,      /* nb_divide */
 #endif
-  0,      /* nb_remainder */
-  0,      /* nb_divmod */
-  0,      /* nb_power */
-  0,      /* nb_negative */
-  0,      /* nb_positive */
-  0,      /* nb_absolute */
+  nullptr,      /* nb_remainder */
+  nullptr,      /* nb_divmod */
+  nullptr,      /* nb_power */
+  nullptr,      /* nb_negative */
+  nullptr,      /* nb_positive */
+  nullptr,      /* nb_absolute */
   PythonQtBoolResult_nonzero,      /* nb_nonzero / nb_bool in Py3K */
-  0,      /* nb_invert */
-  0,      /* nb_lshift */
-  0,      /* nb_rshift */
-  0,    /* nb_and */
-  0,    /* nb_xor */
-  0,    /* nb_or */
-#ifndef PY3K
-  0,      /* nb_coerce */
+  nullptr,      /* nb_invert */
+  nullptr,      /* nb_lshift */
+  nullptr,      /* nb_rshift */
+  nullptr,      /* nb_and */
+  nullptr,      /* nb_xor */
+  nullptr,      /* nb_or */
+#ifndef PY3K   
+  nullptr,      /* nb_coerce */
 #endif
-  0,      /* nb_int */
-  0,      /* nb_long  / nb_reserved in Py3K */
-  0,      /* nb_float */
+  nullptr,      /* nb_int */
+  nullptr,      /* nb_long  / nb_reserved in Py3K */
+  nullptr,      /* nb_float */
 #ifndef PY3K
-  0,      /* nb_oct */
-  0,      /* nb_hex */
+  nullptr,      /* nb_oct */
+  nullptr,      /* nb_hex */
 #endif
-  0,      /* nb_inplace_add */
-  0,      /* nb_inplace_subtract */
-  0,      /* nb_inplace_multiply */
+  nullptr,      /* nb_inplace_add */
+  nullptr,      /* nb_inplace_subtract */
+  nullptr,      /* nb_inplace_multiply */
 #ifndef PY3K
-  0,      /* nb_inplace_divide */
+  nullptr,      /* nb_inplace_divide */
 #endif
-  0,      /* nb_inplace_remainder */
-  0,      /* nb_inplace_power */
-  0,      /* nb_inplace_lshift */
-  0,      /* nb_inplace_rshift */
-  0,      /* nb_inplace_and */
-  0,      /* nb_inplace_xor */
-  0,      /* nb_inplace_or */
-  0,      /* nb_floor_divide */
-  0,      /* nb_true_divide */
-  0,      /* nb_inplace_floor_divide */
-  0,      /* nb_inplace_true_divide */
+  nullptr,      /* nb_inplace_remainder */
+  nullptr,      /* nb_inplace_power */
+  nullptr,      /* nb_inplace_lshift */
+  nullptr,      /* nb_inplace_rshift */
+  nullptr,      /* nb_inplace_and */
+  nullptr,      /* nb_inplace_xor */
+  nullptr,      /* nb_inplace_or */
+  nullptr,      /* nb_floor_divide */
+  nullptr,      /* nb_true_divide */
+  nullptr,      /* nb_inplace_floor_divide */
+  nullptr,      /* nb_inplace_true_divide */
 #ifdef PY3K
-  0,      /* nb_index in Py3K */
+  nullptr,      /* nb_index in Py3K */
 #endif
 };
 
@@ -122,37 +122,37 @@ PyTypeObject PythonQtBoolResult_Type = {
     "BoolResult",
     sizeof(PythonQtBoolResultObject),
     0,
-    0,     /* tp_dealloc */
-    0,          /* tp_print */
-    0,          /* tp_getattr */
-    0,          /* tp_setattr */
-    0,
+    nullptr,      /* tp_dealloc */
+    0,            /* tp_vectorcall_offset */
+    nullptr,      /* tp_getattr */
+    nullptr,      /* tp_setattr */
+    nullptr,
     (reprfunc)PythonQtBoolResult_repr,      /* tp_repr */
     &PythonQtBoolResult_as_number,          /* tp_as_number */
-    0,          /* tp_as_sequence */
-    0,          /* tp_as_mapping */
-    0,      /* tp_hash */
-    0,      /* tp_call */
-    0,          /* tp_str */
-    0,    /* tp_getattro */
-    0,          /* tp_setattro */
-    0,          /* tp_as_buffer */
+    nullptr,      /* tp_as_sequence */
+    nullptr,      /* tp_as_mapping */
+    nullptr,      /* tp_hash */
+    nullptr,      /* tp_call */
+    nullptr,      /* tp_str */
+    nullptr,      /* tp_getattro */
+    nullptr,      /* tp_setattro */
+    nullptr,      /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT,/* tp_flags */
-    "Result object that is useful for bool* arguments",          /* tp_doc */
-    0,    /* tp_traverse */
-    0,          /* tp_clear */
-    0,          /* tp_richcompare */
-    0,          /* tp_weaklistoffset */
-    0,          /* tp_iter */
-    0,          /* tp_iternext */
-    0,          /* tp_methods */
-    0,       /* tp_members */
-    0,       /* tp_getset */
-    0,          /* tp_base */
-    0,          /* tp_dict */
-    0,                         /* tp_descr_get */
-    0,                         /* tp_descr_set */
-    0,                         /* tp_dictoffset */
+    "Result object that is useful for bool* arguments",     /* tp_doc */
+    nullptr,      /* tp_traverse */
+    nullptr,      /* tp_clear */
+    nullptr,      /* tp_richcompare */
+    0,            /* tp_weaklistoffset */
+    nullptr,      /* tp_iter */
+    nullptr,      /* tp_iternext */
+    nullptr,      /* tp_methods */
+    nullptr,      /* tp_members */
+    nullptr,      /* tp_getset */
+    nullptr,      /* tp_base */
+    nullptr,      /* tp_dict */
+    nullptr,      /* tp_descr_get */
+    nullptr,      /* tp_descr_set */
+    0,            /* tp_dictoffset */
     (initproc)&PythonQtBoolResult_init,      /* tp_init */
 };