C++ PyEval_CallObject函数代码示例

static char *cpython_import_callback(void *ctx_, const char *base, const char *rel,
                                     char **found_here, int *success)
{
    const struct ImportCtx *ctx = ctx_;
    PyObject *arglist, *result;
    char *out;

    arglist = Py_BuildValue("(s, s)", base, rel);
    result = PyEval_CallObject(ctx->callback, arglist);
    Py_DECREF(arglist);

    if (result == NULL) {
        // Get string from exception
        char *out = jsonlang_str(ctx->vm, exc_to_str());
        *success = 0;
        PyErr_Clear();
        return out;
    }

    if (!PyTuple_Check(result)) {
        out = jsonlang_str(ctx->vm, "import_callback did not return a tuple");
        *success = 0;
    } else if (PyTuple_Size(result) != 2) {
        out = jsonlang_str(ctx->vm, "import_callback did not return a tuple (size 2)");
        *success = 0;
    } else {
        PyObject *file_name = PyTuple_GetItem(result, 0);
        PyObject *file_content = PyTuple_GetItem(result, 1);
        if (!PyString_Check(file_name) || !PyString_Check(file_content)) {
            out = jsonlang_str(ctx->vm, "import_callback did not return a pair of strings");
            *success = 0;
        } else {
            const char *found_here_cstr = PyString_AsString(file_name);
            const char *content_cstr = PyString_AsString(file_content);
            *found_here = jsonlang_str(ctx->vm, found_here_cstr);
            out = jsonlang_str(ctx->vm, content_cstr);
            *success = 1;
        }
    }

    Py_DECREF(result);

    return out;
}

static int function(double x[], double *f, double g[], void *state)
{
  PyObject *py_list, *arglist, *py_grad, *result = NULL;
  pytnc_state *py_state = (pytnc_state *)state;

  py_list = PyDoubleArray_AsList(py_state->n, x);
  if (py_list == NULL)
  {
    PyErr_SetString(PyExc_MemoryError, "tnc: memory allocation failed.");
    goto failure;
  }

  arglist = Py_BuildValue("(N)", py_list);
  result = PyEval_CallObject(py_state->py_function, arglist);
  Py_DECREF(arglist);

  if (result == NULL)
    goto failure;

  if (result == Py_None)
  {
    Py_DECREF(result);
    return 1;
  }

  if (!PyArg_ParseTuple(result, "dO!", f, &PyList_Type, &py_grad))
  {
    PyErr_SetString(PyExc_ValueError,
      "tnc: invalid return value from minimized function.");
    goto failure;
  }

  if (PyList_IntoDoubleArray(py_grad, g, py_state->n))
    goto failure;

  Py_DECREF(result);

  return 0;

failure:
  py_state->failed = 1;
  Py_XDECREF(result);
  return 1;
}

static OSErr GenericCoercionHandler(const AEDesc *fromDesc, DescType toType, SRefCon refcon, AEDesc *toDesc)
{	
	PyObject *handler = (PyObject *)refcon;
	AEDescObject *fromObject;
	PyObject *args, *res;
    PyGILState_STATE state;
	OSErr err = noErr;
	
	state = PyGILState_Ensure();
	if ((fromObject = (AEDescObject *)AE_AEDesc_New((AEDesc *)fromDesc)) == NULL) {
		err = -1;
		goto cleanup;
	}
	if ((args = Py_BuildValue("OO&", fromObject, AE_BuildOSType, &toType)) == NULL) {
		Py_DECREF(fromObject);
		err = -1;
		goto cleanup;
	}
	res = PyEval_CallObject(handler, args);
	fromObject->ob_itself.descriptorType = 'null';
	fromObject->ob_itself.dataHandle = NULL;
	Py_DECREF(args);
	if (res == NULL) {
		PySys_WriteStderr("Exception in AE coercion handler function\n");
		PyErr_Print();
		err = errAECoercionFail;
		goto cleanup;
	}
	if (!AEDesc_Check(res)) {
		PySys_WriteStderr("AE coercion handler function did not return an AEDesc\n");
		Py_DECREF(res);
		err = errAECoercionFail;
		goto cleanup;
	}
	if (AEDuplicateDesc(&((AEDescObject *)res)->ob_itself, toDesc)) {
		Py_DECREF(res);
		err = -1;
		goto cleanup;
	}
	Py_DECREF(res);
cleanup:
	PyGILState_Release(state);
	return err;
}

