C++ PyLong_Check函数代码示例

static PyObject *Triton_getRegValue(PyObject *self, PyObject *regId) {
  RegisterOperand reg;
  uint64 tritonReg;

  if (!PyLong_Check(regId) && !PyInt_Check(regId))
    return PyErr_Format(PyExc_TypeError, "getRegValue(): expected a register id (IDREF.REG) as argument");

  if (!ap.getCurrentCtxH())
    return PyErr_Format(PyExc_TypeError, "getRegValue(): Can't call getRegValue() right now. You must run the program before.");

  tritonReg = PyLong_AsLong(regId);
  reg = createTmpReg(tritonReg);

  if (tritonReg >= ID_XMM0 && tritonReg <= ID_XMM15){
    uint128 value = ap.getSSERegisterValue(reg);
    return uint128ToPyLongObject(value);
  }

  return Py_BuildValue("k", ap.getRegisterValue(reg));
}

static int validItem(rpmTagClass tclass, PyObject *item)
{
    int rc;

    switch (tclass) {
    case RPM_NUMERIC_CLASS:
	rc = (PyLong_Check(item) || PyInt_Check(item));
	break;
    case RPM_STRING_CLASS:
	rc = (PyBytes_Check(item) || PyUnicode_Check(item));
	break;
    case RPM_BINARY_CLASS:
	rc = PyBytes_Check(item);
	break;
    default:
	rc = 0;
	break;
    }
    return rc;
}

/* adapted from Python source, floatobject.c:convert_to_double */
int
convert_to_double(PyObject *obj, double *dbl)
{
    if (PyFloat_Check(obj)) {
        *dbl = PyFloat_AS_DOUBLE(obj);
#ifndef IS_PY3K
    } else if (PyInt_Check(obj)) {
        *dbl = (double)PyInt_AS_LONG(obj);
#endif
    } else if (PyLong_Check(obj)) {
        *dbl = PyLong_AsDouble(obj);
        if (*dbl == -1.0 && PyErr_Occurred()) {
            return 0;
        }
    } else {
        PyErr_SetString(PyExc_ValueError, "Expected a number");
        return 0;
    }
    return 1;
}

static PyObject * AerospikePredicates_Equals(PyObject * self, PyObject * args)
{
	PyObject * py_bin = NULL;
	PyObject * py_val = NULL;

	if (PyArg_ParseTuple(args, "OO:equals", 
			&py_bin, &py_val) == false) {
		goto exit;
	}

	if (PyInt_Check(py_val) || PyLong_Check(py_val)) {
		return Py_BuildValue("iiOO", AS_PREDICATE_EQUAL, AS_INDEX_NUMERIC, py_bin, py_val);
	} else if (PyString_Check(py_val) || PyUnicode_Check(py_val)) {
		return Py_BuildValue("iiOO", AS_PREDICATE_EQUAL, AS_INDEX_STRING, py_bin, py_val);
	}

exit:
	Py_INCREF(Py_None);
	return Py_None;
}

static int
get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)
{
    unsigned PY_LONG_LONG x;

    v = get_pylong(v);
    if (v == NULL)
        return -1;
    assert(PyLong_Check(v));
    x = PyLong_AsUnsignedLongLong(v);
    Py_DECREF(v);
    if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred()) {
        if (PyErr_ExceptionMatches(PyExc_OverflowError))
            PyErr_SetString(StructError,
                            "argument out of range");
        return -1;
    }
    *p = x;
    return 0;
}

VALUE ptorLong(PyObject* pNum)
{
	if(!PyLong_Check(pNum)) return Qnil;

	VALUE rNum;
	long cNum;

	cNum = PyLong_AsLong(pNum);

	if(PyErr_ExceptionMatches(PyExc_OverflowError))
	{
		rpPythonError();
		return Qnil;
	}

	rNum = INT2NUM(cNum);

	return rNum;
	
}

static int BufferObj_set_cfa(Buffer *self, PyObject *value, void *_)
{
	long cfa_id;

	if (PyInt_Check(value))
		cfa_id = PyInt_AS_LONG(value);
	else if (PyLong_Check(value))
		cfa_id = PyLong_AsLong(value);
	else
		return -1;

	if (cfa_id >= _PLDRAW_CFA_N_) {
		PyErr_SetString(PyExc_ValueError, "Invalid CFA identifier");
		return -1;
	}

	pldraw_set_cfa(self->pldraw, cfa_id);

	return Buffer_update_cached_colors(self);
}

