python-native: Support explicit args in fastcall format

Right now, doesn't actually expose these as fastcall yet, so it isn't
efficient to use yet, but this is a good starting point for
compatibility and later implementation

Author: rdb

src/interrogate/functionRemap.cxx

@@ -684,9 +684,15 @@ setup_properties(const InterrogateFunction &ifunc, InterfaceMaker *interface_mak
       if (fname == "__traverse__") {
         // Hack to record this even though we can't wrap visitproc.
         param._remap = new ParameterRemapUnchanged(type);
-      } else {
-        // nout << "Can't handle parameter " << i << " of method " <<
-        // *_cppfunc << "\n";
+      }
+      else if (param._name == "args" &&
+               TypeManager::is_pointer_to_pointer_to_PyObject(type) &&
+               TypeManager::is_const_pointer_to_anything(type)) {
+        // Special case for PyObject *const *args
+        param._remap = new ParameterRemapUnchanged(type);
+      }
+      else {
+        //nout << "Can't handle parameter " << i << " of method " << *_cppfunc << "\n";
         return false;
       }
     } else {
@@ -824,6 +830,18 @@ setup_properties(const InterrogateFunction &ifunc, InterfaceMaker *interface_mak
       _flags |= F_explicit_args;
       _args_type = InterfaceMaker::AT_keyword_args;
     }
+    else if (_parameters.size() == first_param + 2 &&
+             _parameters[first_param]._name == "args" &&
+             _parameters[first_param + 1]._name == "nargs") {
+      _flags |= F_explicit_args | F_fastcall;
+    }
+    else if (_parameters.size() == first_param + 3 &&
+             _parameters[first_param]._name == "args" &&
+             _parameters[first_param + 1]._name == "nargs" &&
+             _parameters[first_param + 2]._name == "kwnames") {
+      _flags |= F_explicit_args | F_fastcall;
+      _args_type = InterfaceMaker::AT_keyword_args;
+    }
   }
 
   switch (_type) {
@@ -934,7 +952,8 @@ setup_properties(const InterrogateFunction &ifunc, InterfaceMaker *interface_mak
       _args_type = InterfaceMaker::AT_single_arg;
 
     } else {
-      if (_args_type == InterfaceMaker::AT_varargs) {
+      if (_args_type == InterfaceMaker::AT_varargs &&
+          (_flags & F_fastcall) == 0) {
         // Every other method can take keyword arguments, if they take more
         // than one argument, and the arguments are named.
         for (size_t i = first_param; i < _parameters.size(); ++i) {

src/interrogate/functionRemap.h

@@ -103,6 +103,7 @@ class FunctionRemap {
     F_hash               = 0x4000,
     F_explicit_args      = 0x8000,
     F_explicit_cls       =0x10000,
+    F_fastcall           =0x20000,
   };
 
   typedef std::vector<Parameter> Parameters;

src/interrogate/interfaceMakerPythonNative.cxx

@@ -4058,6 +4058,7 @@ write_function_for_name(ostream &out, Object *obj,
   int max_required_args = 0;
   bool all_nonconst = true;
   bool has_keywords = false;
+  bool has_fastcall = false;
 
   out << "/**\n * Python function wrapper for:\n";
   for (ri = remaps.begin(); ri != remaps.end(); ++ri) {
@@ -4077,6 +4078,10 @@ write_function_for_name(ostream &out, Object *obj,
         has_keywords = true;
       }
 
+      if (remap->_flags & FunctionRemap::F_fastcall) {
+        has_fastcall = true;
+      }
+
       max_required_args = max(max_num_args, max_required_args);
 
       for (int i = min_num_args; i <= max_num_args; ++i) {
@@ -4169,6 +4174,58 @@ write_function_for_name(ostream &out, Object *obj,
     max_required_args = collapse_default_remaps(map_sets, max_required_args);
   }
 
+  if (has_fastcall) {
+    if (args_type == AT_keyword_args && has_keywords) {
+      out << "  Py_ssize_t fc_nargs = PyTuple_GET_SIZE(args);\n";
+      out << "  PyObject *const *fc_args;\n";
+      out << "  PyObject *fc_kwnames;\n";
+      out << "  if (kwds == nullptr) {\n";
+      out << "    fc_args = &PyTuple_GET_ITEM(args, 0);\n";
+      out << "    fc_kwnames = nullptr;\n";
+      out << "  } else {\n";
+      out << "    Py_BEGIN_CRITICAL_SECTION(kwds);\n";
+      out << "    PyObject **fc_args_mut = (PyObject **)alloca(sizeof(PyObject *) * (fc_nargs + PyDict_GET_SIZE(kwds)));\n";
+      out << "    for (Py_ssize_t i = 0; i < fc_nargs; i++) {\n";
+      out << "      fc_args_mut[i] = PyTuple_GET_ITEM(args, i);\n";
+      out << "    }\n";
+      out << "    fc_kwnames = PyTuple_New(PyDict_GET_SIZE(kwds));\n";
+      out << "    PyObject *key, *value;\n";
+      out << "    Py_ssize_t pos = 0;\n";
+      out << "    Py_ssize_t i = 0;\n";
+      out << "    while (PyDict_Next(kwds, &pos, &key, &value)) {\n";
+      out << "      Py_INCREF(key);\n";
+      out << "      PyTuple_SET_ITEM(fc_kwnames, i, key);\n";
+      out << "      fc_args_mut[fc_nargs + i] = value;\n";
+      out << "      i++;\n";
+      out << "    }\n";
+      out << "    fc_args = fc_args_mut;\n";
+      out << "    Py_END_CRITICAL_SECTION();\n";
+      out << "  }\n";
+      return_flags |= RF_decref_kwnames;
+    }
+    else if (args_type == AT_varargs) {
+      out << "  Py_ssize_t fc_nargs = PyTuple_GET_SIZE(args);\n";
+      out << "  PyObject *const *fc_args = &PyTuple_GET_ITEM(args, 0);\n";
+      if (has_keywords) {
+        out << "  PyObject *fc_kwnames = nullptr;\n";
+      }
+    }
+    else if (args_type == AT_single_arg) {
+      out << "  Py_ssize_t fc_nargs = 1;\n";
+      out << "  PyObject *const *fc_args = &arg;\n";
+      if (has_keywords) {
+        out << "  PyObject *fc_kwnames = nullptr;\n";
+      }
+    }
+    else {
+      out << "  Py_ssize_t fc_nargs = 0;\n";
+      out << "  PyObject *const *fc_args = nullptr;\n";
+      if (has_keywords) {
+        out << "  PyObject *fc_kwnames = nullptr;\n";
+      }
+    }
+  }
+
   if (remap->_flags & FunctionRemap::F_explicit_args) {
     // We have a remap that wants to handle the wrapper itself.
     string expected_params;
@@ -5209,11 +5266,20 @@ write_function_instance(ostream &out, FunctionRemap *remap,
   if (remap->_flags & FunctionRemap::F_explicit_args) {
     // The function handles the arguments by itself.
     expected_params += "*args";
-    pexprs.push_back("args");
+    if (remap->_flags & FunctionRemap::F_fastcall) {
+      pexprs.push_back("fc_args");
+      pexprs.push_back("fc_nargs");
+    } else {
+      pexprs.push_back("args");
+    }
     if (remap->_args_type == AT_keyword_args) {
       if (args_type == AT_keyword_args) {
         expected_params += ", **kwargs";
-        pexprs.push_back("kwds");
+        if (remap->_flags & FunctionRemap::F_fastcall) {
+          pexprs.push_back("fc_kwnames");
+        } else {
+          pexprs.push_back("kwds");
+        }
       } else {
         pexprs.push_back("nullptr");
       }
@@ -6726,6 +6792,11 @@ write_function_instance(ostream &out, FunctionRemap *remap,
       return_flags &= ~RF_decref_args;
     }
 
+    if (return_flags & RF_decref_kwnames) {
+      indent(out, indent_level) << "Py_XDECREF(fc_kwnames);\n";
+      return_flags &= ~RF_decref_kwnames;
+    }
+
     // An even specialer special case for functions with void return or bool
     // return.  We have our own functions that do all this in a single
     // function call, so it should reduce the amount of code output while not
@@ -6811,6 +6882,11 @@ write_function_instance(ostream &out, FunctionRemap *remap,
       return_flags &= ~RF_decref_args;
     }
 
+    if (return_flags & RF_decref_kwnames) {
+      indent(out, indent_level) << "Py_XDECREF(fc_kwnames);\n";
+      return_flags &= ~RF_decref_kwnames;
+    }
+
     // Outputs code to check to see if an assertion has failed while the C++
     // code was executing, and report this failure back to Python.  Don't do
     // this for coercion constructors since they are called by other wrapper
@@ -7006,6 +7082,9 @@ error_return(ostream &out, int indent_level, int return_flags) {
   if (return_flags & RF_decref_args) {
     indent(out, indent_level) << "Py_DECREF(args);\n";
   }
+  if (return_flags & RF_decref_kwnames) {
+    indent(out, indent_level) << "Py_XDECREF(fc_kwnames);\n";
+  }
 
   if (return_flags & RF_int) {
     indent(out, indent_level) << "return -1;\n";
@@ -7032,6 +7111,9 @@ error_bad_args_return(ostream &out, int indent_level, int return_flags,
   if (return_flags & RF_decref_args) {
     indent(out, indent_level) << "Py_DECREF(args);\n";
   }
+  if (return_flags & RF_decref_kwnames) {
+    indent(out, indent_level) << "Py_XDECREF(fc_kwnames);\n";
+  }
 
   if ((return_flags & RF_err_null) != 0 &&
       (return_flags & RF_pyobject) != 0) {
@@ -7083,6 +7165,10 @@ error_raise_return(ostream &out, int indent_level, int return_flags,
     indent(out, indent_level) << "Py_DECREF(args);\n";
     return_flags &= ~RF_decref_args;
   }
+  if (return_flags & RF_decref_kwnames) {
+    indent(out, indent_level) << "Py_XDECREF(fc_kwnames);\n";
+    return_flags &= ~RF_decref_kwnames;
+  }
 
   if (format_args.empty()) {
     if (exc_type == "TypeError") {
@@ -8303,6 +8389,14 @@ is_remap_legal(FunctionRemap *remap) {
     ParameterRemap *param = remap->_parameters[pn]._remap;
     CPPType *orig_type = param->get_orig_type();
     if (param->get_default_value() == nullptr && !is_cpp_type_legal(orig_type)) {
+      if ((remap->_flags & FunctionRemap::F_explicit_args) != 0 &&
+          (remap->_flags & FunctionRemap::F_fastcall) != 0 &&
+          remap->_parameters[pn]._name == "args" &&
+          TypeManager::is_pointer_to_pointer_to_PyObject(orig_type) &&
+          TypeManager::is_const_pointer_to_anything(orig_type)) {
+        // Allow PyObject *const *args through.
+        continue;
+      }
       return false;
     }
   }

src/interrogate/interfaceMakerPythonNative.h

@@ -122,6 +122,9 @@ class InterfaceMakerPythonNative : public InterfaceMakerPython {
 
     // Used inside a rich comparison function.
     RF_richcompare_zero = 0x10000,
+
+    // Decref temporary kwnames object.
+    RF_decref_kwnames = 0x20000,
   };
 
   class SlottedFunctionDef {

src/interrogate/typeManager.cxx

@@ -1621,6 +1621,26 @@ is_pair(CPPType *type) {
   return false;
 }
 
+/**
+ * Returns true if the indicated type is PyObject *const *.
+ */
+bool TypeManager::
+is_pointer_to_pointer_to_PyObject(CPPType *type) {
+  switch (type->get_subtype()) {
+  case CPPDeclaration::ST_const:
+    return is_pointer_to_pointer_to_PyObject(type->as_const_type()->_wrapped_around);
+
+  case CPPDeclaration::ST_pointer:
+    return is_pointer_to_PyObject(type->as_pointer_type()->_pointing_at);
+
+  case CPPDeclaration::ST_typedef:
+    return is_pointer_to_pointer_to_PyObject(type->as_typedef_type()->_type);
+
+  default:
+    return false;
+  }
+}
+
 /**
  * Returns true if the indicated type is PyObject *.
  */

src/interrogate/typeManager.h

@@ -105,6 +105,7 @@ class TypeManager {
   static bool is_pointer_to_base(CPPType *type);
   static bool is_const_pointer_to_base(CPPType *type);
   static bool is_const_ref_to_pointer_to_base(CPPType *type);
+  static bool is_pointer_to_pointer_to_PyObject(CPPType *type);
   static bool is_pointer_to_PyObject(CPPType *type);
   static bool is_PyObject(CPPType *type);
   static bool is_pointer_to_PyTypeObject(CPPType *type);