int
PyObject_AsFileDescriptor(PyObject *o)
{
    int fd;
    PyObject *meth;
    _Py_IDENTIFIER(fileno);

    if (PyLong_Check(o)) {
        fd = _PyLong_AsInt(o);
    }
    else if ((meth = _PyObject_GetAttrId(o, &PyId_fileno)) != NULL)
    {
        PyObject *fno = PyEval_CallObject(meth, NULL);
        Py_DECREF(meth);
        if (fno == NULL)
            return -1;

        if (PyLong_Check(fno)) {
            fd = _PyLong_AsInt(fno);
            Py_DECREF(fno);
        }
        else {
            PyErr_SetString(PyExc_TypeError,
                            "fileno() returned a non-integer");
            Py_DECREF(fno);
            return -1;
        }
    }
    else {
        PyErr_SetString(PyExc_TypeError,
                        "argument must be an int, or have a fileno() method.");
        return -1;
    }

    if (fd == -1 && PyErr_Occurred())
        return -1;
    if (fd < 0) {
        PyErr_Format(PyExc_ValueError,
                     "file descriptor cannot be a negative integer (%i)",
                     fd);
        return -1;
    }
    return fd;
}

 wxFileOffset OnSysSeek(wxFileOffset off, wxSeekMode mode) 
 {
     wxPyThreadBlocker blocker;
     PyObject* arglist = PyTuple_New(2);
 
     if (sizeof(wxFileOffset) > sizeof(long))
         // wxFileOffset is a 64-bit value...
         PyTuple_SET_ITEM(arglist, 0, PyLong_FromLongLong(off));
     else
         PyTuple_SET_ITEM(arglist, 0, wxPyInt_FromLong(off));
 
     PyTuple_SET_ITEM(arglist, 1, wxPyInt_FromLong(mode));
 
 
     PyObject* result = PyEval_CallObject(m_seek, arglist);
     Py_DECREF(arglist);
     Py_XDECREF(result);
     return OnSysTell();
 }

/*
 * Globally defined info callback
 *
 * Arguments: ssl   - The Connection
 *            where - The part of the SSL code that called us
 *            _ret  - The return code of the SSL function that called us
 * Returns:   None
 */
static void global_info_callback( const SSL * ssl, int where, int _ret )
{
	ssl_ConnectionObj *conn = (ssl_ConnectionObj *) SSL_get_app_data(ssl);

	PyObject *argv, *ret;


	argv = Py_BuildValue("(Oii)", (PyObject *) conn, where, _ret);
	/* We need to get back our thread state before calling the
	 callback */
	ret = PyEval_CallObject(conn->context->info_callback, argv);
	if ( ret == NULL )
		PyErr_Clear();
	else
		Py_DECREF(ret);
	Py_DECREF(argv);

	return;
}

static xmlSecTransformDataType xmlsec_TransformGetDataTypeMethod(xmlSecTransformPtr transform,
								 xmlSecTransformMode mode,
								 xmlSecTransformCtxPtr transformCtx) {
  PyObject *args, *result;
  PyObject *func = NULL;

  func = xmlHashLookup2(TransformGetDataTypeMethods, transform->id->name,
			transform->id->href);

  args = Py_BuildValue((char *) "OiO", wrap_xmlSecTransformPtr(transform),
		       mode, wrap_xmlSecTransformCtxPtr(transformCtx));

  Py_INCREF(func);
  result = PyEval_CallObject(func, args);
  Py_DECREF(func);
  Py_DECREF(args);

  return (PyInt_AsLong(result));
}

void py_empty_cb (struct tgl_state *TLSR, void *cb_extra, int success) {
    assert (TLSR == TLS);
    PyObject *callable = cb_extra;
    PyObject *arglist = NULL;
    PyObject *result = NULL;

    if(PyCallable_Check(callable)) {
        arglist = Py_BuildValue("(O)", success ? Py_True : Py_False);
        result = PyEval_CallObject(callable, arglist);
        Py_DECREF(arglist);

        if(result == NULL)
            PyErr_Print();

        Py_XDECREF(result);
    }

    Py_XDECREF(callable);
}

int RuleMatch_EndElement(RuleMatchObject *self, PyObject *node, ExpatName *name)
{
  PyObject *handler = self->handlers[Handler_EndElement];
  PyObject *args, *result;

  if (handler != NULL) {
    /* handler.endElement((namespaceURI, localName), tagName) */
    args = Py_BuildValue("O(OO)O", node,name->namespaceURI, name->localName,
                         name->qualifiedName);
    if (args == NULL)
      return -1;
    result = PyEval_CallObject(handler, args);
    Py_DECREF(args);
    if (result == NULL)
      return -1;
    Py_DECREF(result);
  }
  return 0;
}

long process_read_step(int slave_id)
{
	PyObject *arg, *mymod, *strfunc;
    PyObject *pystatus;
    long step = -1;
    Py_Initialize();
    mymod = PyImport_ImportModule("python_motor");
    strfunc = PyObject_GetAttrString(mymod,"read_step");
    arg = Py_BuildValue("(i)",slave_id);
    //printf("before call\n");
    pystatus = PyEval_CallObject(strfunc,arg);
    PyArg_Parse(pystatus,"l",&step);
    //printf("before finilize\n");
    printf("step is %d\n",step);
    Py_Finalize();
    //printf("After finilize\n");
    return step;

}

