C++ PyLong_AsSsize_t函数代码示例

int
PySlice_GetIndices(PySliceObject *r, Py_ssize_t length,
                   Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
{
	/* XXX support long ints */
	if (r->step == Py_None) {
		*step = 1;
	} else {
		if (!PyLong_Check(r->step)) return -1;
		*step = PyLong_AsSsize_t(r->step);
	}
	if (r->start == Py_None) {
		*start = *step < 0 ? length-1 : 0;
	} else {
		if (!PyLong_Check(r->start)) return -1;
		*start = PyLong_AsSsize_t(r->start);
		if (*start < 0) *start += length;
	}
	if (r->stop == Py_None) {
		*stop = *step < 0 ? -1 : length;
	} else {
		if (!PyLong_Check(r->stop)) return -1;
		*stop = PyLong_AsSsize_t(r->stop);
		if (*stop < 0) *stop += length;
	}
	if (*stop > length) return -1;
	if (*start >= length) return -1;
	if (*step == 0) return -1;
	return 0;
}

/* SinglyLinkedList2.get(index) */
static PyObject *
SinglyLinkedList2_get(SinglyLinkedList2 *self, PyObject *indexobj)
{
  SinglyLinkedListNode *n;
  PyObject *item;
  Py_ssize_t index = -1;
  int i;

  if (indexobj != NULL && indexobj != Py_None) {
  index = PyLong_AsSsize_t(indexobj);
  if (index == -1 && PyErr_Occurred())
    return NULL;
  }
  if (index < 0 || index > self->size - 1) {
  PyErr_SetString(PyExc_IndexError, "LinkedList index out of range");
  return NULL;
  }

  n = self->head;
  for (i = 0; i < index; ++i)
  n = n->next;
  item = n->data;
  Py_INCREF(item);
  return item;
}

/* Insert item in external memory list.
 *
 * XXX: Support slice objects and negative indices?
 */
static int em_list_setitem(em_list_t *self, PyObject *key, PyObject *value)
{
    Py_ssize_t index;

    int ret = -1;

    /* Python 3 supports only long integers. */
#if PY_MAJOR_VERSION < 3
    if(PyInt_CheckExact(key))
    {
        index = PyInt_AsSsize_t(key);
        ret = em_list_setitem_safe(self, index, value);
    }
    else if(PyLong_CheckExact(key))
#else
    if(PyLong_CheckExact(key))
#endif
    {
        index = PyLong_AsSsize_t(key);
        ret = em_list_setitem_safe(self, index, value);
    }
    else
        PyErr_SetString(PyExc_TypeError, "Invalid index type");

    return ret;
}

/* ArrayList.remove(index) */
static PyObject *
ArrayList_remove(ArrayList *self, PyObject *indexobj)
{
  PyObject *old_item;
  Py_ssize_t index = -1;
  int j;

  if (indexobj != NULL && indexobj != Py_None) {
    index = PyLong_AsSsize_t(indexobj);
    if (index == -1 && PyErr_Occurred()) {
      PyErr_SetString(PyExc_RuntimeError, "WTF");
      return NULL;
    }
  }
  if (index < 0 || index >= self->capacity || index > self->size - 1) {
    PyErr_SetString(PyExc_IndexError, "ArrayList index out of range");
    return NULL;
  }

  old_item = self->data[index];
  for (j = index; j < self->size - 1; ++j) {
  self->data[j] = self->data[j+1];
  }
  Py_INCREF(Py_None);
  self->data[self->size-1] = Py_None;
  self->size -= 1;

  return old_item;
}

/* SinglyLinkedList2.set(index, item) */
static PyObject *
SinglyLinkedList2_set(SinglyLinkedList2 *self, PyObject *args)
{
  SinglyLinkedListNode *n;
  PyObject *indexobj = NULL, *itemobj = NULL, *old_item = NULL;
  Py_ssize_t index = -1;
  int i;

  if (!PyArg_ParseTuple(args, "OO", &indexobj, &itemobj)) {
  return NULL;
  }
  if (indexobj != NULL && indexobj != Py_None) {
  index = PyLong_AsSsize_t(indexobj);
  if (index == -1 && PyErr_Occurred())
    return NULL;
  }
  if (index < 0 || index > self->size - 1) {
  PyErr_SetString(PyExc_IndexError, "SinglyLinkedList2 index out of range");
  return NULL;
  }
  if (itemobj == NULL) {
  PyErr_SetString(PyExc_ValueError, "item == NULL");
  return NULL;
  }

  n = self->head;
  for (i = 0; i < index; ++i)
  n = n->next;
  ++self->state;
  old_item = n->data;
  Py_XDECREF(old_item);
  Py_INCREF(itemobj);
  n->data = itemobj;
  Py_RETURN_NONE;
}

/* Retrieve item from external memory list.
 *
 * XXX: Support slice objects and negative indices?
 */
static PyObject *em_list_getitem(em_list_t *self, PyObject *key)
{
    Py_ssize_t index;

    PyObject *r = NULL;

    /* Python 3 supports only long integers. */
#if PY_MAJOR_VERSION < 3
    if(PyInt_CheckExact(key))
    {
        index = PyInt_AsSsize_t(key);
        r = em_list_getitem_internal(self, index);
    }
    else if(PyLong_CheckExact(key))
#else
    if(PyLong_CheckExact(key))
#endif
    {
        index = PyLong_AsSsize_t(key);
        r = em_list_getitem_internal(self, index);
    }
    else
        PyErr_SetString(PyExc_TypeError, "Invalid key object type");

    return r;
}

static PyObject *SEQUENCE_REPEAT( ssizeargfunc repeatfunc, PyObject *seq, PyObject *n )
{
    if (unlikely( !PyIndex_Check( n ) ))
    {
        PyErr_Format(
            PyExc_TypeError,
            "can't multiply sequence by non-int of type '%s'",
            Py_TYPE( n )->tp_name
        );

        return NULL;
    }

    PyObject *index_value = PyNumber_Index( n );

    if (unlikely( index_value == NULL ))
    {
        return NULL;
    }

    /* We're done if PyInt_AsSsize_t() returns without error. */
#if PYTHON_VERSION < 300
    Py_ssize_t count = PyInt_AsSsize_t( index_value );
#else
    Py_ssize_t count = PyLong_AsSsize_t( index_value );
#endif

    Py_DECREF( index_value );

    if (unlikely( count == -1 )) // Note: -1 is an unlikely repetition count
    {
        PyObject *exception = GET_ERROR_OCCURRED();

        if (unlikely(  exception ))
        {
            if ( !EXCEPTION_MATCH_BOOL_SINGLE( exception, PyExc_OverflowError ) )
            {
                return NULL;
            }

            PyErr_Format(
                PyExc_OverflowError,
                "cannot fit '%s' into an index-sized integer",
                Py_TYPE( n )->tp_name
            );

            return NULL;
        }
    }

    PyObject *result = (*repeatfunc)( seq, count );

    if (unlikely( result == NULL ))
    {
        return NULL;
    }

    return result;
}

// set capture size
int ImageViewport_setCaptureSize (PyImage * self, PyObject * value, void * closure)
{
	// check validity of parameter
	if (value == NULL || !PySequence_Check(value) || PySequence_Length(value) != 2
		|| !PyLong_Check(PySequence_Fast_GET_ITEM(value, 0))
		|| !PyLong_Check(PySequence_Fast_GET_ITEM(value, 1)))
	{
		PyErr_SetString(PyExc_TypeError, "The value must be a sequence of 2 ints");
		return -1;
	}
	// set capture size
	short size [] = {
		short(PyLong_AsSsize_t(PySequence_Fast_GET_ITEM(value, 0))),
			short(PyLong_AsSsize_t(PySequence_Fast_GET_ITEM(value, 1)))
	};
	getImageViewport(self)->setCaptureSize(size);
	// success
	return 0;
}

void list_base::insert(object const& index, object_cref x)
{
#if PY_VERSION_HEX >= 0x03000000
    ssize_t index_ = PyLong_AsSsize_t(index.ptr());
#else
    long index_ = PyInt_AsLong(index.ptr());
#endif
    if (index_ == -1 && PyErr_Occurred())
        throw_error_already_set();
    this->insert(index_, x);
}

static int bpy_bmdeformvert_contains(BPy_BMDeformVert *self, PyObject *value)
{
	const int key = PyLong_AsSsize_t(value);

	if (key == -1 && PyErr_Occurred()) {
		PyErr_SetString(PyExc_TypeError,
		                "BMDeformVert.__contains__: expected an int");
		return -1;
	}

	return (defvert_find_index(self->data, key) != NULL) ? 1 : 0;
}

long list_base::index(object_cref value) const
{
    object result_obj(this->attr("index")(value));
#if PY_VERSION_HEX >= 0x03000000
    ssize_t result = PyLong_AsSsize_t(result_obj.ptr());
#else
    long result = PyInt_AsLong(result_obj.ptr());
#endif
    if (result == -1)
        throw_error_already_set();
    return result;
}

static PyObject *
iter_setstate(seqiterobject *it, PyObject *state)
{
    Py_ssize_t index = PyLong_AsSsize_t(state);
    if (index == -1 && PyErr_Occurred())
        return NULL;
    if (it->it_seq != NULL) {
        if (index < 0)
            index = 0;
        it->it_index = index;
    }
    Py_RETURN_NONE;
}

static PyObject *
tupleiter_setstate(tupleiterobject *it, PyObject *state)
{
    Py_ssize_t index = PyLong_AsSsize_t(state);
    if (index == -1 && PyErr_Occurred())
        return NULL;
    if (it->it_seq != NULL) {
        if (index < 0)
            index = 0;
        else if (it->it_seq != NULL && index > PyTuple_GET_SIZE(it->it_seq))
            index = PyTuple_GET_SIZE(it->it_seq);
        it->it_index = index;
    }
    Py_RETURN_NONE;
}

static PyObject *listvalue_mapping_subscript(PyObject *self, PyObject *key)
{
	CListValue *list= static_cast<CListValue *>(BGE_PROXY_REF(self));
	if (list==NULL) {
		PyErr_SetString(PyExc_SystemError, "value = CList[i], "BGE_PROXY_ERROR_MSG);
		return NULL;
	}
	
	if (PyUnicode_Check(key)) {
		CValue *item = ((CListValue*) list)->FindValue(_PyUnicode_AsString(key));
		if (item) {
			PyObject *pyobj = item->ConvertValueToPython();
			if (pyobj)
				return pyobj;
			else
				return item->GetProxy();
		}
	}
	else if (PyIndex_Check(key)) {
		Py_ssize_t index = PyLong_AsSsize_t(key);
		return listvalue_buffer_item(self, index); /* wont add a ref */
	}
	else if (PySlice_Check(key)) {
		Py_ssize_t start, stop, step, slicelength;

		if (PySlice_GetIndicesEx(key, list->GetCount(), &start, &stop, &step, &slicelength) < 0)
			return NULL;

		if (slicelength <= 0) {
			return PyList_New(0);
		}
		else if (step == 1) {
			return listvalue_buffer_slice(list, start, stop);
		}
		else {
			PyErr_SetString(PyExc_TypeError, "CList[slice]: slice steps not supported");
			return NULL;
		}
	}

	PyErr_Format(PyExc_KeyError,
	             "CList[key]: '%R' key not in list", key);
	return NULL;
}

ssize_t skull_module_unpack (void* md, skull_txn_t* txn,
                         const void* data, size_t data_len)
{
    PyGILState_STATE state = PyGILState_Ensure();
    module_data_t* mdata = (module_data_t*)md;

    // Prepare args
    PyObject* pyArgs = PyTuple_New(4);
    PyObject* pyModuleName = PyString_FromString(mdata->name);
    PyObject* pyEntryName  = PyString_FromString(MODULE_UNPACK_FUNCNAME);
    PyObject* pyTxn        = PyCapsule_New(txn, "skull_txn", NULL);
    PyObject* pyData       = PyString_FromStringAndSize((const char*)data,
                                                        (Py_ssize_t)data_len);

    PyTuple_SetItem(pyArgs, 0, pyModuleName);
    PyTuple_SetItem(pyArgs, 1, pyEntryName);
    PyTuple_SetItem(pyArgs, 2, pyTxn);
    PyTuple_SetItem(pyArgs, 3, pyData);

    // Call user module_unpack
    PyObject* pyConsumed = PyObject_CallObject(mdata->pyExecutorFunc, pyArgs);

    // Set to -1 by default, so if error occurred, like un-handled excpetions,
    //  then the entity will be destroyed soon
    ssize_t consumed = -1;

    if (!pyConsumed) {
        if (PyErr_Occurred()) PyErr_Print();
    } else {
        if (PyInt_Check(pyConsumed)) {
            consumed = PyInt_AsSsize_t(pyConsumed);
        } else if (PyLong_Check(pyConsumed)) {
            consumed = PyLong_AsSsize_t(pyConsumed);
        } else {
            fprintf(stderr, "Error: Cannot parse the pyConsumed object");
            _PyObject_Dump(pyConsumed);
        }
    }

    Py_XDECREF(pyConsumed);
    Py_DECREF(pyArgs);
    PyGILState_Release(state);
    return consumed;
}