//-----------------------------------------------------------------------------
// NumberVar_SetValue()
//   Set the value of the variable.
//-----------------------------------------------------------------------------
static int NumberVar_SetValue(
    udt_NumberVar *var,                 // variable to set value for
    unsigned pos,                       // array position to set
    PyObject *value)                    // value to set
{
#if PY_MAJOR_VERSION < 3
    if (PyInt_Check(value))
        return NumberVar_SetValueFromInteger(var, pos, value);
#endif
    if (PyLong_Check(value))
        return NumberVar_SetValueFromLong(var, pos, value);
    if (PyBool_Check(value))
        return NumberVar_SetValueFromBoolean(var, pos, value);
    if (PyFloat_Check(value))
        return NumberVar_SetValueFromFloat(var, pos, value);
    if (Py_TYPE(value) == g_DecimalType)
        return NumberVar_SetValueFromDecimal(var, pos, value);
    PyErr_SetString(PyExc_TypeError, "expecting numeric data");
    return -1;
}

static int
get_size_t(PyObject *v, size_t *p)
{
    size_t x;

    v = get_pylong(v);
    if (v == NULL)
        return -1;
    assert(PyLong_Check(v));
    x = PyLong_AsSize_t(v);
    Py_DECREF(v);
    if (x == (size_t)-1 && PyErr_Occurred()) {
        if (PyErr_ExceptionMatches(PyExc_OverflowError))
            PyErr_SetString(StructError,
                            "argument out of range");
        return -1;
    }
    *p = x;
    return 0;
}

bool ChPythonEngine::GetInteger(const char* variable, int& return_val)
{
	PyObject * module = PyImport_AddModule("__main__"); // borrowed reference
	assert(module);                                     // __main__ should always exist

	PyObject * dictionary = PyModule_GetDict(module);   // borrowed reference
	assert(dictionary);                                 // __main__ should have a dictionary

	PyObject * result = PyDict_GetItemString(dictionary, variable);   // borrowed reference
	if (!result) 
		return false;

	if (PyLong_Check(result)) 
	{
		return_val = PyLong_AsLong(result); 
		return true;
	}

	return false;
}

/*static*/ PyObject *
ReplicateAttributes_SetNewPeriodicOrigin(PyObject *self, PyObject *args)
{
    ReplicateAttributesObject *obj = (ReplicateAttributesObject *)self;

    double *dvals = obj->data->GetNewPeriodicOrigin();
    if(!PyArg_ParseTuple(args, "ddd", &dvals[0], &dvals[1], &dvals[2]))
    {
        PyObject     *tuple;
        if(!PyArg_ParseTuple(args, "O", &tuple))
            return NULL;

        if(PyTuple_Check(tuple))
        {
            if(PyTuple_Size(tuple) != 3)
                return NULL;

            PyErr_Clear();
            for(int i = 0; i < PyTuple_Size(tuple); ++i)
            {
                PyObject *item = PyTuple_GET_ITEM(tuple, i);
                if(PyFloat_Check(item))
                    dvals[i] = PyFloat_AS_DOUBLE(item);
                else if(PyInt_Check(item))
                    dvals[i] = double(PyInt_AS_LONG(item));
                else if(PyLong_Check(item))
                    dvals[i] = PyLong_AsDouble(item);
                else
                    dvals[i] = 0.;
            }
        }
        else
            return NULL;
    }

    // Mark the newPeriodicOrigin in the object as modified.
    obj->data->SelectNewPeriodicOrigin();

    Py_INCREF(Py_None);
    return Py_None;
}

int
get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
{
  if (gdbpy_is_value_object (obj))
    *addr = value_as_address (value_object_to_value (obj));
  else if (PyLong_Check (obj))
    {
      /* Assume CORE_ADDR corresponds to unsigned long.  */
      *addr = PyLong_AsUnsignedLong (obj);
      if (PyErr_Occurred () != NULL)
	return 0;
    }
  else if (PyInt_Check (obj))
    {
      long val;

      /* Assume CORE_ADDR corresponds to unsigned long.  */
      val = PyInt_AsLong (obj);

      if (val >= 0)
	*addr = val;
      else
      {
	/* If no error ocurred, VAL is indeed negative.  */
	if (PyErr_Occurred () != NULL)
	  return 0;

	PyErr_SetString (PyExc_ValueError,
			 _("Supplied address is negative."));
	return 0;
      }
    }
  else
    {
      PyErr_SetString (PyExc_TypeError,
		       _("Invalid type for address."));
      return 0;
    }

  return 1;
}