static int xmlsec_KeyDataXmlWriteMethod(xmlSecKeyDataId id, xmlSecKeyPtr key,
					xmlNodePtr node,
					xmlSecKeyInfoCtxPtr keyInfoCtx) {
  PyObject *args, *result;
  PyObject *func = NULL;

  func = xmlHashLookup(KeyDataXmlWriteMethods, id->name);

  args = Py_BuildValue((char *) "OOOO", wrap_xmlSecKeyDataId(id),
		       wrap_xmlSecKeyPtr(key), wrap_xmlNodePtr(node),
		       wrap_xmlSecKeyInfoCtxPtr(keyInfoCtx));

  Py_INCREF(func);
  result = PyEval_CallObject(func, args);
  Py_DECREF(func);
  Py_DECREF(args);

  return (PyInt_AsLong(result));
}

static int
multi_timer_callback(CURLM *multi,
                     long timeout_ms,
                     void *userp)
{
    CurlMultiObject *self;
    PyObject *arglist;
    PyObject *result = NULL;
    int ret = 0;       /* always success */
    PYCURL_DECLARE_THREAD_STATE;

    UNUSED(multi);

    /* acquire thread */
    self = (CurlMultiObject *)userp;
    if (!PYCURL_ACQUIRE_THREAD_MULTI())
        return ret;

    /* check args */
    if (self->t_cb == NULL)
        goto silent_error;

    /* run callback */
    arglist = Py_BuildValue("(i)", timeout_ms);
    if (arglist == NULL)
        goto verbose_error;
    result = PyEval_CallObject(self->t_cb, arglist);
    Py_DECREF(arglist);
    if (result == NULL)
        goto verbose_error;

    /* return values from timer callbacks should be ignored */

silent_error:
    Py_XDECREF(result);
    PYCURL_RELEASE_THREAD();
    return ret;
verbose_error:
    PyErr_Print();
    goto silent_error;

    return 0;
}

int process_go_position(int slave_id,float position)
{
     PyObject *arg, *mymod, *strfunc;
	 PyObject *pystatus;
     int status;
     Py_Initialize();
     mymod = PyImport_ImportModule("python_motor");
     strfunc = PyObject_GetAttrString(mymod,"go_position");
     arg = Py_BuildValue("(if)",slave_id,position);
     pystatus = PyEval_CallObject(strfunc,arg);
     status = PyObject_IsTrue(pystatus);
     //printf("status is %d\n",status);
     Py_XDECREF(mymod);
     Py_XDECREF(strfunc);
     Py_XDECREF(arg);
     Py_XDECREF(pystatus);
     Py_Finalize();
     return status;
}

/*
	Dumb greenlet used for controlling the shutdown (originally uWSGI only wait for the hub)
*/
PyObject *py_uwsgi_gevent_ctrl_gl(PyObject *self, PyObject *args) {
	for(;;) {
		PyObject *gevent_sleep_args = PyTuple_New(1);
                PyTuple_SetItem(gevent_sleep_args, 0, PyInt_FromLong(60));
                PyObject *gswitch = PyEval_CallObject(ugevent.greenlet_switch, gevent_sleep_args);
		// could be NULL on exception
		if (!gswitch) {
			// just for being paranid
			if (PyErr_Occurred()) {
				PyErr_Clear();
				break;
			}
		}
                Py_XDECREF(gswitch);
                Py_DECREF(gevent_sleep_args);
	}
	Py_INCREF(Py_None);
	return Py_None;
}

void * cli_thread(void *params)
{
	PyObject *strret, *strargs;
	int intret;
	int fExitOnCtrlC = (int)(size_t)params;
	dove_status status;
	PyGILState_STATE gstate;

	log_debug(PythonLibLogLevel, "Enter");

	gstate = PyGILState_Ensure();
	do
	{
		status = python_lib_embed_initialize_cli(NULL, fExitOnCtrlC);
		if (status != DOVE_STATUS_OK)
		{
			show_print("cli_thread initialize Failure %s",
			           DOVEStatusToString(status));
			break;
		}

		strargs = Py_BuildValue("()");
		if(strargs == NULL)
		{
			show_print("cli_thread Py_BuildValue returns NULL");
			break;
		}
		strret = PyEval_CallObject(Python_Lib_Cli.cli_start, strargs);
		Py_DECREF(strargs);
		if (strret == NULL)
		{
			show_print("cli_thread PyEval_CallObject returns NULL");
			break;
		}
		PyArg_Parse(strret, "i", &intret);
		Py_DECREF(strret);
	}while(0);

	PyGILState_Release(gstate);
	log_debug(PythonLibLogLevel, "Exit");
	return ((void *) NULL);
}