/*static*/ PyObject *
TransferFunctionWidget_SetPosition(PyObject *self, PyObject *args)
{
    TransferFunctionWidgetObject *obj = (TransferFunctionWidgetObject *)self;

    float *fvals = obj->data->GetPosition();
    if(!PyArg_ParseTuple(args, "ffffffff", &fvals[0], &fvals[1], &fvals[2], &fvals[3], &fvals[4], &fvals[5], &fvals[6], &fvals[7]))
    {
        PyObject     *tuple;
        if(!PyArg_ParseTuple(args, "O", &tuple))
            return NULL;

        if(PyTuple_Check(tuple))
        {
            if(PyTuple_Size(tuple) != 8)
                return NULL;

            PyErr_Clear();
            for(int i = 0; i < PyTuple_Size(tuple); ++i)
            {
                PyObject *item = PyTuple_GET_ITEM(tuple, i);
                if(PyFloat_Check(item))
                    fvals[i] = float(PyFloat_AS_DOUBLE(item));
                else if(PyInt_Check(item))
                    fvals[i] = float(PyInt_AS_LONG(item));
                else if(PyLong_Check(item))
                    fvals[i] = float(PyLong_AsDouble(item));
                else
                    fvals[i] = 0.;
            }
        }
        else
            return NULL;
    }

    // Mark the Position in the object as modified.
    obj->data->SelectPosition();

    Py_INCREF(Py_None);
    return Py_None;
}

static int
music_delivery(sp_session * session, const sp_audioformat * format,
               const void *frames, int num_frames)
{
    PyGILState_STATE gstate;
    PyObject *res, *method;

#ifdef DEBUG
        fprintf(stderr, "[DEBUG]-session- >> music_delivery called\n");
#endif
    gstate = PyGILState_Ensure();
    int siz = frame_size(format);
    PyObject *pyframes = PyBuffer_FromMemory((void *)frames, num_frames * siz);
    Session *psession =
        (Session *) PyObject_CallObject((PyObject *)&SessionType, NULL);
    psession->_session = session;
    PyObject *client = (PyObject *)sp_session_userdata(session);
    method = PyObject_GetAttrString(client, "music_delivery");
    res =
        PyObject_CallFunction(method, "OOiiiii", psession,
                              pyframes, siz, num_frames, format->sample_type,
                              format->sample_rate, format->channels);
    int consumed = num_frames;  // assume all consumed
    if (!res)
        PyErr_WriteUnraisable(method);
    if (PyInt_Check(res))
        consumed = (int)PyInt_AsLong(res);
    else if (PyLong_Check(res))
        consumed = (int)PyLong_AsLong(res);
    else {
        PyErr_SetString(PyExc_TypeError,
                        "music_delivery must return an integer");
        PyErr_WriteUnraisable(method);
    }
    Py_DECREF(pyframes);
    Py_DECREF(psession);
    Py_XDECREF(res);
    Py_DECREF(method);
    PyGILState_Release(gstate);
    return consumed;
}

/*static*/ PyObject *
RadialResampleAttributes_SetCenter(PyObject *self, PyObject *args)
{
    RadialResampleAttributesObject *obj = (RadialResampleAttributesObject *)self;

    float *fvals = obj->data->GetCenter();
    if(!PyArg_ParseTuple(args, "fff", &fvals[0], &fvals[1], &fvals[2]))
    {
        PyObject     *tuple;
        if(!PyArg_ParseTuple(args, "O", &tuple))
            return NULL;

        if(PyTuple_Check(tuple))
        {
            if(PyTuple_Size(tuple) != 3)
                return NULL;

            PyErr_Clear();
            for(int i = 0; i < PyTuple_Size(tuple); ++i)
            {
                PyObject *item = PyTuple_GET_ITEM(tuple, i);
                if(PyFloat_Check(item))
                    fvals[i] = float(PyFloat_AS_DOUBLE(item));
                else if(PyInt_Check(item))
                    fvals[i] = float(PyInt_AS_LONG(item));
                else if(PyLong_Check(item))
                    fvals[i] = float(PyLong_AsDouble(item));
                else
                    fvals[i] = 0.;
            }
        }
        else
            return NULL;
    }

    // Mark the center in the object as modified.
    obj->data->SelectCenter();

    Py_INCREF(Py_None);
    return Py_None;
}