static PyObject *
xyzzy_foo(PyObject *self, PyObject* args)
{
- return PyInt_FromLong(42L);
+ return PyLong_FromLong(42L);
}
static PyMethodDef xyzzy_methods[] = {
if (pFunc && PyCallable_Check(pFunc)) {
pArgs = PyTuple_New(argc - 3);
for (i = 0; i < argc - 3; ++i) {
- pValue = PyInt_FromLong(atoi(argv[i + 3]));
+ pValue = PyLong_FromLong(atoi(argv[i + 3]));
if (!pValue) {
Py_DECREF(pArgs);
Py_DECREF(pModule);
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL) {
- printf("Result of call: %ld\n", PyInt_AsLong(pValue));
+ printf("Result of call: %ld\n", PyLong_AsLong(pValue));
Py_DECREF(pValue);
}
else {
Shoddy_increment(Shoddy *self, PyObject *unused)
{
self->state++;
- return PyInt_FromLong(self->state);
+ return PyLong_FromLong(self->state);
}
PyAPI_DATA(PyTypeObject) PyInt_Type;
*/
-#define PyInt_Check(op) PyLong_Check(op)
#define PyInt_CheckExact(op) (PyLong_CheckExact(op) && _PyLong_FitsInLong(op))
-#define PyInt_FromString PyLong_FromString
-#define PyInt_FromUnicode PyLong_FromUnicode
-#define PyInt_FromLong PyLong_FromLong
-#define PyInt_FromSize_t PyLong_FromSize_t
-#define PyInt_FromSsize_t PyLong_FromSsize_t
-#define PyInt_AsLong PyLong_AsLong
-#define PyInt_AsSsize_t PyLong_AsSsize_t
-#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
-#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+#ifdef 0
+# define PyInt_Check(op) PyLong_Check(op)
+# define PyInt_FromString PyLong_FromString
+# define PyInt_FromUnicode PyLong_FromUnicode
+# define PyInt_FromLong PyLong_FromLong
+# define PyInt_FromSize_t PyLong_FromSize_t
+# define PyInt_FromSsize_t PyLong_FromSsize_t
+# define PyInt_AsLong PyLong_AsLong
+# define PyInt_AsSsize_t PyLong_AsSsize_t
+# define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
+# define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+# define PyInt_AS_LONG PyLong_AS_LONG
+#endif
PyAPI_FUNC(long) PyInt_GetMax(void);
-#define PyInt_AS_LONG(op) PyLong_AsLong(op)
-
/* These aren't really part of the Int object, but they're handy; the protos
* are necessary for systems that need the magic of PyAPI_FUNC.
*/
PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject *);
PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *);
+/* It may be useful in the future. I've added it in the PyInt -> PyLong
+ cleanup to keep the extra information. [CH] */
+#define PyLong_AS_LONG(op) PyLong_AsLong(op)
+
/* Used by socketmodule.c */
#if SIZEOF_SOCKET_T <= SIZEOF_LONG
#define PyLong_FromSocket_t(fd) PyLong_FromLong((SOCKET_T)(fd))
static PyObject *PyCurses_ ## X (PyObject *self) \
{ \
PyCursesInitialised \
- return PyInt_FromLong((long) X()); }
+ return PyLong_FromLong((long) X()); }
#define NoArgReturnStringFunction(X) \
PyAPI_FUNC(void) _PyExc_Init(void);
PyAPI_FUNC(void) _PyImportHooks_Init(void);
PyAPI_FUNC(int) _PyFrame_Init(void);
-PyAPI_FUNC(int) _PyInt_Init(void);
PyAPI_FUNC(void) _PyFloat_Init(void);
PyAPI_FUNC(int) PyBytes_Init(void);
PyAPI_FUNC(void) PySet_Fini(void);
PyAPI_FUNC(void) PyString_Fini(void);
PyAPI_FUNC(void) PyBytes_Fini(void);
-PyAPI_FUNC(void) PyInt_Fini(void);
PyAPI_FUNC(void) PyFloat_Fini(void);
PyAPI_FUNC(void) PyOS_FiniInterrupts(void);
PyMac_Error(err);
return NULL;
}
- return PyInt_FromLong(where);
+ return PyLong_FromLong(where);
}
static char rf_close__doc__[] =
} else {
if (retValue == Py_None)
status = noErr;
- else if (PyInt_Check(retValue)) {
- status = PyInt_AsLong(retValue);
+ else if (PyLong_Check(retValue)) {
+ status = PyLong_AsLong(retValue);
} else
status = noErr; /* wrong object type, complain? */
Py_DECREF(retValue);
long l;
if (!CFNumberGetValue(src, kCFNumberLongType, &l))
/* XXXX Out of range! */;
- return PyInt_FromLong(l);
+ return PyLong_FromLong(l);
}
}
/* XXXX Should return as CFTypeRef, really... */
*dst = kCFBooleanFalse;
return 1;
}
- if (PyInt_Check(src)) {
- long v = PyInt_AsLong(src);
+ if (PyLong_Check(src)) {
+ long v = PyLong_AsLong(src);
*dst = CFNumberCreate(NULL, kCFNumberLongType, &v);
return 1;
}
PyMac_GetPoint, &startPoint, &callback))
return NULL;
if (callback && callback != Py_None) {
- if (PyInt_Check(callback) && PyInt_AS_LONG(callback) == -1)
+ if (PyLong_Check(callback) && PyLong_AS_LONG(callback) == -1)
upp = (ControlActionUPP)-1;
else {
settrackfunc(callback);
&callback))
return NULL;
if (callback && callback != Py_None) {
- if (PyInt_Check(callback) && PyInt_AS_LONG(callback) == -1)
+ if (PyLong_Check(callback) && PyLong_AS_LONG(callback) == -1)
upp = (ControlActionUPP)-1;
else {
settrackfunc(callback);
}
else {
Dlg_FilterProc_callback = callback;
- if (PyInt_Check(res)) {
- *itemHit = PyInt_AsLong(res);
+ if (PyLong_Check(res)) {
+ *itemHit = PyLong_AsLong(res);
rv = 1;
}
else
int DlgObj_Convert(PyObject *v, DialogPtr *p_itself)
{
if (v == Py_None) { *p_itself = NULL; return 1; }
- if (PyInt_Check(v)) { *p_itself = (DialogPtr)PyInt_AsLong(v);
+ if (PyLong_Check(v)) { *p_itself = (DialogPtr)PyLong_AsLong(v);
return 1; }
if (!DlgObj_Check(v))
{
iErr = Gestalt ( selector, &response );
if (iErr != 0)
return PyMac_Error(iErr);
- return PyInt_FromLong(response);
+ return PyLong_FromLong(response);
}
static struct PyMethodDef gestalt_methods[] = {
static PyObject *BMObj_get_baseAddr(BitMapObject *self, void *closure)
{
- return PyInt_FromLong((long)self->ob_itself->baseAddr);
+ return PyLong_FromLong((long)self->ob_itself->baseAddr);
}
#define BMObj_set_baseAddr NULL
static PyObject *BMObj_get_rowBytes(BitMapObject *self, void *closure)
{
- return PyInt_FromLong((long)self->ob_itself->rowBytes);
+ return PyLong_FromLong((long)self->ob_itself->rowBytes);
}
#define BMObj_set_rowBytes NULL
static PyObject *ResObj_get_size(ResourceObject *self, void *closure)
{
- return PyInt_FromLong(GetHandleSize(self->ob_itself));
+ return PyLong_FromLong(GetHandleSize(self->ob_itself));
}
#define ResObj_set_size NULL
if( (rsizes = PyTuple_New(arg.numsizes)) == NULL)
return NULL;
for( i=0; i<arg.numsizes; i++ )
- PyTuple_SetItem(rsizes, i, PyInt_FromLong((long)fsizes[i]));
+ PyTuple_SetItem(rsizes, i, PyLong_FromLong((long)fsizes[i]));
return rsizes;
}
{
if (v == Py_None) { *p_itself = NULL; return 1; }
- if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; }
+ if (PyLong_Check(v)) { *p_itself = (WindowPtr)PyLong_AsLong(v); return 1; }
{
DialogRef dlg;
index = internal_bisect_right(list, item, lo, hi);
if (index < 0)
return NULL;
- return PyInt_FromLong(index);
+ return PyLong_FromLong(index);
}
PyDoc_STRVAR(bisect_right_doc,
index = internal_bisect_left(list, item, lo, hi);
if (index < 0)
return NULL;
- return PyInt_FromLong(index);
+ return PyLong_FromLong(index);
}
PyDoc_STRVAR(bisect_left_doc,
/* no need to do anything, the structure has already been zeroed */
}
- else if (PyInt_Check(keyobj)) {
+ else if (PyLong_Check(keyobj)) {
/* verify access method type */
type = _DB_get_type(self);
if (type == -1)
/* Make a key out of the requested recno, use allocated space so DB
* will be able to realloc room for the real key if needed. */
- recno = PyInt_AS_LONG(keyobj);
+ recno = PyLong_AS_LONG(keyobj);
key->data = malloc(sizeof(db_recno_t));
if (key->data == NULL) {
PyErr_SetString(PyExc_MemoryError, "Key memory allocation failed");
/* add an integer to a dictionary using the given name as a key */
static void _addIntToDict(PyObject* dict, char *name, int value)
{
- PyObject* v = PyInt_FromLong((long) value);
+ PyObject* v = PyLong_FromLong((long) value);
if (!v || PyDict_SetItemString(dict, name, v))
PyErr_Clear();
v = PyLong_FromLongLong((PY_LONG_LONG) value);
else
#endif
- v = PyInt_FromLong((long) value);
+ v = PyLong_FromLong((long) value);
if (!v || PyDict_SetItemString(dict, name, v))
PyErr_Clear();
}
free_buf_view(dataobj, data_buf_view);
- return PyInt_FromLong(recno);
+ return PyLong_FromLong(recno);
}
else if (result == Py_None) {
retval = DB_DONOTINDEX;
}
- else if (PyInt_Check(result)) {
- retval = PyInt_AsLong(result);
+ else if (PyLong_Check(result)) {
+ retval = PyLong_AsLong(result);
}
else if (PyBytes_Check(result) || PyString_Check(result)) {
char* data;
err = self->db->fd(self->db, &the_fd);
MYDB_END_ALLOW_THREADS;
RETURN_IF_ERR();
- return PyInt_FromLong(the_fd);
+ return PyLong_FromLong(the_fd);
}
if (self->primaryDBType == DB_RECNO ||
self->primaryDBType == DB_QUEUE)
- pkeyObj = PyInt_FromLong(*(int *)pkey.data);
+ pkeyObj = PyLong_FromLong(*(int *)pkey.data);
else
pkeyObj = PyString_FromStringAndSize(pkey.data, pkey.size);
PyObject *keyObj;
int type = _DB_get_type(self);
if (type == DB_RECNO || type == DB_QUEUE)
- keyObj = PyInt_FromLong(*(int *)key.data);
+ keyObj = PyLong_FromLong(*(int *)key.data);
else
keyObj = PyString_FromStringAndSize(key.data, key.size);
#if (PY_VERSION_HEX >= 0x02040000)
err = self->db->get(self->db, txn, &key, &data, flags);
MYDB_END_ALLOW_THREADS;
if (err == DB_BUFFER_SMALL) {
- retval = PyInt_FromLong((long)data.size);
+ retval = PyLong_FromLong((long)data.size);
err = 0;
}
retval = self->db->get_byteswapped(self->db);
MYDB_END_ALLOW_THREADS;
#endif
- return PyInt_FromLong(retval);
+ return PyLong_FromLong(retval);
}
type = _DB_get_type(self);
if (type == -1)
return NULL;
- return PyInt_FromLong(type);
+ return PyLong_FromLong(type);
}
}
if (flags & DB_APPEND)
- retval = PyInt_FromLong(*((db_recno_t*)key.data));
+ retval = PyLong_FromLong(*((db_recno_t*)key.data));
else {
retval = Py_None;
Py_INCREF(retval);
/* we're in a callback within the DB code, we can't raise */
PyErr_Print();
res = _default_cmp(leftKey, rightKey);
- } else if (PyInt_Check(result)) {
- res = PyInt_AsLong(result);
+ } else if (PyLong_Check(result)) {
+ res = PyLong_AsLong(result);
} else {
PyErr_SetString(PyExc_TypeError,
"DB_bt_compare callback MUST return an int.");
Py_DECREF(tuple);
if (result == NULL)
return NULL;
- if (!PyInt_Check(result)) {
+ if (!PyLong_Check(result)) {
PyErr_SetString(PyExc_TypeError,
"callback MUST return an int");
return NULL;
- } else if (PyInt_AsLong(result) != 0) {
+ } else if (PyLong_AsLong(result) != 0) {
PyErr_SetString(PyExc_TypeError,
"callback failed to return 0 on two empty strings");
return NULL;
err = self->db->truncate(self->db, txn, &count, flags);
MYDB_END_ALLOW_THREADS;
RETURN_IF_ERR();
- return PyInt_FromLong(count);
+ return PyLong_FromLong(count);
}
#endif
++oldValue;
self->moduleFlags.getReturnsNone = (flags >= 1);
self->moduleFlags.cursorSetReturnsNone = (flags >= 2);
- return PyInt_FromLong(oldValue);
+ return PyLong_FromLong(oldValue);
}
#if (DBVER >= 41)
FREE_DBT_VIEW(key, keyobj, key_buf_view);
if (err == DB_BUFFER_SMALL || err == 0) {
- return PyInt_FromLong(1);
+ return PyLong_FromLong(1);
} else if (err == DB_NOTFOUND || err == DB_KEYEMPTY) {
- return PyInt_FromLong(0);
+ return PyLong_FromLong(0);
}
makeDBError(err);
break;
case DB_RECNO:
case DB_QUEUE:
- item = PyInt_FromLong(*((db_recno_t*)key.data));
+ item = PyLong_FromLong(*((db_recno_t*)key.data));
break;
}
break;
MYDB_END_ALLOW_THREADS;
RETURN_IF_ERR();
- return PyInt_FromLong(count);
+ return PyLong_FromLong(count);
}
if (self->mydb->primaryDBType == DB_RECNO ||
self->mydb->primaryDBType == DB_QUEUE)
- pkeyObj = PyInt_FromLong(*(int *)pkey.data);
+ pkeyObj = PyLong_FromLong(*(int *)pkey.data);
else
pkeyObj = PyString_FromStringAndSize(pkey.data, pkey.size);
PyObject *keyObj;
int type = _DB_get_type(self->mydb);
if (type == DB_RECNO || type == DB_QUEUE)
- keyObj = PyInt_FromLong(*(int *)key.data);
+ keyObj = PyLong_FromLong(*(int *)key.data);
else
keyObj = PyString_FromStringAndSize(key.data, key.size);
retval = PyTuple_Pack(3, keyObj, pkeyObj, dataObj);
recno = *((db_recno_t*)data.data);
free_dbt(&key);
free_dbt(&data);
- return PyInt_FromLong(recno);
+ return PyLong_FromLong(recno);
}
MYDB_END_ALLOW_THREADS;
if (err == DB_BUFFER_SMALL || !err) {
/* DB_BUFFER_SMALL means positive size, !err means zero length value */
- retval = PyInt_FromLong((long)data.size);
+ retval = PyLong_FromLong((long)data.size);
err = 0;
}
#endif
MYDB_END_ALLOW_THREADS;
RETURN_IF_ERR();
- return PyInt_FromLong(aborted);
+ return PyLong_FromLong(aborted);
}
MYDB_END_ALLOW_THREADS;
RETURN_IF_ERR();
- return PyInt_FromLong((long)theID);
+ return PyLong_FromLong((long)theID);
}
#if (DBVER >= 40)
++oldValue;
self->moduleFlags.getReturnsNone = (flags >= 1);
self->moduleFlags.cursorSetReturnsNone = (flags >= 2);
- return PyInt_FromLong(oldValue);
+ return PyLong_FromLong(oldValue);
}
id = txn_id(self->txn);
#endif
MYDB_END_ALLOW_THREADS;
- return PyInt_FromLong(id);
+ return PyLong_FromLong(id);
}
#if (DBVER >= 43)
MYDB_END_ALLOW_THREADS
RETURN_IF_ERR();
- return PyInt_FromLong(size);
+ return PyLong_FromLong(size);
}
static PyObject*
MYDB_END_ALLOW_THREADS
RETURN_IF_ERR();
- return PyInt_FromLong((int)flags);
+ return PyLong_FromLong((int)flags);
}
static PyObject*
if (!PyArg_ParseTupleAndKeywords(args, kwdargs, "|OO:deque", kwlist, &iterable, &maxlenobj))
return -1;
if (maxlenobj != NULL && maxlenobj != Py_None) {
- maxlen = PyInt_AsLong(maxlenobj);
+ maxlen = PyLong_AsLong(maxlenobj);
if (maxlen == -1 && PyErr_Occurred())
return -1;
if (maxlen < 0) {
static PyObject *
dequeiter_len(dequeiterobject *it)
{
- return PyInt_FromLong(it->counter);
+ return PyLong_FromLong(it->counter);
}
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
static PyObject *
Dialect_get_quoting(DialectObj *self)
{
- return PyInt_FromLong(self->quoting);
+ return PyLong_FromLong(self->quoting);
}
static int
"\"%s\" must be an integer", name);
return -1;
}
- *target = PyInt_AsLong(src);
+ *target = PyLong_AsLong(src);
}
return 0;
}
"limit must be an integer");
return NULL;
}
- field_limit = PyInt_AsLong(new_limit);
+ field_limit = PyLong_AsLong(new_limit);
}
- return PyInt_FromLong(old_limit);
+ return PyLong_FromLong(old_limit);
}
/*
CDataType_from_address(PyObject *type, PyObject *value)
{
void *buf;
- if (!PyInt_Check(value)) {
+ if (!PyLong_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"integer expected");
return NULL;
obj = PyObject_GetAttrString(dll, "_handle");
if (!obj)
return NULL;
- if (!PyInt_Check(obj)) {
+ if (!PyLong_Check(obj)) {
PyErr_SetString(PyExc_TypeError,
"the _handle attribute of the second argument must be an integer");
Py_DECREF(obj);
StgDictObject *typedict;
if (value == Py_None)
- return PyInt_FromLong(0); /* NULL pointer */
+ return PyLong_FromLong(0); /* NULL pointer */
typedict = PyType_stgdict(type);
assert(typedict); /* Cannot be NULL for pointer types */
"which must be a positive integer");
return NULL;
}
- length = PyInt_AS_LONG(proto);
+ length = PyLong_AS_LONG(proto);
proto = PyDict_GetItemString(typedict, "_type_"); /* Borrowed ref */
if (!proto) {
}
/* Should probably allow buffer interface as well */
/* int, long */
- if (PyInt_Check(value)) {
+ if (PyLong_Check(value)) {
PyCArgObject *parg;
struct fielddesc *fd = getentry("P");
stgdict->ffi_type_pointer = ffi_type_pointer;
ob = PyDict_GetItemString((PyObject *)stgdict, "_flags_");
- if (!ob || !PyInt_Check(ob)) {
+ if (!ob || !PyLong_Check(ob)) {
PyErr_SetString(PyExc_TypeError,
"class must define _flags_ which must be an integer");
return -1;
}
- stgdict->flags = PyInt_AS_LONG(ob);
+ stgdict->flags = PyLong_AS_LONG(ob);
/* _argtypes_ is optional... */
ob = PyDict_GetItemString((PyObject *)stgdict, "_argtypes_");
_get_name(PyObject *obj, char **pname)
{
#ifdef MS_WIN32
- if (PyInt_Check(obj)) {
+ if (PyLong_Check(obj)) {
/* We have to use MAKEINTRESOURCEA for Windows CE.
Works on Windows as well, of course.
*/
- *pname = MAKEINTRESOURCEA(PyInt_AsUnsignedLongMask(obj) & 0xFFFF);
+ *pname = MAKEINTRESOURCEA(PyLong_AsUnsignedLongMask(obj) & 0xFFFF);
return 1;
}
#endif
obj = PyObject_GetAttrString(dll, "_handle");
if (!obj)
return NULL;
- if (!PyInt_Check(obj)) {
+ if (!PyLong_Check(obj)) {
PyErr_SetString(PyExc_TypeError,
"the _handle attribute of the second argument must be an integer");
Py_DECREF(obj);
return CFuncPtr_FromDll(type, args, kwds);
#ifdef MS_WIN32
- if (2 <= PyTuple_GET_SIZE(args) && PyInt_Check(PyTuple_GET_ITEM(args, 0)))
+ if (2 <= PyTuple_GET_SIZE(args) && PyLong_Check(PyTuple_GET_ITEM(args, 0)))
return CFuncPtr_FromVtblIndex(type, args, kwds);
#endif
if (1 == PyTuple_GET_SIZE(args)
- && (PyInt_Check(PyTuple_GET_ITEM(args, 0)))) {
+ && (PyLong_Check(PyTuple_GET_ITEM(args, 0)))) {
CDataObject *ob;
void *ptr = PyLong_AsVoidPtr(PyTuple_GET_ITEM(args, 0));
if (ptr == NULL)
calls below. */
/* We HAVE already checked that the tuple can be parsed with "i|ZO", so... */
Py_ssize_t tsize = PyTuple_GET_SIZE(item);
- flag = PyInt_AS_LONG(PyTuple_GET_ITEM(item, 0));
+ flag = PyLong_AS_LONG(PyTuple_GET_ITEM(item, 0));
name = tsize > 1 ? PyTuple_GET_ITEM(item, 1) : NULL;
defval = tsize > 2 ? PyTuple_GET_ITEM(item, 2) : NULL;
/* ['in', 'lcid'] parameter. Always taken from defval,
if given, else the integer 0. */
if (defval == NULL) {
- defval = PyInt_FromLong(0);
+ defval = PyLong_FromLong(0);
if (defval == NULL)
goto error;
} else
return;
PyModule_AddObject(m, "COMError", ComError);
- PyModule_AddObject(m, "FUNCFLAG_HRESULT", PyInt_FromLong(FUNCFLAG_HRESULT));
- PyModule_AddObject(m, "FUNCFLAG_STDCALL", PyInt_FromLong(FUNCFLAG_STDCALL));
+ PyModule_AddObject(m, "FUNCFLAG_HRESULT", PyLong_FromLong(FUNCFLAG_HRESULT));
+ PyModule_AddObject(m, "FUNCFLAG_STDCALL", PyLong_FromLong(FUNCFLAG_STDCALL));
#endif
- PyModule_AddObject(m, "FUNCFLAG_CDECL", PyInt_FromLong(FUNCFLAG_CDECL));
- PyModule_AddObject(m, "FUNCFLAG_PYTHONAPI", PyInt_FromLong(FUNCFLAG_PYTHONAPI));
+ PyModule_AddObject(m, "FUNCFLAG_CDECL", PyLong_FromLong(FUNCFLAG_CDECL));
+ PyModule_AddObject(m, "FUNCFLAG_PYTHONAPI", PyLong_FromLong(FUNCFLAG_PYTHONAPI));
PyModule_AddStringConstant(m, "__version__", "1.1.0");
PyModule_AddObject(m, "_memmove_addr", PyLong_FromVoidPtr(memmove));
#define RTLD_GLOBAL RTLD_LOCAL
#endif
- PyModule_AddObject(m, "RTLD_LOCAL", PyInt_FromLong(RTLD_LOCAL));
- PyModule_AddObject(m, "RTLD_GLOBAL", PyInt_FromLong(RTLD_GLOBAL));
+ PyModule_AddObject(m, "RTLD_LOCAL", PyLong_FromLong(RTLD_LOCAL));
+ PyModule_AddObject(m, "RTLD_GLOBAL", PyLong_FromLong(RTLD_GLOBAL));
PyExc_ArgError = PyErr_NewException("ctypes.ArgumentError", NULL, NULL);
if (PyExc_ArgError) {
return E_FAIL;
}
- retval = PyInt_AsLong(result);
+ retval = PyLong_AsLong(result);
if (PyErr_Occurred()) {
PyErr_WriteUnraisable(context ? context : Py_None);
retval = E_FAIL;
return E_FAIL;
}
- retval = PyInt_AsLong(result);
+ retval = PyLong_AsLong(result);
if (PyErr_Occurred()) {
PyErr_WriteUnraisable(context ? context : Py_None);
retval = E_FAIL;
return NULL;
if (FAILED(hr))
return PyErr_SetFromWindowsErr(hr);
- return PyInt_FromLong(hr);
+ return PyLong_FromLong(hr);
}
#endif
PyObject *retval, *v;
if (restype == NULL)
- return PyInt_FromLong(*(int *)result);
+ return PyLong_FromLong(*(int *)result);
if (restype == Py_None) {
Py_INCREF(Py_None);
if (*(int *)resbuf & 0x80000000)
retval = GetComError(*(HRESULT *)resbuf, iid, pIunk);
else
- retval = PyInt_FromLong(*(int *)resbuf);
+ retval = PyLong_FromLong(*(int *)resbuf);
} else if (flags & FUNCFLAG_HRESULT) {
if (*(int *)resbuf & 0x80000000)
retval = PyErr_SetFromWindowsErr(*(int *)resbuf);
else
- retval = PyInt_FromLong(*(int *)resbuf);
+ retval = PyLong_FromLong(*(int *)resbuf);
} else
#endif
retval = GetResult(restype, resbuf, checker);
pdst = (IUnknown **)b.value.p;
if (pdst == NULL)
- r = PyInt_FromLong(E_POINTER);
+ r = PyLong_FromLong(E_POINTER);
else {
if (src)
src->lpVtbl->AddRef(src);
*pdst = src;
- r = PyInt_FromLong(S_OK);
+ r = PyLong_FromLong(S_OK);
}
done:
Py_XDECREF(a.keep);
dict = PyType_stgdict(obj);
if (dict)
- return PyInt_FromSsize_t(dict->size);
+ return PyLong_FromSsize_t(dict->size);
if (CDataObject_Check(obj))
- return PyInt_FromSsize_t(((CDataObject *)obj)->b_size);
+ return PyLong_FromSsize_t(((CDataObject *)obj)->b_size);
PyErr_SetString(PyExc_TypeError,
"this type has no size");
return NULL;
dict = PyType_stgdict(obj);
if (dict)
- return PyInt_FromSsize_t(dict->align);
+ return PyLong_FromSsize_t(dict->align);
dict = PyObject_stgdict(obj);
if (dict)
- return PyInt_FromSsize_t(dict->align);
+ return PyLong_FromSsize_t(dict->align);
PyErr_SetString(PyExc_TypeError,
"no alignment info");
static PyObject *
CField_get_offset(PyObject *self, void *data)
{
- return PyInt_FromSsize_t(((CFieldObject *)self)->offset);
+ return PyLong_FromSsize_t(((CFieldObject *)self)->offset);
}
static PyObject *
CField_get_size(PyObject *self, void *data)
{
- return PyInt_FromSsize_t(((CFieldObject *)self)->size);
+ return PyLong_FromSsize_t(((CFieldObject *)self)->size);
}
static PyGetSetDef CField_getset[] = {
get_long(PyObject *v, long *p)
{
long x;
- if (!PyInt_Check(v)) {
+ if (!PyLong_Check(v)) {
PyErr_Format(PyExc_TypeError,
"int expected instead of %s instance",
v->ob_type->tp_name);
return -1;
}
- x = PyInt_AsUnsignedLongMask(v);
+ x = PyLong_AsUnsignedLongMask(v);
if (x == -1 && PyErr_Occurred())
return -1;
*p = x;
get_ulong(PyObject *v, unsigned long *p)
{
unsigned long x;
- if (!PyInt_Check(v)) {
+ if (!PyLong_Check(v)) {
PyErr_Format(PyExc_TypeError,
"int expected instead of %s instance",
v->ob_type->tp_name);
return -1;
}
- x = PyInt_AsUnsignedLongMask(v);
+ x = PyLong_AsUnsignedLongMask(v);
if (x == -1 && PyErr_Occurred())
return -1;
*p = x;
get_longlong(PyObject *v, PY_LONG_LONG *p)
{
PY_LONG_LONG x;
- if (!PyInt_Check(v)) {
+ if (!PyLong_Check(v)) {
PyErr_Format(PyExc_TypeError,
"int expected instead of %s instance",
v->ob_type->tp_name);
return -1;
}
- x = PyInt_AsUnsignedLongLongMask(v);
+ x = PyLong_AsUnsignedLongLongMask(v);
if (x == -1 && PyErr_Occurred())
return -1;
*p = x;
get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)
{
unsigned PY_LONG_LONG x;
- if (!PyInt_Check(v)) {
+ if (!PyLong_Check(v)) {
PyErr_Format(PyExc_TypeError,
"int expected instead of %s instance",
v->ob_type->tp_name);
return -1;
}
- x = PyInt_AsUnsignedLongLongMask(v);
+ x = PyLong_AsUnsignedLongLongMask(v);
if (x == -1 && PyErr_Occurred())
return -1;
*p = x;
{
signed char val = *(signed char *)ptr;
GET_BITFIELD(val, size);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
{
unsigned char val = *(unsigned char *)ptr;
GET_BITFIELD(val, size);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
short val;
memcpy(&val, ptr, sizeof(val));
GET_BITFIELD(val, size);
- return PyInt_FromLong((long)val);
+ return PyLong_FromLong((long)val);
}
static PyObject *
memcpy(&val, ptr, sizeof(val));
val = SWAP_2(val);
GET_BITFIELD(val, size);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
unsigned short val;
memcpy(&val, ptr, sizeof(val));
GET_BITFIELD(val, size);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
memcpy(&val, ptr, sizeof(val));
val = SWAP_2(val);
GET_BITFIELD(val, size);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
int val;
memcpy(&val, ptr, sizeof(val));
GET_BITFIELD(val, size);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
memcpy(&val, ptr, sizeof(val));
val = SWAP_INT(val);
GET_BITFIELD(val, size);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
#ifdef MS_WIN32
long val;
memcpy(&val, ptr, sizeof(val));
GET_BITFIELD(val, size);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
memcpy(&val, ptr, sizeof(val));
val = SWAP_LONG(val);
GET_BITFIELD(val, size);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
*(char *)ptr = PyBytes_AS_STRING(value)[0];
_RET(value);
}
- if (PyInt_Check(value))
+ if (PyLong_Check(value))
{
- long longval = PyInt_AS_LONG(value);
+ long longval = PyLong_AS_LONG(value);
if (longval < 0 || longval >= 256)
goto error;
*(char *)ptr = (char)longval;
return NULL;
*(char **)ptr = PyString_AS_STRING(str);
return str;
- } else if (PyInt_Check(value)) {
+ } else if (PyLong_Check(value)) {
#if SIZEOF_VOID_P == SIZEOF_LONG_LONG
- *(char **)ptr = (char *)PyInt_AsUnsignedLongLongMask(value);
+ *(char **)ptr = (char *)PyLong_AsUnsignedLongLongMask(value);
#else
- *(char **)ptr = (char *)PyInt_AsUnsignedLongMask(value);
+ *(char **)ptr = (char *)PyLong_AsUnsignedLongMask(value);
#endif
_RET(value);
}
Py_INCREF(value);
return value;
}
- if (PyInt_Check(value) || PyLong_Check(value)) {
+ if (PyLong_Check(value) || PyLong_Check(value)) {
#if SIZEOF_VOID_P == SIZEOF_LONG_LONG
- *(wchar_t **)ptr = (wchar_t *)PyInt_AsUnsignedLongLongMask(value);
+ *(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongLongMask(value);
#else
- *(wchar_t **)ptr = (wchar_t *)PyInt_AsUnsignedLongMask(value);
+ *(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongMask(value);
#endif
Py_INCREF(Py_None);
return Py_None;
_RET(value);
}
- if (!PyInt_Check(value) && !PyLong_Check(value)) {
+ if (!PyLong_Check(value) && !PyLong_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"cannot be converted to pointer");
return NULL;
}
#if SIZEOF_VOID_P <= SIZEOF_LONG
- v = (void *)PyInt_AsUnsignedLongMask(value);
+ v = (void *)PyLong_AsUnsignedLongMask(value);
#else
#ifndef HAVE_LONG_LONG
# error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long"
#elif SIZEOF_LONG_LONG < SIZEOF_VOID_P
# error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)"
#endif
- v = (void *)PyInt_AsUnsignedLongLongMask(value);
+ v = (void *)PyLong_AsUnsignedLongLongMask(value);
#endif
if (PyErr_Occurred())
isPacked = PyObject_GetAttrString(type, "_pack_");
if (isPacked) {
- pack = PyInt_AsLong(isPacked);
+ pack = PyLong_AsLong(isPacked);
if (pack < 0 || PyErr_Occurred()) {
Py_XDECREF(isPacked);
PyErr_SetString(PyExc_ValueError,
PyCurses_ConvertToChtype(PyObject *obj, chtype *ch)
{
if (PyInt_CheckExact(obj)) {
- *ch = (chtype) PyInt_AsLong(obj);
+ *ch = (chtype) PyLong_AsLong(obj);
} else if(PyString_Check(obj)
&& (PyString_Size(obj) == 1)) {
*ch = (chtype) *PyString_AsString(obj);
if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))
return NULL;
- return PyInt_FromLong( wenclose(self->win,y,x) );
+ return PyLong_FromLong( wenclose(self->win,y,x) );
}
#endif
static PyObject *
PyCursesWindow_GetBkgd(PyCursesWindowObject *self)
{
- return PyInt_FromLong((long) getbkgd(self->win));
+ return PyLong_FromLong((long) getbkgd(self->win));
}
static PyObject *
PyErr_SetString(PyExc_TypeError, "getch requires 0 or 2 arguments");
return NULL;
}
- return PyInt_FromLong((long)rtn);
+ return PyLong_FromLong((long)rtn);
}
static PyObject *
PyErr_SetString(PyExc_TypeError, "inch requires 0 or 2 arguments");
return NULL;
}
- return PyInt_FromLong((long) rtn);
+ return PyLong_FromLong((long) rtn);
}
static PyObject *
PyCursesInitialisedColor
if (!PyArg_ParseTuple(args, "i:color_pair", &n)) return NULL;
- return PyInt_FromLong((long) (n << 8));
+ return PyLong_FromLong((long) (n << 8));
}
static PyObject *
erg = curs_set(vis);
if (erg == ERR) return PyCursesCheckERR(erg, "curs_set");
- return PyInt_FromLong((long) erg);
+ return PyLong_FromLong((long) erg);
}
static PyObject *
where they're not defined until you've called initscr() */
#define SetDictInt(string,ch) \
do { \
- PyObject *o = PyInt_FromLong((long) (ch)); \
+ PyObject *o = PyLong_FromLong((long) (ch)); \
if (o && PyDict_SetItemString(ModDict, string, o) == 0) { \
Py_DECREF(o); \
} \
return NULL;
}
- return PyInt_FromLong((long) ((n & A_COLOR) >> 8));
+ return PyLong_FromLong((long) ((n & A_COLOR) >> 8));
}
static PyObject *
if (!m)
return 0;
- o = PyInt_FromLong(LINES);
+ o = PyLong_FromLong(LINES);
if (!o) {
Py_DECREF(m);
return 0;
return 0;
}
Py_DECREF(o);
- o = PyInt_FromLong(COLS);
+ o = PyLong_FromLong(COLS);
if (!o) {
Py_DECREF(m);
return 0;
code = start_color();
if (code != ERR) {
initialisedcolors = TRUE;
- c = PyInt_FromLong((long) COLORS);
+ c = PyLong_FromLong((long) COLORS);
PyDict_SetItemString(ModDict, "COLORS", c);
Py_DECREF(c);
- cp = PyInt_FromLong((long) COLOR_PAIRS);
+ cp = PyLong_FromLong((long) COLOR_PAIRS);
PyDict_SetItemString(ModDict, "COLOR_PAIRS", cp);
Py_DECREF(cp);
Py_INCREF(Py_None);
if (!PyArg_ParseTuple(args, "z", &capname))
return NULL;
- return PyInt_FromLong( (long) tigetflag( capname ) );
+ return PyLong_FromLong( (long) tigetflag( capname ) );
}
static PyObject *
if (!PyArg_ParseTuple(args, "z", &capname))
return NULL;
- return PyInt_FromLong( (long) tigetnum( capname ) );
+ return PyLong_FromLong( (long) tigetnum( capname ) );
}
static PyObject *
}
/* add object to memo dictionary (so deepcopy won't visit it again) */
- id = PyInt_FromLong((Py_uintptr_t) self);
+ id = PyLong_FromLong((Py_uintptr_t) self);
i = PyDict_SetItem(memo, id, (PyObject*) element);
{
if (self->fd < 0)
return err_closed();
- return PyInt_FromLong((long) self->fd);
+ return PyLong_FromLong((long) self->fd);
}
static PyObject *
return NULL;
}
- return PyInt_FromSsize_t(n);
+ return PyLong_FromSsize_t(n);
}
#define DEFAULT_BUFFER_SIZE (8*1024)
return NULL;
}
- return PyInt_FromSsize_t(n);
+ return PyLong_FromSsize_t(n);
}
/* XXX Windows support below is likely incomplete */
return NULL;
}
#if !defined(HAVE_LARGEFILE_SUPPORT)
- pos = PyInt_AsLong(posobj);
+ pos = PyLong_AsLong(posobj);
#else
pos = PyLong_Check(posobj) ?
- PyLong_AsLongLong(posobj) : PyInt_AsLong(posobj);
+ PyLong_AsLongLong(posobj) : PyLong_AsLong(posobj);
#endif
if (PyErr_Occurred())
return NULL;
return PyErr_SetFromErrno(PyExc_IOError);
#if !defined(HAVE_LARGEFILE_SUPPORT)
- return PyInt_FromLong(res);
+ return PyLong_FromLong(res);
#else
return PyLong_FromLongLong(res);
#endif
}
#if !defined(HAVE_LARGEFILE_SUPPORT)
- pos = PyInt_AsLong(posobj);
+ pos = PyLong_AsLong(posobj);
#else
pos = PyLong_Check(posobj) ?
- PyLong_AsLongLong(posobj) : PyInt_AsLong(posobj);
+ PyLong_AsLongLong(posobj) : PyLong_AsLong(posobj);
#endif
if (PyErr_Occurred()) {
Py_DECREF(posobj);
static PyObject *
EVP_get_block_size(EVPobject *self, void *closure)
{
- return PyInt_FromLong(EVP_MD_CTX_block_size(&((EVPobject *)self)->ctx));
+ return PyLong_FromLong(EVP_MD_CTX_block_size(&((EVPobject *)self)->ctx));
}
static PyObject *
EVP_get_digest_size(EVPobject *self, void *closure)
{
- return PyInt_FromLong(EVP_MD_CTX_size(&((EVPobject *)self)->ctx));
+ return PyLong_FromLong(EVP_MD_CTX_size(&((EVPobject *)self)->ctx));
}
static PyMemberDef EVP_members[] = {
i = -1;
do {
i++;
- val = PyInt_FromLong(s[i]);
+ val = PyLong_FromLong(s[i]);
if (!val)
break;
if (PyList_SetItem(result, i, val)) {
Py_XDECREF(x)
#define RESULT_INT(i)\
- x = PyInt_FromLong(l->i);\
+ x = PyLong_FromLong(l->i);\
if (!x) goto failed;\
PyDict_SetItemString(result, #i, x);\
Py_XDECREF(x)
if (!PyArg_ParseTuple(args, "ss:strcoll", &s1, &s2))
return NULL;
- return PyInt_FromLong(strcoll(s1, s2));
+ return PyLong_FromLong(strcoll(s1, s2));
#else
PyObject *os1, *os2, *result = NULL;
wchar_t *ws1 = NULL, *ws2 = NULL;
goto done;
ws2[len2 - 1] = 0;
/* Collate the strings. */
- result = PyInt_FromLong(wcscoll(ws1, ws2));
+ result = PyLong_FromLong(wcscoll(ws1, ws2));
done:
/* Deallocate everything. */
if (ws1) PyMem_FREE(ws1);
d = PyModule_GetDict(m);
- x = PyInt_FromLong(LC_CTYPE);
+ x = PyLong_FromLong(LC_CTYPE);
PyDict_SetItemString(d, "LC_CTYPE", x);
Py_XDECREF(x);
- x = PyInt_FromLong(LC_TIME);
+ x = PyLong_FromLong(LC_TIME);
PyDict_SetItemString(d, "LC_TIME", x);
Py_XDECREF(x);
- x = PyInt_FromLong(LC_COLLATE);
+ x = PyLong_FromLong(LC_COLLATE);
PyDict_SetItemString(d, "LC_COLLATE", x);
Py_XDECREF(x);
- x = PyInt_FromLong(LC_MONETARY);
+ x = PyLong_FromLong(LC_MONETARY);
PyDict_SetItemString(d, "LC_MONETARY", x);
Py_XDECREF(x);
#ifdef LC_MESSAGES
- x = PyInt_FromLong(LC_MESSAGES);
+ x = PyLong_FromLong(LC_MESSAGES);
PyDict_SetItemString(d, "LC_MESSAGES", x);
Py_XDECREF(x);
#endif /* LC_MESSAGES */
- x = PyInt_FromLong(LC_NUMERIC);
+ x = PyLong_FromLong(LC_NUMERIC);
PyDict_SetItemString(d, "LC_NUMERIC", x);
Py_XDECREF(x);
- x = PyInt_FromLong(LC_ALL);
+ x = PyLong_FromLong(LC_ALL);
PyDict_SetItemString(d, "LC_ALL", x);
Py_XDECREF(x);
- x = PyInt_FromLong(CHAR_MAX);
+ x = PyLong_FromLong(CHAR_MAX);
PyDict_SetItemString(d, "CHAR_MAX", x);
Py_XDECREF(x);
masklower = PyLong_FromUnsignedLong(0xffffffffU);
if (masklower == NULL)
goto Done;
- thirtytwo = PyInt_FromLong(32L);
+ thirtytwo = PyLong_FromLong(32L);
if (thirtytwo == NULL)
goto Done;
while ((err=PyObject_IsTrue(n))) {
if (state == NULL)
return NULL;
for (i=0; i<N ; i++) {
- element = PyInt_FromLong((long)(self->state[i]));
+ element = PyLong_FromLong((long)(self->state[i]));
if (element == NULL)
goto Fail;
PyTuple_SET_ITEM(state, i, element);
}
- element = PyInt_FromLong((long)(self->index));
+ element = PyLong_FromLong((long)(self->index));
if (element == NULL)
goto Fail;
PyTuple_SET_ITEM(state, i, element);
}
for (i=0; i<N ; i++) {
- element = PyInt_AsLong(PyTuple_GET_ITEM(state, i));
+ element = PyLong_AsLong(PyTuple_GET_ITEM(state, i));
if (element == -1 && PyErr_Occurred())
return NULL;
self->state[i] = (unsigned long)element;
}
- element = PyInt_AsLong(PyTuple_GET_ITEM(state, i));
+ element = PyLong_AsLong(PyTuple_GET_ITEM(state, i));
if (element == -1 && PyErr_Occurred())
return NULL;
self->index = (int)element;
mt = self->state;
for (i = N-1; i > 1; i--) {
- iobj = PyInt_FromLong(i);
+ iobj = PyLong_FromLong(i);
if (iobj == NULL)
return NULL;
remobj = PyNumber_Remainder(n, iobj);
Py_DECREF(iobj);
if (remobj == NULL)
return NULL;
- j = PyInt_AsLong(remobj);
+ j = PyLong_AsLong(remobj);
Py_DECREF(remobj);
if (j == -1L && PyErr_Occurred())
return NULL;
sqlite3_result_null(context);
} else if (py_val == Py_None) {
sqlite3_result_null(context);
- } else if (PyInt_Check(py_val)) {
- longval = PyInt_AsLong(py_val);
+ } else if (PyLong_Check(py_val)) {
+ longval = PyLong_AsLong(py_val);
sqlite3_result_int64(context, (PY_LONG_LONG)longval);
} else if (PyFloat_Check(py_val)) {
sqlite3_result_double(context, PyFloat_AsDouble(py_val));
switch (sqlite3_value_type(argv[i])) {
case SQLITE_INTEGER:
val_int = sqlite3_value_int64(cur_value);
- cur_py_value = PyInt_FromLong((long)val_int);
+ cur_py_value = PyLong_FromLong((long)val_int);
break;
case SQLITE_FLOAT:
cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));
rc = SQLITE_DENY;
} else {
- if (PyInt_Check(ret)) {
- rc = (int)PyInt_AsLong(ret);
+ if (PyLong_Check(ret)) {
+ rc = (int)PyLong_AsLong(ret);
} else {
rc = SQLITE_DENY;
}
goto finally;
}
- result = PyInt_AsLong(retval);
+ result = PyLong_AsLong(retval);
if (PyErr_Occurred()) {
result = 0;
}
#include "util.h"
#include "sqlitecompat.h"
-/* used to decide wether to call PyInt_FromLong or PyLong_FromLongLong */
+/* used to decide wether to call PyLong_FromLong or PyLong_FromLongLong */
#ifndef INT32_MIN
#define INT32_MIN (-2147483647 - 1)
#endif
self->arraysize = 1;
- self->rowcount = PyInt_FromLong(-1L);
+ self->rowcount = PyLong_FromLong(-1L);
if (!self->rowcount) {
return -1;
}
if (intval < INT32_MIN || intval > INT32_MAX) {
converted = PyLong_FromLongLong(intval);
} else {
- converted = PyInt_FromLong((long)intval);
+ converted = PyLong_FromLong((long)intval);
}
} else if (coltype == SQLITE_FLOAT) {
converted = PyFloat_FromDouble(sqlite3_column_double(self->statement->st, i));
self->description = Py_None;
Py_DECREF(self->rowcount);
- self->rowcount = PyInt_FromLong(-1L);
+ self->rowcount = PyLong_FromLong(-1L);
if (!self->rowcount) {
goto error;
}
rowcount += (long)sqlite3_changes(self->connection->db);
Py_END_ALLOW_THREADS
Py_DECREF(self->rowcount);
- self->rowcount = PyInt_FromLong(rowcount);
+ self->rowcount = PyLong_FromLong(rowcount);
}
Py_DECREF(self->lastrowid);
Py_BEGIN_ALLOW_THREADS
lastrowid = sqlite3_last_insert_rowid(self->connection->db);
Py_END_ALLOW_THREADS
- self->lastrowid = PyInt_FromLong((long)lastrowid);
+ self->lastrowid = PyLong_FromLong((long)lastrowid);
} else {
Py_INCREF(Py_None);
self->lastrowid = Py_None;
/* Set integer constants */
for (i = 0; _int_constants[i].constant_name != 0; i++) {
- tmp_obj = PyInt_FromLong(_int_constants[i].constant_value);
+ tmp_obj = PyLong_FromLong(_int_constants[i].constant_value);
if (!tmp_obj) {
goto error;
}
/* Default value */
return 0;
- if (PyInt_Check(index))
- return PyInt_AsSsize_t(index);
+ if (PyLong_Check(index))
+ return PyLong_AsSsize_t(index);
i = -1;
index = PyObject_GetItem(self->pattern->groupindex, index);
if (index) {
if (PyLong_Check(index))
- i = PyInt_AsSsize_t(index);
+ i = PyLong_AsSsize_t(index);
Py_DECREF(index);
} else
PyErr_Clear();
if (!pair)
return NULL;
- item = PyInt_FromSsize_t(i1);
+ item = PyLong_FromSsize_t(i1);
if (!item)
goto error;
PyTuple_SET_ITEM(pair, 0, item);
- item = PyInt_FromSsize_t(i2);
+ item = PyLong_FromSsize_t(i2);
if (!item)
goto error;
PyTuple_SET_ITEM(pair, 1, item);
return;
d = PyModule_GetDict(m);
- x = PyInt_FromLong(SRE_MAGIC);
+ x = PyLong_FromLong(SRE_MAGIC);
if (x) {
PyDict_SetItemString(d, "MAGIC", x);
Py_DECREF(x);
}
- x = PyInt_FromLong(sizeof(SRE_CODE));
+ x = PyLong_FromLong(sizeof(SRE_CODE));
if (x) {
PyDict_SetItemString(d, "CODESIZE", x);
Py_DECREF(x);
}
Py_DECREF(issuer);
- version = PyInt_FromLong(X509_get_version(certificate) + 1);
+ version = PyLong_FromLong(X509_get_version(certificate) + 1);
if (PyDict_SetItemString(retval, "version", version) < 0) {
Py_DECREF(version);
goto fail0;
goto fail0;
PyTuple_SET_ITEM(retval, 1, v);
}
- v = PyInt_FromLong(SSL_CIPHER_get_bits(current, NULL));
+ v = PyLong_FromLong(SSL_CIPHER_get_bits(current, NULL));
if (v == NULL)
goto fail0;
PyTuple_SET_ITEM(retval, 2, v);
}
} while (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE);
if (len > 0)
- return PyInt_FromLong(len);
+ return PyLong_FromLong(len);
else
return PySSL_SetError(self, len, __FILE__, __LINE__);
}
if (count < 0)
return PySSL_SetError(self, count, __FILE__, __LINE__);
else
- return PyInt_FromLong(count);
+ return PyLong_FromLong(count);
}
PyDoc_STRVAR(PySSL_SSLpending_doc,
if ((buf == NULL) || (buf == Py_None)) {
if (!(buf = PyBytes_FromStringAndSize((char *) 0, len)))
return NULL;
- } else if (PyInt_Check(buf)) {
- len = PyInt_AS_LONG(buf);
+ } else if (PyLong_Check(buf)) {
+ len = PyLong_AS_LONG(buf);
if (!(buf = PyBytes_FromStringAndSize((char *) 0, len)))
return NULL;
} else {
Py_DECREF(buf);
return res;
} else {
- return PyInt_FromLong(count);
+ return PyLong_FromLong(count);
}
}
static PyObject *
PySSL_RAND_status(PyObject *self)
{
- return PyInt_FromLong(RAND_status());
+ return PyLong_FromLong(RAND_status());
}
PyDoc_STRVAR(PySSL_RAND_status_doc,
"enough data to seed the PRNG");
return NULL;
}
- return PyInt_FromLong(bytes);
+ return PyLong_FromLong(bytes);
}
PyDoc_STRVAR(PySSL_RAND_egd_doc,
static int
get_long(PyObject *v, long *p)
{
- long x = PyInt_AsLong(v);
+ long x = PyLong_AsLong(v);
if (x == -1 && PyErr_Occurred()) {
#ifdef PY_STRUCT_FLOAT_COERCE
if (PyFloat_Check(v)) {
static PyObject *
nu_byte(const char *p, const formatdef *f)
{
- return PyInt_FromLong((long) *(signed char *)p);
+ return PyLong_FromLong((long) *(signed char *)p);
}
static PyObject *
nu_ubyte(const char *p, const formatdef *f)
{
- return PyInt_FromLong((long) *(unsigned char *)p);
+ return PyLong_FromLong((long) *(unsigned char *)p);
}
static PyObject *
{
short x;
memcpy((char *)&x, p, sizeof x);
- return PyInt_FromLong((long)x);
+ return PyLong_FromLong((long)x);
}
static PyObject *
{
unsigned short x;
memcpy((char *)&x, p, sizeof x);
- return PyInt_FromLong((long)x);
+ return PyLong_FromLong((long)x);
}
static PyObject *
{
int x;
memcpy((char *)&x, p, sizeof x);
- return PyInt_FromLong((long)x);
+ return PyLong_FromLong((long)x);
}
static PyObject *
unsigned int x;
memcpy((char *)&x, p, sizeof x);
#if (SIZEOF_LONG > SIZEOF_INT)
- return PyInt_FromLong((long)x);
+ return PyLong_FromLong((long)x);
#else
if (x <= ((unsigned int)LONG_MAX))
- return PyInt_FromLong((long)x);
+ return PyLong_FromLong((long)x);
return PyLong_FromUnsignedLong((unsigned long)x);
#endif
}
{
long x;
memcpy((char *)&x, p, sizeof x);
- return PyInt_FromLong(x);
+ return PyLong_FromLong(x);
}
static PyObject *
unsigned long x;
memcpy((char *)&x, p, sizeof x);
if (x <= LONG_MAX)
- return PyInt_FromLong((long)x);
+ return PyLong_FromLong((long)x);
return PyLong_FromUnsignedLong(x);
}
PY_LONG_LONG x;
memcpy((char *)&x, p, sizeof x);
if (x >= LONG_MIN && x <= LONG_MAX)
- return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
+ return PyLong_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
return PyLong_FromLongLong(x);
}
unsigned PY_LONG_LONG x;
memcpy((char *)&x, p, sizeof x);
if (x <= LONG_MAX)
- return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
+ return PyLong_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
return PyLong_FromUnsignedLongLong(x);
}
/* Extend the sign bit. */
if (SIZEOF_LONG > f->size)
x |= -(x & (1L << ((8 * f->size) - 1)));
- return PyInt_FromLong(x);
+ return PyLong_FromLong(x);
}
static PyObject *
x = (x<<8) | *bytes++;
} while (--i > 0);
if (x <= LONG_MAX)
- return PyInt_FromLong((long)x);
+ return PyLong_FromLong((long)x);
return PyLong_FromUnsignedLong(x);
}
if (SIZEOF_LONG_LONG > f->size)
x |= -(x & ((PY_LONG_LONG)1 << ((8 * f->size) - 1)));
if (x >= LONG_MIN && x <= LONG_MAX)
- return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
+ return PyLong_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
return PyLong_FromLongLong(x);
#else
return _PyLong_FromByteArray((const unsigned char *)p,
x = (x<<8) | *bytes++;
} while (--i > 0);
if (x <= LONG_MAX)
- return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
+ return PyLong_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
return PyLong_FromUnsignedLongLong(x);
#else
return _PyLong_FromByteArray((const unsigned char *)p,
/* Extend the sign bit. */
if (SIZEOF_LONG > f->size)
x |= -(x & (1L << ((8 * f->size) - 1)));
- return PyInt_FromLong(x);
+ return PyLong_FromLong(x);
}
static PyObject *
x = (x<<8) | bytes[--i];
} while (i > 0);
if (x <= LONG_MAX)
- return PyInt_FromLong((long)x);
+ return PyLong_FromLong((long)x);
return PyLong_FromUnsignedLong((long)x);
}
if (SIZEOF_LONG_LONG > f->size)
x |= -(x & ((PY_LONG_LONG)1 << ((8 * f->size) - 1)));
if (x >= LONG_MIN && x <= LONG_MAX)
- return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
+ return PyLong_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
return PyLong_FromLongLong(x);
#else
return _PyLong_FromByteArray((const unsigned char *)p,
x = (x<<8) | bytes[--i];
} while (i > 0);
if (x <= LONG_MAX)
- return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
+ return PyLong_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
return PyLong_FromUnsignedLongLong(x);
#else
return _PyLong_FromByteArray((const unsigned char *)p,
assert( buffer_len >= 0 );
/* Extract the offset from the first argument */
- offset = PyInt_AsSsize_t(PyTuple_GET_ITEM(args, 1));
+ offset = PyLong_AsSsize_t(PyTuple_GET_ITEM(args, 1));
/* Support negative offsets. */
if (offset < 0)
static PyObject *
s_get_size(PyStructObject *self, void *unused)
{
- return PyInt_FromSsize_t(self->s_size);
+ return PyLong_FromSsize_t(self->s_size);
}
/* List of functions */
#ifdef PY_STRUCT_OVERFLOW_MASKING
if (pyint_zero == NULL) {
- pyint_zero = PyInt_FromLong(0);
+ pyint_zero = PyLong_FromLong(0);
if (pyint_zero == NULL)
return;
}
return (PyObject*)NULL;
/* list = range(NLIST) */
for (i = 0; i < NLIST; ++i) {
- PyObject* anint = PyInt_FromLong(i);
+ PyObject* anint = PyLong_FromLong(i);
if (anint == (PyObject*)NULL) {
Py_DECREF(list);
return (PyObject*)NULL;
/* Check that list == range(29, -1, -1) now */
for (i = 0; i < NLIST; ++i) {
PyObject* anint = PyList_GET_ITEM(list, i);
- if (PyInt_AS_LONG(anint) != NLIST-1-i) {
+ if (PyLong_AS_LONG(anint) != NLIST-1-i) {
PyErr_SetString(TestError,
"test_list_api: reverse screwed up");
Py_DECREF(list);
return -1;
for (i = 0; i < count; i++) {
- v = PyInt_FromLong(i);
+ v = PyLong_FromLong(i);
PyDict_SetItem(dict, v, v);
Py_DECREF(v);
}
PyObject *o;
iterations++;
- i = PyInt_AS_LONG(v) + 1;
- o = PyInt_FromLong(i);
+ i = PyLong_AS_LONG(v) + 1;
+ o = PyLong_FromLong(i);
if (o == NULL)
return -1;
if (PyDict_SetItem(dict, k, o) < 0) {
"L code returned wrong value for long 42");
Py_DECREF(num);
- num = PyInt_FromLong(42);
+ num = PyLong_FromLong(42);
if (num == NULL)
return NULL;
#endif
/* This function not only tests the 'k' getargs code, but also the
- PyInt_AsUnsignedLongMask() and PyInt_AsUnsignedLongMask() functions. */
+ PyLong_AsUnsignedLongMask() and PyLong_AsUnsignedLongMask() functions. */
static PyObject *
test_k_code(PyObject *self)
{
if (num == NULL)
return NULL;
- value = PyInt_AsUnsignedLongMask(num);
+ value = PyLong_AsUnsignedLongMask(num);
if (value != ULONG_MAX)
return raiseTestError("test_k_code",
- "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
+ "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
PyTuple_SET_ITEM(tuple, 0, num);
if (num == NULL)
return NULL;
- value = PyInt_AsUnsignedLongMask(num);
+ value = PyLong_AsUnsignedLongMask(num);
if (value != (unsigned long)-0x42)
return raiseTestError("test_k_code",
- "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
+ "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
PyTuple_SET_ITEM(tuple, 0, num);
if (exc_args == NULL)
return NULL;
for (i = 0; i < num_args; ++i) {
- v = PyInt_FromLong(i);
+ v = PyLong_FromLong(i);
if (v == NULL) {
Py_DECREF(exc_args);
return NULL;
gettimeofday(&start, NULL);
for(k=0; k < 20000; k++)
for(i=0; i < 1000; i++) {
- single = PyInt_FromLong(i);
+ single = PyLong_FromLong(i);
Py_DECREF(single);
}
gettimeofday(&stop, NULL);
gettimeofday(&start, NULL);
for(k=0; k < 20000; k++)
for(i=0; i < 1000; i++) {
- single = PyInt_FromLong(i+1000000);
+ single = PyLong_FromLong(i+1000000);
Py_DECREF(single);
}
gettimeofday(&stop, NULL);
gettimeofday(&start, NULL);
for(k=0; k < 20000; k++) {
for(i=0; i < 1000; i++) {
- multiple[i] = PyInt_FromLong(i+1000000);
+ multiple[i] = PyLong_FromLong(i+1000000);
}
for(i=0; i < 1000; i++) {
Py_DECREF(multiple[i]);
gettimeofday(&start, NULL);
for(k=0; k < 20; k++) {
for(i=0; i < 1000000; i++) {
- multiple[i] = PyInt_FromLong(i+1000000);
+ multiple[i] = PyLong_FromLong(i+1000000);
}
for(i=0; i < 1000000; i++) {
Py_DECREF(multiple[i]);
gettimeofday(&start, NULL);
for(k=0; k < 10; k++) {
for(i=0; i < 1000000; i++) {
- multiple[i] = PyInt_FromLong(i+1000);
+ multiple[i] = PyLong_FromLong(i+1000);
}
for(i=0; i < 1000000; i++) {
Py_DECREF(multiple[i]);
print_delta(5, &start, &stop);
/* Test 6: Perform small int addition */
- op1 = PyInt_FromLong(1);
+ op1 = PyLong_FromLong(1);
gettimeofday(&start, NULL);
for(i=0; i < 10000000; i++) {
result = PyNumber_Add(op1, op1);
print_delta(6, &start, &stop);
/* Test 7: Perform medium int addition */
- op1 = PyInt_FromLong(1000);
+ op1 = PyLong_FromLong(1000);
gettimeofday(&start, NULL);
for(i=0; i < 10000000; i++) {
result = PyNumber_Add(op1, op1);
Py_INCREF(&test_structmembersType);
PyModule_AddObject(m, "test_structmembersType", (PyObject *)&test_structmembersType);
- PyModule_AddObject(m, "CHAR_MAX", PyInt_FromLong(CHAR_MAX));
- PyModule_AddObject(m, "CHAR_MIN", PyInt_FromLong(CHAR_MIN));
- PyModule_AddObject(m, "UCHAR_MAX", PyInt_FromLong(UCHAR_MAX));
- PyModule_AddObject(m, "SHRT_MAX", PyInt_FromLong(SHRT_MAX));
- PyModule_AddObject(m, "SHRT_MIN", PyInt_FromLong(SHRT_MIN));
- PyModule_AddObject(m, "USHRT_MAX", PyInt_FromLong(USHRT_MAX));
+ PyModule_AddObject(m, "CHAR_MAX", PyLong_FromLong(CHAR_MAX));
+ PyModule_AddObject(m, "CHAR_MIN", PyLong_FromLong(CHAR_MIN));
+ PyModule_AddObject(m, "UCHAR_MAX", PyLong_FromLong(UCHAR_MAX));
+ PyModule_AddObject(m, "SHRT_MAX", PyLong_FromLong(SHRT_MAX));
+ PyModule_AddObject(m, "SHRT_MIN", PyLong_FromLong(SHRT_MIN));
+ PyModule_AddObject(m, "USHRT_MAX", PyLong_FromLong(USHRT_MAX));
PyModule_AddObject(m, "INT_MAX", PyLong_FromLong(INT_MAX));
PyModule_AddObject(m, "INT_MIN", PyLong_FromLong(INT_MIN));
PyModule_AddObject(m, "UINT_MAX", PyLong_FromUnsignedLong(UINT_MAX));
- PyModule_AddObject(m, "LONG_MAX", PyInt_FromLong(LONG_MAX));
- PyModule_AddObject(m, "LONG_MIN", PyInt_FromLong(LONG_MIN));
+ PyModule_AddObject(m, "LONG_MAX", PyLong_FromLong(LONG_MAX));
+ PyModule_AddObject(m, "LONG_MIN", PyLong_FromLong(LONG_MIN));
PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX));
PyModule_AddObject(m, "FLT_MAX", PyFloat_FromDouble(FLT_MAX));
PyModule_AddObject(m, "FLT_MIN", PyFloat_FromDouble(FLT_MIN));
PyModule_AddObject(m, "LLONG_MAX", PyLong_FromLongLong(PY_LLONG_MAX));
PyModule_AddObject(m, "LLONG_MIN", PyLong_FromLongLong(PY_LLONG_MIN));
PyModule_AddObject(m, "ULLONG_MAX", PyLong_FromUnsignedLongLong(PY_ULLONG_MAX));
- PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyInt_FromSsize_t(PY_SSIZE_T_MAX));
- PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyInt_FromSsize_t(PY_SSIZE_T_MIN));
+ PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyLong_FromSsize_t(PY_SSIZE_T_MAX));
+ PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyLong_FromSsize_t(PY_SSIZE_T_MIN));
TestError = PyErr_NewException("_testcapi.error", NULL, NULL);
Py_INCREF(TestError);
#ifndef PyBool_Check
#define PyBool_Check(o) 0
-#define PyBool_FromLong PyInt_FromLong
+#define PyBool_FromLong PyLong_FromLong
#endif
/* Starting with Tcl 8.4, many APIs offer const-correctness. Unfortunately,
else if (PyBool_Check(value))
return Tcl_NewBooleanObj(PyObject_IsTrue(value));
else if (PyInt_CheckExact(value))
- return Tcl_NewLongObj(PyInt_AS_LONG(value));
+ return Tcl_NewLongObj(PyLong_AS_LONG(value));
else if (PyFloat_Check(value))
return Tcl_NewDoubleObj(PyFloat_AS_DOUBLE(value));
else if (PyTuple_Check(value)) {
}
if (value->typePtr == app->IntType) {
- return PyInt_FromLong(value->internalRep.longValue);
+ return PyLong_FromLong(value->internalRep.longValue);
}
if (value->typePtr == app->ListType) {
if (PyTuple_Size(args) == 1) {
PyObject* o = PyTuple_GetItem(args, 0);
- if (PyInt_Check(o)) {
+ if (PyLong_Check(o)) {
Py_INCREF(o);
return o;
}
if (PyTuple_Size(args) == 1) {
PyObject *o = PyTuple_GetItem(args, 0);
- if (PyInt_Check(o)) {
+ if (PyLong_Check(o)) {
Py_INCREF(o);
return o;
}
if (!PyArg_ParseTuple(args, ":interpaddr"))
return NULL;
- return PyInt_FromLong((long)Tkapp_Interp(self));
+ return PyLong_FromLong((long)Tkapp_Interp(self));
}
static PyObject *
static PyObject *
Tkinter_getbusywaitinterval(PyObject *self, PyObject *args)
{
- return PyInt_FromLong(Tkinter_busywaitinterval);
+ return PyLong_FromLong(Tkinter_busywaitinterval);
}
static char getbusywaitinterval_doc[] =
static void
ins_long(PyObject *d, char *name, long val)
{
- PyObject *v = PyInt_FromLong(val);
+ PyObject *v = PyLong_FromLong(val);
if (v) {
PyDict_SetItemString(d, name, v);
Py_DECREF(v);
if (PyType_SUPPORTS_WEAKREFS(Py_Type(object))) {
PyWeakReference **list = GET_WEAKREFS_LISTPTR(object);
- result = PyInt_FromSsize_t(_PyWeakref_GetWeakrefCount(*list));
+ result = PyLong_FromSsize_t(_PyWeakref_GetWeakrefCount(*list));
}
else
- result = PyInt_FromLong(0);
+ result = PyLong_FromLong(0);
return result;
}
long x = ((char *)ap->ob_item)[i];
if (x >= 128)
x -= 256;
- return PyInt_FromLong(x);
+ return PyLong_FromLong(x);
}
static int
BB_getitem(arrayobject *ap, Py_ssize_t i)
{
long x = ((unsigned char *)ap->ob_item)[i];
- return PyInt_FromLong(x);
+ return PyLong_FromLong(x);
}
static int
static PyObject *
h_getitem(arrayobject *ap, Py_ssize_t i)
{
- return PyInt_FromLong((long) ((short *)ap->ob_item)[i]);
+ return PyLong_FromLong((long) ((short *)ap->ob_item)[i]);
}
static PyObject *
HH_getitem(arrayobject *ap, Py_ssize_t i)
{
- return PyInt_FromLong((long) ((unsigned short *)ap->ob_item)[i]);
+ return PyLong_FromLong((long) ((unsigned short *)ap->ob_item)[i]);
}
static int
static PyObject *
i_getitem(arrayobject *ap, Py_ssize_t i)
{
- return PyInt_FromLong((long) ((int *)ap->ob_item)[i]);
+ return PyLong_FromLong((long) ((int *)ap->ob_item)[i]);
}
static int
static PyObject *
l_getitem(arrayobject *ap, Py_ssize_t i)
{
- return PyInt_FromLong(((long *)ap->ob_item)[i]);
+ return PyLong_FromLong(((long *)ap->ob_item)[i]);
}
static int
else if (cmp < 0)
return NULL;
}
- return PyInt_FromSsize_t(count);
+ return PyLong_FromSsize_t(count);
}
PyDoc_STRVAR(count_doc,
int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
Py_DECREF(selfi);
if (cmp > 0) {
- return PyInt_FromLong((long)i);
+ return PyLong_FromLong((long)i);
}
else if (cmp < 0)
return NULL;
return NULL;
PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
- PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(Py_Size(self))));
+ PyTuple_SET_ITEM(retval, 1, PyLong_FromLong((long)(Py_Size(self))));
return retval;
}
static PyObject *
array_get_itemsize(arrayobject *a, void *closure)
{
- return PyInt_FromLong((long)a->ob_descr->itemsize);
+ return PyLong_FromLong((long)a->ob_descr->itemsize);
}
static PyGetSetDef array_getsets [] = {
if ( size == 1 ) val = (int)*CHARP(cp, i);
else if ( size == 2 ) val = (int)*SHORTP(cp, i*2);
else if ( size == 4 ) val = (int)*LONGP(cp, i*4);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
if ( val < 0 ) val = (-val);
if ( val > max ) max = val;
}
- return PyInt_FromLong(max);
+ return PyLong_FromLong(max);
}
static PyObject *
val = 0;
else
val = (int)(avg / (double)(len/size));
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
val = 0;
else
val = (int)sqrt(sum_squares / (double)(len/size));
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static double _sum2(short *a, short *b, int len)
}
- return PyInt_FromLong(best_j);
+ return PyLong_FromLong(best_j);
}
static PyObject *
val = 0;
else
val = (int)(avg / (double)nextreme);
- return PyInt_FromLong(val);
+ return PyLong_FromLong(val);
}
static PyObject *
if ( diff != 0 )
prevdiff = diff;
}
- return PyInt_FromLong(max);
+ return PyLong_FromLong(max);
}
static PyObject *
if ( val != prevval ) ncross++;
prevval = val;
}
- return PyInt_FromLong(ncross);
+ return PyLong_FromLong(ncross);
}
static PyObject *
*/
result |= -(result & (1L << 31));
#endif
- return PyInt_FromLong(result);
+ return PyLong_FromLong(result);
}
if (!PyArg_ParseTuple(args, "O|i:seek", &offobj, &where))
return NULL;
#if !defined(HAVE_LARGEFILE_SUPPORT)
- offset = PyInt_AsLong(offobj);
+ offset = PyLong_AsLong(offobj);
#else
offset = PyLong_Check(offobj) ?
- PyLong_AsLongLong(offobj) : PyInt_AsLong(offobj);
+ PyLong_AsLongLong(offobj) : PyLong_AsLong(offobj);
#endif
if (PyErr_Occurred())
return NULL;
}
#if !defined(HAVE_LARGEFILE_SUPPORT)
- ret = PyInt_FromLong(self->pos);
+ ret = PyLong_FromLong(self->pos);
#else
ret = PyLong_FromLongLong(self->pos);
#endif
static PyObject *
BZ2File_get_closed(BZ2FileObject *self, void *closure)
{
- return PyInt_FromLong(self->mode == MODE_CLOSED);
+ return PyLong_FromLong(self->mode == MODE_CLOSED);
}
static PyGetSetDef BZ2File_getset[] = {
if (!IO__opencheck(self)) return NULL;
- return PyInt_FromSsize_t(self->pos);
+ return PyLong_FromSsize_t(self->pos);
}
PyDoc_STRVAR(IO_truncate__doc__,
}
PyTuple_SET_ITEM(v, 0, object);
- w = PyInt_FromSsize_t(len);
+ w = PyLong_FromSsize_t(len);
if (w == NULL) {
Py_DECREF(v);
return NULL;
if (!PyTuple_Check(retobj) || PyTuple_GET_SIZE(retobj) != 2 ||
!PyUnicode_Check((tobj = PyTuple_GET_ITEM(retobj, 0))) ||
- !PyInt_Check(PyTuple_GET_ITEM(retobj, 1))) {
+ !PyLong_Check(PyTuple_GET_ITEM(retobj, 1))) {
PyErr_SetString(PyExc_TypeError,
"encoding error handler must return "
"(unicode, int) tuple");
memcpy(buf->outbuf, PyString_AS_STRING(retstr), retstrsize);
buf->outbuf += retstrsize;
- newpos = PyInt_AsSsize_t(PyTuple_GET_ITEM(retobj, 1));
+ newpos = PyLong_AsSsize_t(PyTuple_GET_ITEM(retobj, 1));
if (newpos < 0 && !PyErr_Occurred())
newpos += (Py_ssize_t)(buf->inbuf_end - buf->inbuf_top);
if (newpos < 0 || buf->inbuf_top + newpos > buf->inbuf_end) {
if (!PyTuple_Check(retobj) || PyTuple_GET_SIZE(retobj) != 2 ||
!PyUnicode_Check((retuni = PyTuple_GET_ITEM(retobj, 0))) ||
- !PyInt_Check(PyTuple_GET_ITEM(retobj, 1))) {
+ !PyLong_Check(PyTuple_GET_ITEM(retobj, 1))) {
PyErr_SetString(PyExc_TypeError,
"decoding error handler must return "
"(unicode, int) tuple");
buf->outbuf += retunisize;
}
- newpos = PyInt_AsSsize_t(PyTuple_GET_ITEM(retobj, 1));
+ newpos = PyLong_AsSsize_t(PyTuple_GET_ITEM(retobj, 1));
if (newpos < 0 && !PyErr_Occurred())
newpos += (Py_ssize_t)(buf->inbuf_end - buf->inbuf_top);
if (newpos < 0 || buf->inbuf_top + newpos > buf->inbuf_end) {
if (sizeobj == Py_None || sizeobj == NULL)
size = -1;
- else if (PyInt_Check(sizeobj))
- size = PyInt_AsSsize_t(sizeobj);
+ else if (PyLong_Check(sizeobj))
+ size = PyLong_AsSsize_t(sizeobj);
else {
PyErr_SetString(PyExc_TypeError, "arg 1 must be an integer");
return NULL;
if (sizeobj == Py_None || sizeobj == NULL)
size = -1;
- else if (PyInt_Check(sizeobj))
- size = PyInt_AsSsize_t(sizeobj);
+ else if (PyLong_Check(sizeobj))
+ size = PyLong_AsSsize_t(sizeobj);
else {
PyErr_SetString(PyExc_TypeError, "arg 1 must be an integer");
return NULL;
if (sizehintobj == Py_None || sizehintobj == NULL)
sizehint = -1;
- else if (PyInt_Check(sizehintobj))
- sizehint = PyInt_AsSsize_t(sizehintobj);
+ else if (PyLong_Check(sizehintobj))
+ sizehint = PyLong_AsSsize_t(sizehintobj);
else {
PyErr_SetString(PyExc_TypeError, "arg 1 must be an integer");
return NULL;
long year;
PyObject *pyyear = PySequence_GetItem(timetuple, 0);
if (pyyear == NULL) return NULL;
- assert(PyInt_Check(pyyear));
- year = PyInt_AsLong(pyyear);
+ assert(PyLong_Check(pyyear));
+ year = PyLong_AsLong(pyyear);
Py_DECREF(pyyear);
if (year < 1900) {
PyErr_Format(PyExc_ValueError, "year=%ld is before "
PyObject *x3 = NULL;
PyObject *result = NULL;
- x1 = PyInt_FromLong(GET_TD_DAYS(self));
+ x1 = PyLong_FromLong(GET_TD_DAYS(self));
if (x1 == NULL)
goto Done;
x2 = PyNumber_Multiply(x1, seconds_per_day); /* days in seconds */
x1 = NULL;
/* x2 has days in seconds */
- x1 = PyInt_FromLong(GET_TD_SECONDS(self)); /* seconds */
+ x1 = PyLong_FromLong(GET_TD_SECONDS(self)); /* seconds */
if (x1 == NULL)
goto Done;
x3 = PyNumber_Add(x1, x2); /* days and seconds in seconds */
x3 = NULL;
/* x1 has days+seconds in us */
- x2 = PyInt_FromLong(GET_TD_MICROSECONDS(self));
+ x2 = PyLong_FromLong(GET_TD_MICROSECONDS(self));
if (x2 == NULL)
goto Done;
result = PyNumber_Add(x1, x2);
&ms, &minute, &hour, &week) == 0)
goto Done;
- x = PyInt_FromLong(0);
+ x = PyLong_FromLong(0);
if (x == NULL)
goto Done;
static PyObject *
date_year(PyDateTime_Date *self, void *unused)
{
- return PyInt_FromLong(GET_YEAR(self));
+ return PyLong_FromLong(GET_YEAR(self));
}
static PyObject *
date_month(PyDateTime_Date *self, void *unused)
{
- return PyInt_FromLong(GET_MONTH(self));
+ return PyLong_FromLong(GET_MONTH(self));
}
static PyObject *
date_day(PyDateTime_Date *self, void *unused)
{
- return PyInt_FromLong(GET_DAY(self));
+ return PyLong_FromLong(GET_DAY(self));
}
static PyGetSetDef date_getset[] = {
{
int dow = weekday(GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
- return PyInt_FromLong(dow + 1);
+ return PyLong_FromLong(dow + 1);
}
static PyObject *
static PyObject *
date_toordinal(PyDateTime_Date *self)
{
- return PyInt_FromLong(ymd_to_ord(GET_YEAR(self), GET_MONTH(self),
+ return PyLong_FromLong(ymd_to_ord(GET_YEAR(self), GET_MONTH(self),
GET_DAY(self)));
}
{
int dow = weekday(GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
- return PyInt_FromLong(dow);
+ return PyLong_FromLong(dow);
}
/* Pickle support, a simple use of __reduce__. */
static PyObject *
time_hour(PyDateTime_Time *self, void *unused)
{
- return PyInt_FromLong(TIME_GET_HOUR(self));
+ return PyLong_FromLong(TIME_GET_HOUR(self));
}
static PyObject *
time_minute(PyDateTime_Time *self, void *unused)
{
- return PyInt_FromLong(TIME_GET_MINUTE(self));
+ return PyLong_FromLong(TIME_GET_MINUTE(self));
}
/* The name time_second conflicted with some platform header file. */
static PyObject *
py_time_second(PyDateTime_Time *self, void *unused)
{
- return PyInt_FromLong(TIME_GET_SECOND(self));
+ return PyLong_FromLong(TIME_GET_SECOND(self));
}
static PyObject *
time_microsecond(PyDateTime_Time *self, void *unused)
{
- return PyInt_FromLong(TIME_GET_MICROSECOND(self));
+ return PyLong_FromLong(TIME_GET_MICROSECOND(self));
}
static PyObject *
static PyObject *
datetime_hour(PyDateTime_DateTime *self, void *unused)
{
- return PyInt_FromLong(DATE_GET_HOUR(self));
+ return PyLong_FromLong(DATE_GET_HOUR(self));
}
static PyObject *
datetime_minute(PyDateTime_DateTime *self, void *unused)
{
- return PyInt_FromLong(DATE_GET_MINUTE(self));
+ return PyLong_FromLong(DATE_GET_MINUTE(self));
}
static PyObject *
datetime_second(PyDateTime_DateTime *self, void *unused)
{
- return PyInt_FromLong(DATE_GET_SECOND(self));
+ return PyLong_FromLong(DATE_GET_SECOND(self));
}
static PyObject *
datetime_microsecond(PyDateTime_DateTime *self, void *unused)
{
- return PyInt_FromLong(DATE_GET_MICROSECOND(self));
+ return PyLong_FromLong(DATE_GET_MICROSECOND(self));
}
static PyObject *
return NULL;
}
if (PyInt_CheckExact(p))
- ia[i] = PyInt_AsLong(p);
+ ia[i] = PyLong_AsLong(p);
else
good_timetuple = 0;
Py_DECREF(p);
assert(DI100Y == 25 * DI4Y - 1);
assert(DI100Y == days_before_year(100+1));
- us_per_us = PyInt_FromLong(1);
- us_per_ms = PyInt_FromLong(1000);
- us_per_second = PyInt_FromLong(1000000);
- us_per_minute = PyInt_FromLong(60000000);
- seconds_per_day = PyInt_FromLong(24 * 3600);
+ us_per_us = PyLong_FromLong(1);
+ us_per_ms = PyLong_FromLong(1000);
+ us_per_second = PyLong_FromLong(1000000);
+ us_per_minute = PyLong_FromLong(60000000);
+ seconds_per_day = PyLong_FromLong(24 * 3600);
if (us_per_us == NULL || us_per_ms == NULL || us_per_second == NULL ||
us_per_minute == NULL || seconds_per_day == NULL)
return;
Py_INCREF(Py_None);
return Py_None;
}
- return PyInt_FromLong((long)func);
+ return PyLong_FromLong((long)func);
}
static PyObject *
}
for (i = 1; i < n; i++) {
PyObject *v = PyTuple_GetItem(args, i);
- if (PyInt_Check(v)) {
- alist[i-1] = PyInt_AsLong(v);
+ if (PyLong_Check(v)) {
+ alist[i-1] = PyLong_AsLong(v);
if (alist[i-1] == -1 && PyErr_Occurred())
return NULL;
} else if (PyUnicode_Check(v))
alist[i-1] = 0;
res = (*func)(alist[0], alist[1], alist[2], alist[3], alist[4],
alist[5], alist[6], alist[7], alist[8], alist[9]);
- return PyInt_FromLong(res);
+ return PyLong_FromLong(res);
}
static PyMethodDef dlobject_methods[] = {
static void
insint(PyObject *d, char *name, int value)
{
- PyObject *v = PyInt_FromLong((long) value);
+ PyObject *v = PyLong_FromLong((long) value);
if (!v || PyDict_SetItemString(d, name, v))
PyErr_Clear();
d = PyModule_GetDict(m);
Dlerror = x = PyErr_NewException("dl.error", NULL, NULL);
PyDict_SetItemString(d, "error", x);
- x = PyInt_FromLong((long)RTLD_LAZY);
+ x = PyLong_FromLong((long)RTLD_LAZY);
PyDict_SetItemString(d, "RTLD_LAZY", x);
#define INSINT(X) insint(d,#X,X)
#ifdef RTLD_NOW
_inscode(PyObject *d, PyObject *de, const char *name, int code)
{
PyObject *u = PyUnicode_FromString(name);
- PyObject *v = PyInt_FromLong((long) code);
+ PyObject *v = PyLong_FromLong((long) code);
/* Don't bother checking for errors; they'll be caught at the end
* of the module initialization function by the caller of
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
- return PyInt_FromLong((long)ret);
+ return PyLong_FromLong((long)ret);
}
PyDoc_STRVAR(fcntl_doc,
return NULL;
}
if (mutate_arg) {
- return PyInt_FromLong(ret);
+ return PyLong_FromLong(ret);
}
else {
return PyString_FromStringAndSize(buf, len);
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
- return PyInt_FromLong((long)ret);
+ return PyLong_FromLong((long)ret);
#undef IOCTL_BUFSZ
}
l.l_start = l.l_len = 0;
if (startobj != NULL) {
#if !defined(HAVE_LARGEFILE_SUPPORT)
- l.l_start = PyInt_AsLong(startobj);
+ l.l_start = PyLong_AsLong(startobj);
#else
l.l_start = PyLong_Check(startobj) ?
PyLong_AsLongLong(startobj) :
- PyInt_AsLong(startobj);
+ PyLong_AsLong(startobj);
#endif
if (PyErr_Occurred())
return NULL;
}
if (lenobj != NULL) {
#if !defined(HAVE_LARGEFILE_SUPPORT)
- l.l_len = PyInt_AsLong(lenobj);
+ l.l_len = PyLong_AsLong(lenobj);
#else
l.l_len = PyLong_Check(lenobj) ?
PyLong_AsLongLong(lenobj) :
- PyInt_AsLong(lenobj);
+ PyLong_AsLong(lenobj);
#endif
if (PyErr_Occurred())
return NULL;
static int
ins(PyObject* d, char* symbol, long value)
{
- PyObject* v = PyInt_FromLong(value);
+ PyObject* v = PyLong_FromLong(value);
if (!v || PyDict_SetItemString(d, symbol, v) < 0)
return -1;
collecting = 0;
}
- return PyInt_FromSsize_t(n);
+ return PyLong_FromSsize_t(n);
}
PyDoc_STRVAR(gc_set_debug__doc__,
Py_INCREF(Py_None);
}
#endif
- SET(setIndex++, PyInt_FromLong((long) p->gr_gid));
+ SET(setIndex++, PyLong_FromLong((long) p->gr_gid));
SET(setIndex++, w);
#undef SET
py_int_id = PyNumber_Int(pyo_id);
if (!py_int_id)
return NULL;
- gid = PyInt_AS_LONG(py_int_id);
+ gid = PyLong_AS_LONG(py_int_id);
Py_DECREF(py_int_id);
if ((p = getgrgid(gid)) == NULL) {
numargs = PyTuple_Size(args);
if (numargs == 2) {
if (a1 != Py_None) {
- stop = PyInt_AsSsize_t(a1);
+ stop = PyLong_AsSsize_t(a1);
if (stop == -1) {
if (PyErr_Occurred())
PyErr_Clear();
}
} else {
if (a1 != Py_None)
- start = PyInt_AsSsize_t(a1);
+ start = PyLong_AsSsize_t(a1);
if (start == -1 && PyErr_Occurred())
PyErr_Clear();
if (a2 != Py_None) {
- stop = PyInt_AsSsize_t(a2);
+ stop = PyLong_AsSsize_t(a2);
if (stop == -1) {
if (PyErr_Occurred())
PyErr_Clear();
if (a3 != NULL) {
if (a3 != Py_None)
- step = PyInt_AsSsize_t(a3);
+ step = PyLong_AsSsize_t(a3);
if (step == -1 && PyErr_Occurred())
PyErr_Clear();
}
return NULL;
if (cnt_arg != NULL) {
- cnt = PyInt_AsSsize_t(cnt_arg);
+ cnt = PyLong_AsSsize_t(cnt_arg);
if (cnt == -1 && PyErr_Occurred()) {
PyErr_Clear();
if (!PyLong_Check(cnt_arg)) {
PyObject *stepped_up;
if (lz->long_cnt == NULL) {
- lz->long_cnt = PyInt_FromSsize_t(PY_SSIZE_T_MAX);
+ lz->long_cnt = PyLong_FromSsize_t(PY_SSIZE_T_MAX);
if (lz->long_cnt == NULL)
return NULL;
}
if (one == NULL) {
- one = PyInt_FromLong(1);
+ one = PyLong_FromLong(1);
if (one == NULL)
return NULL;
}
{
if (lz->cnt == PY_SSIZE_T_MAX)
return count_nextlong(lz);
- return PyInt_FromSsize_t(lz->cnt++);
+ return PyLong_FromSsize_t(lz->cnt++);
}
static PyObject *
PyErr_SetString(PyExc_TypeError, "len() of unsized object");
return NULL;
}
- return PyInt_FromSize_t(ro->cnt);
+ return PyLong_FromSize_t(ro->cnt);
}
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
static PyObject *
MD5_get_block_size(PyObject *self, void *closure)
{
- return PyInt_FromLong(MD5_BLOCKSIZE);
+ return PyLong_FromLong(MD5_BLOCKSIZE);
}
static PyObject *
static PyObject *
md5_get_digest_size(PyObject *self, void *closure)
{
- return PyInt_FromLong(MD5_DIGESTSIZE);
+ return PyLong_FromLong(MD5_DIGESTSIZE);
}
for (i = 0; i < len && needle[i] == p[i]; ++i)
/* nothing */;
if (i == len) {
- return PyInt_FromSsize_t(p - self->data);
+ return PyLong_FromSsize_t(p - self->data);
}
}
- return PyInt_FromLong(-1);
+ return PyLong_FromLong(-1);
}
}
return PyErr_SetFromWindowsErr(error);
}
if (!high && low < LONG_MAX)
- return PyInt_FromLong((long)low);
+ return PyLong_FromLong((long)low);
size = (((PY_LONG_LONG)high)<<32) + low;
return PyLong_FromLongLong(size);
} else {
- return PyInt_FromSsize_t(self->size);
+ return PyLong_FromSsize_t(self->size);
}
#endif /* MS_WINDOWS */
PyErr_SetFromErrno(mmap_module_error);
return NULL;
}
- return PyInt_FromSsize_t(buf.st_size);
+ return PyLong_FromSsize_t(buf.st_size);
}
#endif /* UNIX */
}
mmap_tell_method(mmap_object *self, PyObject *unused)
{
CHECK_VALID(NULL);
- return PyInt_FromSize_t(self->pos);
+ return PyLong_FromSize_t(self->pos);
}
static PyObject *
return NULL;
} else {
#ifdef MS_WINDOWS
- return PyInt_FromLong((long)
+ return PyLong_FromLong((long)
FlushViewOfFile(self->data+offset, size));
#endif /* MS_WINDOWS */
#ifdef UNIX
PyErr_SetFromErrno(mmap_module_error);
return NULL;
}
- return PyInt_FromLong(0);
+ return PyLong_FromLong(0);
#endif /* UNIX */
}
}
"mmap index out of range");
return NULL;
}
- return PyInt_FromLong(Py_CHARMASK(self->data[i]));
+ return PyLong_FromLong(Py_CHARMASK(self->data[i]));
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelen;
static void
setint(PyObject *d, const char *name, long value)
{
- PyObject *o = PyInt_FromLong(value);
+ PyObject *o = PyLong_FromLong(value);
if (o && PyDict_SetItemString(d, name, o) == 0) {
Py_DECREF(o);
}
PyObject *a1, *a2; long r; \
if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
if(-1 == (r=AOP(a1,a2))) return NULL; \
- return PyInt_FromLong(r); }
+ return PyLong_FromLong(r); }
#define spamn2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
PyObject *a1, *a2; Py_ssize_t r; \
if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
if(-1 == (r=AOP(a1,a2))) return NULL; \
- return PyInt_FromSsize_t(r); }
+ return PyLong_FromSsize_t(r); }
#define spami2b(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
PyObject *a1, *a2; long r; \
if (ioctl(fd, cmd, &arg) == -1)
return PyErr_SetFromErrno(PyExc_IOError);
- return PyInt_FromLong(arg);
+ return PyLong_FromLong(arg);
}
if (ioctl(fd, cmd, &arg) == -1)
return PyErr_SetFromErrno(PyExc_IOError);
- return PyInt_FromLong(arg);
+ return PyLong_FromLong(arg);
}
int mask;
if (ioctl(self->fd, SNDCTL_DSP_GETFMTS, &mask) == -1)
return PyErr_SetFromErrno(PyExc_IOError);
- return PyInt_FromLong(mask);
+ return PyLong_FromLong(mask);
}
static PyObject *
} else {
self->ocount += rv;
}
- return PyInt_FromLong(rv);
+ return PyLong_FromLong(rv);
}
static PyObject *
static PyObject *
oss_fileno(oss_audio_t *self, PyObject *unused)
{
- return PyInt_FromLong(self->fd);
+ return PyLong_FromLong(self->fd);
}
rv = PyTuple_New(3);
if (rv == NULL)
return NULL;
- PyTuple_SET_ITEM(rv, 0, PyInt_FromLong(fmt));
- PyTuple_SET_ITEM(rv, 1, PyInt_FromLong(channels));
- PyTuple_SET_ITEM(rv, 2, PyInt_FromLong(rate));
+ PyTuple_SET_ITEM(rv, 0, PyLong_FromLong(fmt));
+ PyTuple_SET_ITEM(rv, 1, PyLong_FromLong(channels));
+ PyTuple_SET_ITEM(rv, 2, PyLong_FromLong(rate));
return rv;
}
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
- return PyInt_FromLong((ai.fragstotal * ai.fragsize) / (nchannels * ssize));
+ return PyLong_FromLong((ai.fragstotal * ai.fragsize) / (nchannels * ssize));
}
/* obufcount returns the number of samples that are available in the
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
- return PyInt_FromLong((ai.fragstotal * ai.fragsize - ai.bytes) /
+ return PyLong_FromLong((ai.fragstotal * ai.fragsize - ai.bytes) /
(ssize * nchannels));
}
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
- return PyInt_FromLong(ai.bytes / (ssize * nchannels));
+ return PyLong_FromLong(ai.bytes / (ssize * nchannels));
}
static PyObject *
static PyObject *
oss_mixer_fileno(oss_mixer_t *self, PyObject *unused)
{
- return PyInt_FromLong(self->fd);
+ return PyLong_FromLong(self->fd);
}
/* Simple mixer interface methods */
v = mkseq(1 + NCH(n) + (TYPE(n) == encoding_decl));
if (v == NULL)
return (v);
- w = PyInt_FromLong(TYPE(n));
+ w = PyLong_FromLong(TYPE(n));
if (w == NULL) {
Py_DECREF(v);
return ((PyObject*) NULL);
else if (ISTERMINAL(TYPE(n))) {
PyObject *result = mkseq(2 + lineno + col_offset);
if (result != NULL) {
- (void) addelem(result, 0, PyInt_FromLong(TYPE(n)));
+ (void) addelem(result, 0, PyLong_FromLong(TYPE(n)));
(void) addelem(result, 1, PyUnicode_FromString(STR(n)));
if (lineno == 1)
- (void) addelem(result, 2, PyInt_FromLong(n->n_lineno));
+ (void) addelem(result, 2, PyLong_FromLong(n->n_lineno));
if (col_offset == 1)
- (void) addelem(result, 3, PyInt_FromLong(n->n_col_offset));
+ (void) addelem(result, 3, PyLong_FromLong(n->n_col_offset));
}
return (result);
}
if (temp == NULL)
ok = 0;
else {
- ok = PyInt_Check(temp);
+ ok = PyLong_Check(temp);
if (ok)
- type = PyInt_AS_LONG(temp);
+ type = PyLong_AS_LONG(temp);
Py_DECREF(temp);
}
}
if (len == 3) {
PyObject *o = PySequence_GetItem(elem, 2);
if (o != NULL) {
- if (PyInt_Check(o))
- *line_num = PyInt_AS_LONG(o);
+ if (PyLong_Check(o))
+ *line_num = PyLong_AS_LONG(o);
else {
PyErr_Format(parser_error,
"third item in terminal node must be an"
long num = -1;
if (temp != NULL)
- num = PyInt_AsLong(temp);
+ num = PyLong_AsLong(temp);
Py_XDECREF(temp);
if (ISTERMINAL(num)) {
/*
#if SIZEOF_TIME_T > SIZEOF_LONG
ival = PyLong_FromLongLong((PY_LONG_LONG)sec);
#else
- ival = PyInt_FromLong((long)sec);
+ ival = PyLong_FromLong((long)sec);
#endif
if (!ival)
return;
if (v == NULL)
return NULL;
- PyStructSequence_SET_ITEM(v, 0, PyInt_FromLong((long)st->st_mode));
+ PyStructSequence_SET_ITEM(v, 0, PyLong_FromLong((long)st->st_mode));
#ifdef HAVE_LARGEFILE_SUPPORT
PyStructSequence_SET_ITEM(v, 1,
PyLong_FromLongLong((PY_LONG_LONG)st->st_ino));
#else
- PyStructSequence_SET_ITEM(v, 1, PyInt_FromLong((long)st->st_ino));
+ PyStructSequence_SET_ITEM(v, 1, PyLong_FromLong((long)st->st_ino));
#endif
#if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS)
PyStructSequence_SET_ITEM(v, 2,
PyLong_FromLongLong((PY_LONG_LONG)st->st_dev));
#else
- PyStructSequence_SET_ITEM(v, 2, PyInt_FromLong((long)st->st_dev));
+ PyStructSequence_SET_ITEM(v, 2, PyLong_FromLong((long)st->st_dev));
#endif
- PyStructSequence_SET_ITEM(v, 3, PyInt_FromLong((long)st->st_nlink));
- PyStructSequence_SET_ITEM(v, 4, PyInt_FromLong((long)st->st_uid));
- PyStructSequence_SET_ITEM(v, 5, PyInt_FromLong((long)st->st_gid));
+ PyStructSequence_SET_ITEM(v, 3, PyLong_FromLong((long)st->st_nlink));
+ PyStructSequence_SET_ITEM(v, 4, PyLong_FromLong((long)st->st_uid));
+ PyStructSequence_SET_ITEM(v, 5, PyLong_FromLong((long)st->st_gid));
#ifdef HAVE_LARGEFILE_SUPPORT
PyStructSequence_SET_ITEM(v, 6,
PyLong_FromLongLong((PY_LONG_LONG)st->st_size));
#else
- PyStructSequence_SET_ITEM(v, 6, PyInt_FromLong(st->st_size));
+ PyStructSequence_SET_ITEM(v, 6, PyLong_FromLong(st->st_size));
#endif
#if defined(HAVE_STAT_TV_NSEC)
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
PyStructSequence_SET_ITEM(v, ST_BLKSIZE_IDX,
- PyInt_FromLong((long)st->st_blksize));
+ PyLong_FromLong((long)st->st_blksize));
#endif
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
PyStructSequence_SET_ITEM(v, ST_BLOCKS_IDX,
- PyInt_FromLong((long)st->st_blocks));
+ PyLong_FromLong((long)st->st_blocks));
#endif
#ifdef HAVE_STRUCT_STAT_ST_RDEV
PyStructSequence_SET_ITEM(v, ST_RDEV_IDX,
- PyInt_FromLong((long)st->st_rdev));
+ PyLong_FromLong((long)st->st_rdev));
#endif
#ifdef HAVE_STRUCT_STAT_ST_GEN
PyStructSequence_SET_ITEM(v, ST_GEN_IDX,
- PyInt_FromLong((long)st->st_gen));
+ PyLong_FromLong((long)st->st_gen));
#endif
#ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
{
if (_stat_float_times) {
val = PyFloat_FromDouble(bsec + 1e-9*bnsec);
} else {
- val = PyInt_FromLong((long)bsec);
+ val = PyLong_FromLong((long)bsec);
}
PyStructSequence_SET_ITEM(v, ST_BIRTHTIME_IDX,
val);
#endif
#ifdef HAVE_STRUCT_STAT_ST_FLAGS
PyStructSequence_SET_ITEM(v, ST_FLAGS_IDX,
- PyInt_FromLong((long)st->st_flags));
+ PyLong_FromLong((long)st->st_flags));
#endif
if (PyErr_Occurred()) {
if (value == -1 && errno != 0)
/* either nice() or getpriority() returned an error */
return posix_error();
- return PyInt_FromLong((long) value);
+ return PyLong_FromLong((long) value);
}
#endif /* HAVE_NICE */
sts = system(command);
#endif
Py_END_ALLOW_THREADS
- return PyInt_FromLong(sts);
+ return PyLong_FromLong(sts);
}
#endif
i = (int)umask(i);
if (i < 0)
return posix_error();
- return PyInt_FromLong((long)i);
+ return PyLong_FromLong((long)i);
}
PyObject *intobj = Py_Type(t)->tp_as_number->nb_int(t);
if (!intobj)
return -1;
- intval = PyInt_AsLong(intobj);
+ intval = PyLong_AsLong(intobj);
Py_DECREF(intobj);
if (intval == -1 && PyErr_Occurred())
return -1;
*usec = 0;
return 0;
}
- intval = PyInt_AsLong(t);
+ intval = PyLong_AsLong(t);
if (intval == -1 && PyErr_Occurred())
return -1;
*sec = intval;
if (pid == -1)
return posix_error();
PyOS_AfterFork();
- return PyInt_FromLong((long)pid);
+ return PyLong_FromLong((long)pid);
}
#endif
return posix_error();
if (pid == 0)
PyOS_AfterFork();
- return PyInt_FromLong((long)pid);
+ return PyLong_FromLong((long)pid);
}
#endif
static PyObject *
posix_getegid(PyObject *self, PyObject *noargs)
{
- return PyInt_FromLong((long)getegid());
+ return PyLong_FromLong((long)getegid());
}
#endif
static PyObject *
posix_geteuid(PyObject *self, PyObject *noargs)
{
- return PyInt_FromLong((long)geteuid());
+ return PyLong_FromLong((long)geteuid());
}
#endif
static PyObject *
posix_getgid(PyObject *self, PyObject *noargs)
{
- return PyInt_FromLong((long)getgid());
+ return PyLong_FromLong((long)getgid());
}
#endif
static PyObject *
posix_getpid(PyObject *self, PyObject *noargs)
{
- return PyInt_FromLong((long)getpid());
+ return PyLong_FromLong((long)getpid());
}
if (result != NULL) {
int i;
for (i = 0; i < n; ++i) {
- PyObject *o = PyInt_FromLong((long)grouplist[i]);
+ PyObject *o = PyLong_FromLong((long)grouplist[i]);
if (o == NULL) {
Py_DECREF(result);
result = NULL;
pgid = getpgid(pid);
if (pgid < 0)
return posix_error();
- return PyInt_FromLong((long)pgid);
+ return PyLong_FromLong((long)pgid);
}
#endif /* HAVE_GETPGID */
posix_getpgrp(PyObject *self, PyObject *noargs)
{
#ifdef GETPGRP_HAVE_ARG
- return PyInt_FromLong((long)getpgrp(0));
+ return PyLong_FromLong((long)getpgrp(0));
#else /* GETPGRP_HAVE_ARG */
- return PyInt_FromLong((long)getpgrp());
+ return PyLong_FromLong((long)getpgrp());
#endif /* GETPGRP_HAVE_ARG */
}
#endif /* HAVE_GETPGRP */
static PyObject *
posix_getppid(PyObject *self, PyObject *noargs)
{
- return PyInt_FromLong((long)getppid());
+ return PyLong_FromLong((long)getppid());
}
#endif
static PyObject *
posix_getuid(PyObject *self, PyObject *noargs)
{
- return PyInt_FromLong((long)getuid());
+ return PyLong_FromLong((long)getuid());
}
#endif
PyStructSequence_SET_ITEM(result, 1,
PyFloat_FromDouble(doubletime(ru->ru_stime)));
#define SET_INT(result, index, value)\
- PyStructSequence_SET_ITEM(result, index, PyInt_FromLong(value))
+ PyStructSequence_SET_ITEM(result, index, PyLong_FromLong(value))
SET_INT(result, 2, ru->ru_maxrss);
SET_INT(result, 3, ru->ru_ixrss);
SET_INT(result, 4, ru->ru_idrss);
sid = getsid(pid);
if (sid < 0)
return posix_error();
- return PyInt_FromLong((long)sid);
+ return PyLong_FromLong((long)sid);
}
#endif /* HAVE_GETSID */
pgid = tcgetpgrp(fd);
if (pgid < 0)
return posix_error();
- return PyInt_FromLong((long)pgid);
+ return PyLong_FromLong((long)pgid);
}
#endif /* HAVE_TCGETPGRP */
Py_END_ALLOW_THREADS
if (fd < 0)
return posix_error();
- return PyInt_FromLong((long)fd);
+ return PyLong_FromLong((long)fd);
}
/* Drop the argument parsing error as narrow strings
are also valid. */
if (fd < 0)
return posix_error_with_allocated_filename(file);
PyMem_Free(file);
- return PyInt_FromLong((long)fd);
+ return PyLong_FromLong((long)fd);
}
Py_END_ALLOW_THREADS
if (fd < 0)
return posix_error();
- return PyInt_FromLong((long)fd);
+ return PyLong_FromLong((long)fd);
}
#endif /* SEEK_END */
#if !defined(HAVE_LARGEFILE_SUPPORT)
- pos = PyInt_AsLong(posobj);
+ pos = PyLong_AsLong(posobj);
#else
pos = PyLong_Check(posobj) ?
- PyLong_AsLongLong(posobj) : PyInt_AsLong(posobj);
+ PyLong_AsLongLong(posobj) : PyLong_AsLong(posobj);
#endif
if (PyErr_Occurred())
return NULL;
return posix_error();
#if !defined(HAVE_LARGEFILE_SUPPORT)
- return PyInt_FromLong(res);
+ return PyLong_FromLong(res);
#else
return PyLong_FromLongLong(res);
#endif
Py_END_ALLOW_THREADS
if (size < 0)
return posix_error();
- return PyInt_FromSsize_t(size);
+ return PyLong_FromSsize_t(size);
}
int device;
if (!PyArg_ParseTuple(args, "i:major", &device))
return NULL;
- return PyInt_FromLong((long)major(device));
+ return PyLong_FromLong((long)major(device));
}
PyDoc_STRVAR(posix_minor__doc__,
int device;
if (!PyArg_ParseTuple(args, "i:minor", &device))
return NULL;
- return PyInt_FromLong((long)minor(device));
+ return PyLong_FromLong((long)minor(device));
}
PyDoc_STRVAR(posix_makedev__doc__,
int major, minor;
if (!PyArg_ParseTuple(args, "ii:makedev", &major, &minor))
return NULL;
- return PyInt_FromLong((long)makedev(major, minor));
+ return PyLong_FromLong((long)makedev(major, minor));
}
#endif /* device macros */
return NULL;
#if !defined(HAVE_LARGEFILE_SUPPORT)
- length = PyInt_AsLong(lenobj);
+ length = PyLong_AsLong(lenobj);
#else
length = PyLong_Check(lenobj) ?
- PyLong_AsLongLong(lenobj) : PyInt_AsLong(lenobj);
+ PyLong_AsLongLong(lenobj) : PyLong_AsLong(lenobj);
#endif
if (PyErr_Occurred())
return NULL;
return NULL;
#if !defined(HAVE_LARGEFILE_SUPPORT)
- PyStructSequence_SET_ITEM(v, 0, PyInt_FromLong((long) st.f_bsize));
- PyStructSequence_SET_ITEM(v, 1, PyInt_FromLong((long) st.f_frsize));
- PyStructSequence_SET_ITEM(v, 2, PyInt_FromLong((long) st.f_blocks));
- PyStructSequence_SET_ITEM(v, 3, PyInt_FromLong((long) st.f_bfree));
- PyStructSequence_SET_ITEM(v, 4, PyInt_FromLong((long) st.f_bavail));
- PyStructSequence_SET_ITEM(v, 5, PyInt_FromLong((long) st.f_files));
- PyStructSequence_SET_ITEM(v, 6, PyInt_FromLong((long) st.f_ffree));
- PyStructSequence_SET_ITEM(v, 7, PyInt_FromLong((long) st.f_favail));
- PyStructSequence_SET_ITEM(v, 8, PyInt_FromLong((long) st.f_flag));
- PyStructSequence_SET_ITEM(v, 9, PyInt_FromLong((long) st.f_namemax));
+ PyStructSequence_SET_ITEM(v, 0, PyLong_FromLong((long) st.f_bsize));
+ PyStructSequence_SET_ITEM(v, 1, PyLong_FromLong((long) st.f_frsize));
+ PyStructSequence_SET_ITEM(v, 2, PyLong_FromLong((long) st.f_blocks));
+ PyStructSequence_SET_ITEM(v, 3, PyLong_FromLong((long) st.f_bfree));
+ PyStructSequence_SET_ITEM(v, 4, PyLong_FromLong((long) st.f_bavail));
+ PyStructSequence_SET_ITEM(v, 5, PyLong_FromLong((long) st.f_files));
+ PyStructSequence_SET_ITEM(v, 6, PyLong_FromLong((long) st.f_ffree));
+ PyStructSequence_SET_ITEM(v, 7, PyLong_FromLong((long) st.f_favail));
+ PyStructSequence_SET_ITEM(v, 8, PyLong_FromLong((long) st.f_flag));
+ PyStructSequence_SET_ITEM(v, 9, PyLong_FromLong((long) st.f_namemax));
#else
- PyStructSequence_SET_ITEM(v, 0, PyInt_FromLong((long) st.f_bsize));
- PyStructSequence_SET_ITEM(v, 1, PyInt_FromLong((long) st.f_frsize));
+ PyStructSequence_SET_ITEM(v, 0, PyLong_FromLong((long) st.f_bsize));
+ PyStructSequence_SET_ITEM(v, 1, PyLong_FromLong((long) st.f_frsize));
PyStructSequence_SET_ITEM(v, 2,
PyLong_FromLongLong((PY_LONG_LONG) st.f_blocks));
PyStructSequence_SET_ITEM(v, 3,
PyLong_FromLongLong((PY_LONG_LONG) st.f_ffree));
PyStructSequence_SET_ITEM(v, 7,
PyLong_FromLongLong((PY_LONG_LONG) st.f_favail));
- PyStructSequence_SET_ITEM(v, 8, PyInt_FromLong((long) st.f_flag));
- PyStructSequence_SET_ITEM(v, 9, PyInt_FromLong((long) st.f_namemax));
+ PyStructSequence_SET_ITEM(v, 8, PyLong_FromLong((long) st.f_flag));
+ PyStructSequence_SET_ITEM(v, 9, PyLong_FromLong((long) st.f_namemax));
#endif
return v;
conv_confname(PyObject *arg, int *valuep, struct constdef *table,
size_t tablesize)
{
- if (PyInt_Check(arg)) {
- *valuep = PyInt_AS_LONG(arg);
+ if (PyLong_Check(arg)) {
+ *valuep = PyLong_AS_LONG(arg);
return 1;
}
else {
if (limit == -1 && errno != 0)
posix_error();
else
- result = PyInt_FromLong(limit);
+ result = PyLong_FromLong(limit);
}
return result;
}
posix_error_with_filename(path);
}
else
- result = PyInt_FromLong(limit);
+ result = PyLong_FromLong(limit);
}
return result;
}
if (value == -1 && errno != 0)
posix_error();
else
- result = PyInt_FromLong(value);
+ result = PyLong_FromLong(value);
}
return result;
}
return -1;
for (i=0; i < tablesize; ++i) {
- PyObject *o = PyInt_FromLong(table[i].value);
+ PyObject *o = PyLong_FromLong(table[i].value);
if (o == NULL || PyDict_SetItemString(d, table[i].name, o) == -1) {
Py_XDECREF(o);
Py_DECREF(d);
if (v == NULL)
return NULL;
-#define SETI(i,val) PyStructSequence_SET_ITEM(v, i, PyInt_FromLong((long) val))
+#define SETI(i,val) PyStructSequence_SET_ITEM(v, i, PyLong_FromLong((long) val))
#define SETS(i,val) sets(v, i, val)
SETS(setIndex++, p->pw_name);
static int
set_error_attr(PyObject *err, char *name, int value)
{
- PyObject *v = PyInt_FromLong(value);
+ PyObject *v = PyLong_FromLong(value);
if (v == NULL || PyObject_SetAttrString(err, name, v) == -1) {
Py_XDECREF(v);
#define INT_HANDLER(NAME, PARAMS, PARAM_FORMAT)\
RC_HANDLER(int, NAME, PARAMS, int rc=0;, PARAM_FORMAT, \
- rc = PyInt_AsLong(rv);, rc, \
+ rc = PyLong_AsLong(rv);, rc, \
(xmlparseobject *)userData)
VOID_HANDLER(EndElement,
("(O&NNN)",
conv_string_to_unicode ,context, string_intern(self, base),
string_intern(self, systemId), string_intern(self, publicId)),
- rc = PyInt_AsLong(rv);, rc,
+ rc = PyLong_AsLong(rv);, rc,
XML_GetUserData(parser))
/* XXX UnknownEncodingHandler */
if (flush_character_buffer(self) < 0) {
return NULL;
}
- return PyInt_FromLong(rv);
+ return PyLong_FromLong(rv);
}
PyDoc_STRVAR(xmlparse_Parse__doc__,
int len = -1;
char *ptr;
- if ((bytes = PyInt_FromLong(buf_size)) == NULL)
+ if ((bytes = PyLong_FromLong(buf_size)) == NULL)
goto finally;
if ((arg = PyTuple_New(1)) == NULL) {
if (!PyArg_ParseTuple(args, "i", &flag))
return NULL;
flag = XML_SetParamEntityParsing(p->itself, flag);
- return PyInt_FromLong(flag);
+ return PyLong_FromLong(flag);
}
}
if (name[0] == 'E') {
if (strcmp(name, "ErrorCode") == 0)
- return PyInt_FromLong((long)
+ return PyLong_FromLong((long)
XML_GetErrorCode(self->itself));
if (strcmp(name, "ErrorLineNumber") == 0)
- return PyInt_FromLong((long)
+ return PyLong_FromLong((long)
XML_GetErrorLineNumber(self->itself));
if (strcmp(name, "ErrorColumnNumber") == 0)
- return PyInt_FromLong((long)
+ return PyLong_FromLong((long)
XML_GetErrorColumnNumber(self->itself));
if (strcmp(name, "ErrorByteIndex") == 0)
- return PyInt_FromLong((long)
+ return PyLong_FromLong((long)
XML_GetErrorByteIndex(self->itself));
}
if (name[0] == 'C') {
if (strcmp(name, "CurrentLineNumber") == 0)
- return PyInt_FromLong((long)
+ return PyLong_FromLong((long)
XML_GetCurrentLineNumber(self->itself));
if (strcmp(name, "CurrentColumnNumber") == 0)
- return PyInt_FromLong((long)
+ return PyLong_FromLong((long)
XML_GetCurrentColumnNumber(self->itself));
if (strcmp(name, "CurrentByteIndex") == 0)
- return PyInt_FromLong((long)
+ return PyLong_FromLong((long)
XML_GetCurrentByteIndex(self->itself));
}
if (name[0] == 'b') {
if (strcmp(name, "buffer_size") == 0)
- return PyInt_FromLong((long) self->buffer_size);
+ return PyLong_FromLong((long) self->buffer_size);
if (strcmp(name, "buffer_text") == 0)
return get_pybool(self->buffer != NULL);
if (strcmp(name, "buffer_used") == 0)
- return PyInt_FromLong((long) self->buffer_used);
+ return PyLong_FromLong((long) self->buffer_used);
}
if (strcmp(name, "namespace_prefixes") == 0)
return get_pybool(self->ns_prefixes);
static PyObject*
get_history_length(PyObject *self, PyObject *noarg)
{
- return PyInt_FromLong(_history_length);
+ return PyLong_FromLong(_history_length);
}
PyDoc_STRVAR(get_history_length_doc,
static PyObject *
get_completion_type(PyObject *self, PyObject *noarg)
{
- return PyInt_FromLong(rl_completion_type);
+ return PyLong_FromLong(rl_completion_type);
}
PyDoc_STRVAR(doc_get_completion_type,
HISTORY_STATE *hist_st;
hist_st = history_get_history_state();
- return PyInt_FromLong(hist_st ? (long) hist_st->length : (long) 0);
+ return PyLong_FromLong(hist_st ? (long) hist_st->length : (long) 0);
}
PyDoc_STRVAR(doc_get_current_history_length,
if (r == Py_None)
result = 0;
else {
- result = PyInt_AsLong(r);
+ result = PyLong_AsLong(r);
if (result == -1 && PyErr_Occurred())
goto error;
}
Py_DECREF(m), m=NULL;
if (r == NULL ||
- (r != Py_None && PyInt_AsLong(r) == -1 && PyErr_Occurred())) {
+ (r != Py_None && PyLong_AsLong(r) == -1 && PyErr_Occurred())) {
goto error;
}
Py_XDECREF(r), r=NULL;
{
Py_XDECREF(begidx);
Py_XDECREF(endidx);
- begidx = PyInt_FromLong((long) start);
- endidx = PyInt_FromLong((long) end);
+ begidx = PyLong_FromLong((long) start);
+ endidx = PyLong_FromLong((long) end);
return completion_matches(text, *on_completion);
}
rl_completion_append_character ='\0';
#endif
- begidx = PyInt_FromLong(0L);
- endidx = PyInt_FromLong(0L);
+ begidx = PyLong_FromLong(0L);
+ endidx = PyLong_FromLong(0L);
/* Initialize (allows .inputrc to override)
*
* XXX: A bug in the readline-2.2 library causes a memory leak
PyFloat_FromDouble(doubletime(ru.ru_utime)));
PyStructSequence_SET_ITEM(result, 1,
PyFloat_FromDouble(doubletime(ru.ru_stime)));
- PyStructSequence_SET_ITEM(result, 2, PyInt_FromLong(ru.ru_maxrss));
- PyStructSequence_SET_ITEM(result, 3, PyInt_FromLong(ru.ru_ixrss));
- PyStructSequence_SET_ITEM(result, 4, PyInt_FromLong(ru.ru_idrss));
- PyStructSequence_SET_ITEM(result, 5, PyInt_FromLong(ru.ru_isrss));
- PyStructSequence_SET_ITEM(result, 6, PyInt_FromLong(ru.ru_minflt));
- PyStructSequence_SET_ITEM(result, 7, PyInt_FromLong(ru.ru_majflt));
- PyStructSequence_SET_ITEM(result, 8, PyInt_FromLong(ru.ru_nswap));
- PyStructSequence_SET_ITEM(result, 9, PyInt_FromLong(ru.ru_inblock));
- PyStructSequence_SET_ITEM(result, 10, PyInt_FromLong(ru.ru_oublock));
- PyStructSequence_SET_ITEM(result, 11, PyInt_FromLong(ru.ru_msgsnd));
- PyStructSequence_SET_ITEM(result, 12, PyInt_FromLong(ru.ru_msgrcv));
- PyStructSequence_SET_ITEM(result, 13, PyInt_FromLong(ru.ru_nsignals));
- PyStructSequence_SET_ITEM(result, 14, PyInt_FromLong(ru.ru_nvcsw));
- PyStructSequence_SET_ITEM(result, 15, PyInt_FromLong(ru.ru_nivcsw));
+ PyStructSequence_SET_ITEM(result, 2, PyLong_FromLong(ru.ru_maxrss));
+ PyStructSequence_SET_ITEM(result, 3, PyLong_FromLong(ru.ru_ixrss));
+ PyStructSequence_SET_ITEM(result, 4, PyLong_FromLong(ru.ru_idrss));
+ PyStructSequence_SET_ITEM(result, 5, PyLong_FromLong(ru.ru_isrss));
+ PyStructSequence_SET_ITEM(result, 6, PyLong_FromLong(ru.ru_minflt));
+ PyStructSequence_SET_ITEM(result, 7, PyLong_FromLong(ru.ru_majflt));
+ PyStructSequence_SET_ITEM(result, 8, PyLong_FromLong(ru.ru_nswap));
+ PyStructSequence_SET_ITEM(result, 9, PyLong_FromLong(ru.ru_inblock));
+ PyStructSequence_SET_ITEM(result, 10, PyLong_FromLong(ru.ru_oublock));
+ PyStructSequence_SET_ITEM(result, 11, PyLong_FromLong(ru.ru_msgsnd));
+ PyStructSequence_SET_ITEM(result, 12, PyLong_FromLong(ru.ru_msgrcv));
+ PyStructSequence_SET_ITEM(result, 13, PyLong_FromLong(ru.ru_nsignals));
+ PyStructSequence_SET_ITEM(result, 14, PyLong_FromLong(ru.ru_nvcsw));
+ PyStructSequence_SET_ITEM(result, 15, PyLong_FromLong(ru.ru_nivcsw));
if (PyErr_Occurred()) {
Py_DECREF(result);
}
#if !defined(HAVE_LARGEFILE_SUPPORT)
- rl.rlim_cur = PyInt_AsLong(curobj);
+ rl.rlim_cur = PyLong_AsLong(curobj);
if (rl.rlim_cur == -1 && PyErr_Occurred())
return NULL;
- rl.rlim_max = PyInt_AsLong(maxobj);
+ rl.rlim_max = PyLong_AsLong(maxobj);
if (rl.rlim_max == -1 && PyErr_Occurred())
return NULL;
#else
/* The limits are probably bigger than a long */
rl.rlim_cur = PyLong_Check(curobj) ?
- PyLong_AsLongLong(curobj) : PyInt_AsLong(curobj);
+ PyLong_AsLongLong(curobj) : PyLong_AsLong(curobj);
if (rl.rlim_cur == -1 && PyErr_Occurred())
return NULL;
rl.rlim_max = PyLong_Check(maxobj) ?
- PyLong_AsLongLong(maxobj) : PyInt_AsLong(maxobj);
+ PyLong_AsLongLong(maxobj) : PyLong_AsLong(maxobj);
if (rl.rlim_max == -1 && PyErr_Occurred())
return NULL;
#endif
} else
#endif
{
- v = PyInt_FromLong((long) RLIM_INFINITY);
+ v = PyLong_FromLong((long) RLIM_INFINITY);
}
if (v) {
PyModule_AddObject(m, "RLIM_INFINITY", v);
i = pos = 0;
while (PyDict_Next(self->dict, &pos, &key, &value)) {
- self->ufds[i].fd = PyInt_AsLong(key);
- self->ufds[i].events = (short)PyInt_AsLong(value);
+ self->ufds[i].fd = PyLong_AsLong(key);
+ self->ufds[i].events = (short)PyLong_AsLong(value);
i++;
}
self->ufd_uptodate = 1;
/* Add entry to the internal dictionary: the key is the
file descriptor, and the value is the event mask. */
- key = PyInt_FromLong(fd);
+ key = PyLong_FromLong(fd);
if (key == NULL)
return NULL;
- value = PyInt_FromLong(events);
+ value = PyLong_FromLong(events);
if (value == NULL) {
Py_DECREF(key);
return NULL;
return NULL;
/* Check whether the fd is already in the array */
- key = PyInt_FromLong(fd);
+ key = PyLong_FromLong(fd);
if (key == NULL)
return NULL;
tout = PyNumber_Int(tout);
if (!tout)
return NULL;
- timeout = PyInt_AsLong(tout);
+ timeout = PyLong_AsLong(tout);
Py_DECREF(tout);
if (timeout == -1 && PyErr_Occurred())
return NULL;
value = PyTuple_New(2);
if (value == NULL)
goto error;
- num = PyInt_FromLong(self->ufds[i].fd);
+ num = PyLong_FromLong(self->ufds[i].fd);
if (num == NULL) {
Py_DECREF(value);
goto error;
is a 16-bit short, and IBM assigned POLLNVAL
to be 0x8000, so the conversion to int results
in a negative number. See SF bug #923315. */
- num = PyInt_FromLong(self->ufds[i].revents & 0xffff);
+ num = PyLong_FromLong(self->ufds[i].revents & 0xffff);
if (num == NULL) {
Py_DECREF(value);
goto error;
static PyObject *
SHA1_get_block_size(PyObject *self, void *closure)
{
- return PyInt_FromLong(SHA1_BLOCKSIZE);
+ return PyLong_FromLong(SHA1_BLOCKSIZE);
}
static PyObject *
static PyObject *
sha1_get_digest_size(PyObject *self, void *closure)
{
- return PyInt_FromLong(SHA1_DIGESTSIZE);
+ return PyLong_FromLong(SHA1_DIGESTSIZE);
}
static PyObject *
SHA256_get_block_size(PyObject *self, void *closure)
{
- return PyInt_FromLong(SHA_BLOCKSIZE);
+ return PyLong_FromLong(SHA_BLOCKSIZE);
}
static PyObject *
static PyObject *
SHA512_get_block_size(PyObject *self, void *closure)
{
- return PyInt_FromLong(SHA_BLOCKSIZE);
+ return PyLong_FromLong(SHA_BLOCKSIZE);
}
static PyObject *
if (!PyArg_ParseTuple(args, "i:alarm", &t))
return NULL;
/* alarm() returns the number of seconds remaining */
- return PyInt_FromLong((long)alarm(t));
+ return PyLong_FromLong((long)alarm(t));
}
PyDoc_STRVAR(alarm_doc,
if (!x || PyDict_SetItemString(d, "SIG_IGN", x) < 0)
goto finally;
- x = PyInt_FromLong((long)NSIG);
+ x = PyLong_FromLong((long)NSIG);
if (!x || PyDict_SetItemString(d, "NSIG", x) < 0)
goto finally;
Py_DECREF(x);
}
#ifdef SIGHUP
- x = PyInt_FromLong(SIGHUP);
+ x = PyLong_FromLong(SIGHUP);
PyDict_SetItemString(d, "SIGHUP", x);
Py_XDECREF(x);
#endif
#ifdef SIGINT
- x = PyInt_FromLong(SIGINT);
+ x = PyLong_FromLong(SIGINT);
PyDict_SetItemString(d, "SIGINT", x);
Py_XDECREF(x);
#endif
#ifdef SIGBREAK
- x = PyInt_FromLong(SIGBREAK);
+ x = PyLong_FromLong(SIGBREAK);
PyDict_SetItemString(d, "SIGBREAK", x);
Py_XDECREF(x);
#endif
#ifdef SIGQUIT
- x = PyInt_FromLong(SIGQUIT);
+ x = PyLong_FromLong(SIGQUIT);
PyDict_SetItemString(d, "SIGQUIT", x);
Py_XDECREF(x);
#endif
#ifdef SIGILL
- x = PyInt_FromLong(SIGILL);
+ x = PyLong_FromLong(SIGILL);
PyDict_SetItemString(d, "SIGILL", x);
Py_XDECREF(x);
#endif
#ifdef SIGTRAP
- x = PyInt_FromLong(SIGTRAP);
+ x = PyLong_FromLong(SIGTRAP);
PyDict_SetItemString(d, "SIGTRAP", x);
Py_XDECREF(x);
#endif
#ifdef SIGIOT
- x = PyInt_FromLong(SIGIOT);
+ x = PyLong_FromLong(SIGIOT);
PyDict_SetItemString(d, "SIGIOT", x);
Py_XDECREF(x);
#endif
#ifdef SIGABRT
- x = PyInt_FromLong(SIGABRT);
+ x = PyLong_FromLong(SIGABRT);
PyDict_SetItemString(d, "SIGABRT", x);
Py_XDECREF(x);
#endif
#ifdef SIGEMT
- x = PyInt_FromLong(SIGEMT);
+ x = PyLong_FromLong(SIGEMT);
PyDict_SetItemString(d, "SIGEMT", x);
Py_XDECREF(x);
#endif
#ifdef SIGFPE
- x = PyInt_FromLong(SIGFPE);
+ x = PyLong_FromLong(SIGFPE);
PyDict_SetItemString(d, "SIGFPE", x);
Py_XDECREF(x);
#endif
#ifdef SIGKILL
- x = PyInt_FromLong(SIGKILL);
+ x = PyLong_FromLong(SIGKILL);
PyDict_SetItemString(d, "SIGKILL", x);
Py_XDECREF(x);
#endif
#ifdef SIGBUS
- x = PyInt_FromLong(SIGBUS);
+ x = PyLong_FromLong(SIGBUS);
PyDict_SetItemString(d, "SIGBUS", x);
Py_XDECREF(x);
#endif
#ifdef SIGSEGV
- x = PyInt_FromLong(SIGSEGV);
+ x = PyLong_FromLong(SIGSEGV);
PyDict_SetItemString(d, "SIGSEGV", x);
Py_XDECREF(x);
#endif
#ifdef SIGSYS
- x = PyInt_FromLong(SIGSYS);
+ x = PyLong_FromLong(SIGSYS);
PyDict_SetItemString(d, "SIGSYS", x);
Py_XDECREF(x);
#endif
#ifdef SIGPIPE
- x = PyInt_FromLong(SIGPIPE);
+ x = PyLong_FromLong(SIGPIPE);
PyDict_SetItemString(d, "SIGPIPE", x);
Py_XDECREF(x);
#endif
#ifdef SIGALRM
- x = PyInt_FromLong(SIGALRM);
+ x = PyLong_FromLong(SIGALRM);
PyDict_SetItemString(d, "SIGALRM", x);
Py_XDECREF(x);
#endif
#ifdef SIGTERM
- x = PyInt_FromLong(SIGTERM);
+ x = PyLong_FromLong(SIGTERM);
PyDict_SetItemString(d, "SIGTERM", x);
Py_XDECREF(x);
#endif
#ifdef SIGUSR1
- x = PyInt_FromLong(SIGUSR1);
+ x = PyLong_FromLong(SIGUSR1);
PyDict_SetItemString(d, "SIGUSR1", x);
Py_XDECREF(x);
#endif
#ifdef SIGUSR2
- x = PyInt_FromLong(SIGUSR2);
+ x = PyLong_FromLong(SIGUSR2);
PyDict_SetItemString(d, "SIGUSR2", x);
Py_XDECREF(x);
#endif
#ifdef SIGCLD
- x = PyInt_FromLong(SIGCLD);
+ x = PyLong_FromLong(SIGCLD);
PyDict_SetItemString(d, "SIGCLD", x);
Py_XDECREF(x);
#endif
#ifdef SIGCHLD
- x = PyInt_FromLong(SIGCHLD);
+ x = PyLong_FromLong(SIGCHLD);
PyDict_SetItemString(d, "SIGCHLD", x);
Py_XDECREF(x);
#endif
#ifdef SIGPWR
- x = PyInt_FromLong(SIGPWR);
+ x = PyLong_FromLong(SIGPWR);
PyDict_SetItemString(d, "SIGPWR", x);
Py_XDECREF(x);
#endif
#ifdef SIGIO
- x = PyInt_FromLong(SIGIO);
+ x = PyLong_FromLong(SIGIO);
PyDict_SetItemString(d, "SIGIO", x);
Py_XDECREF(x);
#endif
#ifdef SIGURG
- x = PyInt_FromLong(SIGURG);
+ x = PyLong_FromLong(SIGURG);
PyDict_SetItemString(d, "SIGURG", x);
Py_XDECREF(x);
#endif
#ifdef SIGWINCH
- x = PyInt_FromLong(SIGWINCH);
+ x = PyLong_FromLong(SIGWINCH);
PyDict_SetItemString(d, "SIGWINCH", x);
Py_XDECREF(x);
#endif
#ifdef SIGPOLL
- x = PyInt_FromLong(SIGPOLL);
+ x = PyLong_FromLong(SIGPOLL);
PyDict_SetItemString(d, "SIGPOLL", x);
Py_XDECREF(x);
#endif
#ifdef SIGSTOP
- x = PyInt_FromLong(SIGSTOP);
+ x = PyLong_FromLong(SIGSTOP);
PyDict_SetItemString(d, "SIGSTOP", x);
Py_XDECREF(x);
#endif
#ifdef SIGTSTP
- x = PyInt_FromLong(SIGTSTP);
+ x = PyLong_FromLong(SIGTSTP);
PyDict_SetItemString(d, "SIGTSTP", x);
Py_XDECREF(x);
#endif
#ifdef SIGCONT
- x = PyInt_FromLong(SIGCONT);
+ x = PyLong_FromLong(SIGCONT);
PyDict_SetItemString(d, "SIGCONT", x);
Py_XDECREF(x);
#endif
#ifdef SIGTTIN
- x = PyInt_FromLong(SIGTTIN);
+ x = PyLong_FromLong(SIGTTIN);
PyDict_SetItemString(d, "SIGTTIN", x);
Py_XDECREF(x);
#endif
#ifdef SIGTTOU
- x = PyInt_FromLong(SIGTTOU);
+ x = PyLong_FromLong(SIGTTOU);
PyDict_SetItemString(d, "SIGTTOU", x);
Py_XDECREF(x);
#endif
#ifdef SIGVTALRM
- x = PyInt_FromLong(SIGVTALRM);
+ x = PyLong_FromLong(SIGVTALRM);
PyDict_SetItemString(d, "SIGVTALRM", x);
Py_XDECREF(x);
#endif
#ifdef SIGPROF
- x = PyInt_FromLong(SIGPROF);
+ x = PyLong_FromLong(SIGPROF);
PyDict_SetItemString(d, "SIGPROF", x);
Py_XDECREF(x);
#endif
#ifdef SIGXCPU
- x = PyInt_FromLong(SIGXCPU);
+ x = PyLong_FromLong(SIGXCPU);
PyDict_SetItemString(d, "SIGXCPU", x);
Py_XDECREF(x);
#endif
#ifdef SIGXFSZ
- x = PyInt_FromLong(SIGXFSZ);
+ x = PyLong_FromLong(SIGXFSZ);
PyDict_SetItemString(d, "SIGXFSZ", x);
Py_XDECREF(x);
#endif
#ifdef SIGRTMIN
- x = PyInt_FromLong(SIGRTMIN);
+ x = PyLong_FromLong(SIGRTMIN);
PyDict_SetItemString(d, "SIGRTMIN", x);
Py_XDECREF(x);
#endif
#ifdef SIGRTMAX
- x = PyInt_FromLong(SIGRTMAX);
+ x = PyLong_FromLong(SIGRTMAX);
PyDict_SetItemString(d, "SIGRTMAX", x);
Py_XDECREF(x);
#endif
#ifdef SIGINFO
- x = PyInt_FromLong(SIGINFO);
+ x = PyLong_FromLong(SIGINFO);
PyDict_SetItemString(d, "SIGINFO", x);
Py_XDECREF(x);
#endif
{
int block;
- block = PyInt_AsLong(arg);
+ block = PyLong_AsLong(arg);
if (block == -1 && PyErr_Occurred())
return NULL;
(void *)&flag, &flagsize);
if (res < 0)
return s->errorhandler();
- return PyInt_FromLong(flag);
+ return PyLong_FromLong(flag);
}
#ifdef __VMS
/* socklen_t is unsigned so no negative test is needed,
return NULL;
#endif
- return PyInt_FromLong((long) res);
+ return PyLong_FromLong((long) res);
}
PyDoc_STRVAR(connect_ex_doc,
int backlog;
int res;
- backlog = PyInt_AsLong(arg);
+ backlog = PyLong_AsLong(arg);
if (backlog == -1 && PyErr_Occurred())
return NULL;
Py_BEGIN_ALLOW_THREADS
/* Return the number of bytes read. Note that we do not do anything
special here in the case that readlen < recvlen. */
- return PyInt_FromSsize_t(readlen);
+ return PyLong_FromSsize_t(readlen);
}
PyDoc_STRVAR(recv_into_doc,
}
if (n < 0)
return s->errorhandler();
- return PyInt_FromLong((long)n);
+ return PyLong_FromLong((long)n);
}
PyDoc_STRVAR(send_doc,
}
if (n < 0)
return s->errorhandler();
- return PyInt_FromLong((long)n);
+ return PyLong_FromLong((long)n);
}
PyDoc_STRVAR(sendto_doc,
int how;
int res;
- how = PyInt_AsLong(arg);
+ how = PyLong_AsLong(arg);
if (how == -1 && PyErr_Occurred())
return NULL;
Py_BEGIN_ALLOW_THREADS
PyErr_SetString(socket_error, "service/proto not found");
return NULL;
}
- return PyInt_FromLong((long) ntohs(sp->s_port));
+ return PyLong_FromLong((long) ntohs(sp->s_port));
}
PyDoc_STRVAR(getservbyname_doc,
PyErr_SetString(socket_error, "protocol not found");
return NULL;
}
- return PyInt_FromLong((long) sp->p_proto);
+ return PyLong_FromLong((long) sp->p_proto);
}
PyDoc_STRVAR(getprotobyname_doc,
return NULL;
}
x2 = (unsigned int)ntohs((unsigned short)x1);
- return PyInt_FromLong(x2);
+ return PyLong_FromLong(x2);
}
PyDoc_STRVAR(ntohs_doc,
return NULL;
}
x2 = (unsigned int)htons((unsigned short)x1);
- return PyInt_FromLong(x2);
+ return PyLong_FromLong(x2);
}
PyDoc_STRVAR(htons_doc,
return NULL;
}
if (PyInt_CheckExact(pobj)) {
- PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", PyInt_AsLong(pobj));
+ PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", PyLong_AsLong(pobj));
pptr = pbuf;
} else if (PyUnicode_Check(pobj)) {
pptr = PyUnicode_AsString(pobj);
if (v == NULL)
return NULL;
-#define SETI(i,val) PyStructSequence_SET_ITEM(v, i, PyInt_FromLong((long) val))
+#define SETI(i,val) PyStructSequence_SET_ITEM(v, i, PyLong_FromLong((long) val))
#define SETS(i,val) sets(v, i, val)
SETS(setIndex++, p->sp_namp);
if (!PyArg_ParseTuple(args, "l;mask for priority", &maskpri))
return NULL;
omaskpri = setlogmask(maskpri);
- return PyInt_FromLong(omaskpri);
+ return PyLong_FromLong(omaskpri);
}
static PyObject *
if (!PyArg_ParseTuple(args, "l:LOG_MASK", &pri))
return NULL;
mask = LOG_MASK(pri);
- return PyInt_FromLong(mask);
+ return PyLong_FromLong(mask);
}
static PyObject *
if (!PyArg_ParseTuple(args, "l:LOG_UPTO", &pri))
return NULL;
mask = LOG_UPTO(pri);
- return PyInt_FromLong(mask);
+ return PyLong_FromLong(mask);
}
/* List of functions defined in the module */
MIN and TIME slots are the same as the EOF and EOL slots. So we
only do this in noncanonical input mode. */
if ((mode.c_lflag & ICANON) == 0) {
- v = PyInt_FromLong((long)mode.c_cc[VMIN]);
+ v = PyLong_FromLong((long)mode.c_cc[VMIN]);
if (v == NULL)
goto err;
PyList_SetItem(cc, VMIN, v);
- v = PyInt_FromLong((long)mode.c_cc[VTIME]);
+ v = PyLong_FromLong((long)mode.c_cc[VTIME]);
if (v == NULL)
goto err;
PyList_SetItem(cc, VTIME, v);
if (!(v = PyList_New(7)))
goto err;
- PyList_SetItem(v, 0, PyInt_FromLong((long)mode.c_iflag));
- PyList_SetItem(v, 1, PyInt_FromLong((long)mode.c_oflag));
- PyList_SetItem(v, 2, PyInt_FromLong((long)mode.c_cflag));
- PyList_SetItem(v, 3, PyInt_FromLong((long)mode.c_lflag));
- PyList_SetItem(v, 4, PyInt_FromLong((long)ispeed));
- PyList_SetItem(v, 5, PyInt_FromLong((long)ospeed));
+ PyList_SetItem(v, 0, PyLong_FromLong((long)mode.c_iflag));
+ PyList_SetItem(v, 1, PyLong_FromLong((long)mode.c_oflag));
+ PyList_SetItem(v, 2, PyLong_FromLong((long)mode.c_cflag));
+ PyList_SetItem(v, 3, PyLong_FromLong((long)mode.c_lflag));
+ PyList_SetItem(v, 4, PyLong_FromLong((long)ispeed));
+ PyList_SetItem(v, 5, PyLong_FromLong((long)ospeed));
PyList_SetItem(v, 6, cc);
if (PyErr_Occurred()){
Py_DECREF(v);
/* Get the old mode, in case there are any hidden fields... */
if (tcgetattr(fd, &mode) == -1)
return PyErr_SetFromErrno(TermiosError);
- mode.c_iflag = (tcflag_t) PyInt_AsLong(PyList_GetItem(term, 0));
- mode.c_oflag = (tcflag_t) PyInt_AsLong(PyList_GetItem(term, 1));
- mode.c_cflag = (tcflag_t) PyInt_AsLong(PyList_GetItem(term, 2));
- mode.c_lflag = (tcflag_t) PyInt_AsLong(PyList_GetItem(term, 3));
- ispeed = (speed_t) PyInt_AsLong(PyList_GetItem(term, 4));
- ospeed = (speed_t) PyInt_AsLong(PyList_GetItem(term, 5));
+ mode.c_iflag = (tcflag_t) PyLong_AsLong(PyList_GetItem(term, 0));
+ mode.c_oflag = (tcflag_t) PyLong_AsLong(PyList_GetItem(term, 1));
+ mode.c_cflag = (tcflag_t) PyLong_AsLong(PyList_GetItem(term, 2));
+ mode.c_lflag = (tcflag_t) PyLong_AsLong(PyList_GetItem(term, 3));
+ ispeed = (speed_t) PyLong_AsLong(PyList_GetItem(term, 4));
+ ospeed = (speed_t) PyLong_AsLong(PyList_GetItem(term, 5));
cc = PyList_GetItem(term, 6);
if (PyErr_Occurred())
return NULL;
if (PyString_Check(v) && PyString_Size(v) == 1)
mode.c_cc[i] = (cc_t) * PyString_AsString(v);
- else if (PyInt_Check(v))
- mode.c_cc[i] = (cc_t) PyInt_AsLong(v);
+ else if (PyLong_Check(v))
+ mode.c_cc[i] = (cc_t) PyLong_AsLong(v);
else {
PyErr_SetString(PyExc_TypeError,
"tcsetattr: elements of attributes must be characters or integers");
PyMem_DEL(boot);
return NULL;
}
- return PyInt_FromLong(ident);
+ return PyLong_FromLong(ident);
}
PyDoc_STRVAR(start_new_doc,
PyErr_SetString(ThreadError, "no current thread ident");
return NULL;
}
- return PyInt_FromLong(ident);
+ return PyLong_FromLong(ident);
}
PyDoc_STRVAR(get_ident_doc,
return NULL;
}
- return PyInt_FromSsize_t((Py_ssize_t) old_size);
+ return PyLong_FromSsize_t((Py_ssize_t) old_size);
}
PyDoc_STRVAR(stack_size_doc,
if (v == NULL)
return NULL;
-#define SET(i,val) PyStructSequence_SET_ITEM(v, i, PyInt_FromLong((long) val))
+#define SET(i,val) PyStructSequence_SET_ITEM(v, i, PyLong_FromLong((long) val))
SET(0, p->tm_year + 1900);
SET(1, p->tm_mon + 1); /* Want January == 1 */
PyObject *accept = PyDict_GetItemString(moddict,
"accept2dyear");
if (accept == NULL || !PyInt_CheckExact(accept) ||
- PyInt_AsLong(accept) == 0) {
+ PyLong_AsLong(accept) == 0) {
PyErr_SetString(PyExc_ValueError,
"year >= 1900 required");
return 0;
return defobj;
}
}
- return PyInt_FromLong(rc);
+ return PyLong_FromLong(rc);
}
PyDoc_STRVAR(unicodedata_digit__doc__,
return defobj;
}
}
- return PyInt_FromLong(rc);
+ return PyLong_FromLong(rc);
}
PyDoc_STRVAR(unicodedata_numeric__doc__,
if (old->category_changed == 0)
index = 0; /* unassigned */
}
- return PyInt_FromLong(index);
+ return PyLong_FromLong(index);
}
PyDoc_STRVAR(unicodedata_mirrored__doc__,
if (old->category_changed == 0)
index = 0; /* unassigned */
}
- return PyInt_FromLong(index);
+ return PyLong_FromLong(index);
}
PyDoc_STRVAR(unicodedata_east_asian_width__doc__,
if (!PyArg_ParseTuple(args, "ll:foo", &i, &j))
return NULL;
res = i+j; /* XXX Do something here */
- return PyInt_FromLong(res);
+ return PyLong_FromLong(res);
}
item = PyList_GetItem(list, 0);
/* Py_INCREF(item); */
- PyList_SetItem(list, 1, PyInt_FromLong(0L));
+ PyList_SetItem(list, 1, PyLong_FromLong(0L));
PyObject_Print(item, stdout, 0);
printf("\n");
/* Py_DECREF(item); */
{
if (!PyArg_ParseTuple(args, ":getstate"))
return NULL;
- return PyInt_FromLong(self->state);
+ return PyLong_FromLong(self->state);
}
static PyObject *
static PyObject *
spamlist_state_get(spamlistobject *self)
{
- return PyInt_FromLong(self->state);
+ return PyLong_FromLong(self->state);
}
static PyGetSetDef spamlist_getsets[] = {
{
if (!PyArg_ParseTuple(args, ":getstate"))
return NULL;
- return PyInt_FromLong(self->state);
+ return PyLong_FromLong(self->state);
}
static PyObject *
/* fetch the time stamp of the .py file for comparison
with an embedded pyc time stamp */
int time, date;
- time = PyInt_AsLong(PyTuple_GetItem(toc_entry, 5));
- date = PyInt_AsLong(PyTuple_GetItem(toc_entry, 6));
+ time = PyLong_AsLong(PyTuple_GetItem(toc_entry, 5));
+ date = PyLong_AsLong(PyTuple_GetItem(toc_entry, 6));
mtime = parse_dostime(time, date);
}
path[lastchar] = savechar;
if (!PyArg_ParseTuple(args, "s#|k:adler32", &buf, &len, &adler32val))
return NULL;
adler32val = adler32(adler32val, buf, len);
- return PyInt_FromLong(adler32val);
+ return PyLong_FromLong(adler32val);
}
PyDoc_STRVAR(crc32__doc__,
if (!PyArg_ParseTuple(args, "s#|k:crc32", &buf, &len, &crc32val))
return NULL;
crc32val = crc32(crc32val, buf, len);
- return PyInt_FromLong(crc32val);
+ return PyLong_FromLong(crc32val);
}
PyErr_Fetch(&err_type, &err_value, &err_tb);
ro = PyObject_CallMethod(o, "__length_hint__", NULL);
if (ro != NULL) {
- rv = PyInt_AsLong(ro);
+ rv = PyLong_AsLong(ro);
Py_DECREF(ro);
Py_XDECREF(err_type);
Py_XDECREF(err_value);
if (value == NULL)
return -1;
- /* We're done if PyInt_AsSsize_t() returns without error. */
- result = PyInt_AsSsize_t(value);
+ /* We're done if PyLong_AsSsize_t() returns without error. */
+ result = PyLong_AsSsize_t(value);
if (result != -1 || !(runerr = PyErr_Occurred()))
goto finish;
to nb_multiply if o appears to be a sequence. */
if (PySequence_Check(o)) {
PyObject *n, *result;
- n = PyInt_FromSsize_t(count);
+ n = PyLong_FromSsize_t(count);
if (n == NULL)
return NULL;
result = binary_op1(o, n, NB_SLOT(nb_multiply));
if (PySequence_Check(o)) {
PyObject *n, *result;
- n = PyInt_FromSsize_t(count);
+ n = PyLong_FromSsize_t(count);
if (n == NULL)
return NULL;
result = binary_iop1(o, n, NB_SLOT(nb_inplace_multiply),
{
long face_value;
- if (PyInt_Check(arg)) {
- face_value = PyInt_AsLong(arg);
+ if (PyLong_Check(arg)) {
+ face_value = PyLong_AsLong(arg);
if (face_value < 0 || face_value >= 256) {
PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
return 0;
PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
return NULL;
}
- return PyInt_FromLong((unsigned char)(self->ob_bytes[i]));
+ return PyLong_FromLong((unsigned char)(self->ob_bytes[i]));
}
static PyObject *
PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
return NULL;
}
- return PyInt_FromLong((unsigned char)(self->ob_bytes[i]));
+ return PyLong_FromLong((unsigned char)(self->ob_bytes[i]));
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
Py_ssize_t result = bytes_find_internal(self, args, +1);
if (result == -2)
return NULL;
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
PyDoc_STRVAR(count__doc__,
_adjust_indices(&start, &end, PyBytes_GET_SIZE(self));
- count_obj = PyInt_FromSsize_t(
+ count_obj = PyLong_FromSsize_t(
stringlib_count(str + start, end - start, vsub.buf, vsub.len)
);
PyObject_ReleaseBuffer(sub_obj, &vsub);
"subsection not found");
return NULL;
}
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
Py_ssize_t result = bytes_find_internal(self, args, -1);
if (result == -2)
return NULL;
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
"subsection not found");
return NULL;
}
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
if (PyBytes_Resize((PyObject *)self, n - 1) < 0)
return NULL;
- return PyInt_FromLong(value);
+ return PyLong_FromLong(value);
}
PyDoc_STRVAR(remove__doc__,
static PyObject *
bytes_alloc(PyBytesObject *self)
{
- return PyInt_FromSsize_t(self->ob_alloc);
+ return PyLong_FromSsize_t(self->ob_alloc);
}
PyDoc_STRVAR(join_doc,
assert(PyBytes_Check(seq));
if (it->it_index < PyBytes_GET_SIZE(seq)) {
- item = PyInt_FromLong(
+ item = PyLong_FromLong(
(unsigned char)seq->ob_bytes[it->it_index]);
if (item != NULL)
++it->it_index;
Py_ssize_t len = 0;
if (it->it_seq)
len = PyBytes_GET_SIZE(it->it_seq) - it->it_index;
- return PyInt_FromSsize_t(len);
+ return PyLong_FromSsize_t(len);
}
PyDoc_STRVAR(length_hint_doc,
Py_ssize_t len = 0;
if (di->di_dict != NULL && di->di_used == di->di_dict->ma_used)
len = di->len;
- return PyInt_FromSize_t(len);
+ return PyLong_FromSize_t(len);
}
PyDoc_STRVAR(length_hint_doc,
PyObject *stepped_up;
if (en->en_longindex == NULL) {
- en->en_longindex = PyInt_FromLong(LONG_MAX);
+ en->en_longindex = PyLong_FromLong(LONG_MAX);
if (en->en_longindex == NULL)
return NULL;
}
if (one == NULL) {
- one = PyInt_FromLong(1);
+ one = PyLong_FromLong(1);
if (one == NULL)
return NULL;
}
if (en->en_index == LONG_MAX)
return enum_next_long(en, next_item);
- next_index = PyInt_FromLong(en->en_index);
+ next_index = PyLong_FromLong(en->en_index);
if (next_index == NULL) {
Py_DECREF(next_item);
return NULL;
Py_ssize_t position, seqsize;
if (ro->seq == NULL)
- return PyInt_FromLong(0);
+ return PyLong_FromLong(0);
seqsize = PySequence_Size(ro->seq);
if (seqsize == -1)
return NULL;
position = ro->index + 1;
- return PyInt_FromSsize_t((seqsize < position) ? 0 : position);
+ return PyLong_FromSsize_t((seqsize < position) ? 0 : position);
}
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
/* Set errno to the POSIX errno, and winerror to the Win32
error code. */
- errcode = PyInt_AsLong(self->myerrno);
+ errcode = PyLong_AsLong(self->myerrno);
if (errcode == -1 && PyErr_Occurred())
return -1;
posix_errno = winerror_to_errno(errcode);
Py_CLEAR(self->winerror);
self->winerror = self->myerrno;
- o_errcode = PyInt_FromLong(posix_errno);
+ o_errcode = PyLong_FromLong(posix_errno);
if (!o_errcode)
return -1;
return PyUnicode_FromFormat("%S (%s, line %ld)",
self->msg ? self->msg : Py_None,
my_basename(filename),
- PyInt_AsLong(self->lineno));
+ PyLong_AsLong(self->lineno));
else if (filename)
return PyUnicode_FromFormat("%S (%s)",
self->msg ? self->msg : Py_None,
else /* only have_lineno */
return PyUnicode_FromFormat("%S (line %ld)",
self->msg ? self->msg : Py_None,
- PyInt_AsLong(self->lineno));
+ PyLong_AsLong(self->lineno));
}
static PyMemberDef SyntaxError_members[] = {
static PyObject *
stdprinter_fileno(PyStdPrinter_Object *self)
{
- return PyInt_FromLong((long) self->fd);
+ return PyLong_FromLong((long) self->fd);
}
static PyObject *
if (PyDict_SetItemString(d, key, tmp)) return NULL; \
Py_DECREF(tmp)
#define SET_INT_CONST(d, key, const) \
- tmp = PyInt_FromLong(const); \
+ tmp = PyLong_FromLong(const); \
if (tmp == NULL) return NULL; \
if (PyDict_SetItemString(d, key, tmp)) return NULL; \
Py_DECREF(tmp)
*/
PyObject *temp;
- one = PyInt_FromLong(1);
+ one = PyLong_FromLong(1);
if (one == NULL)
goto Error;
*/
if (LONG_MIN < wholepart && wholepart < LONG_MAX) {
const long aslong = (long)wholepart;
- return PyInt_FromLong(aslong);
+ return PyLong_FromLong(aslong);
}
return PyLong_FromDouble(wholepart);
}
else
lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);
- return PyInt_FromLong(lineno);
+ return PyLong_FromLong(lineno);
}
/* Setter for f_lineno - you can set f_lineno from within a trace function in
}
/* Fail if the line comes before the start of the code block. */
- new_lineno = (int) PyInt_AsLong(p_new_lineno);
+ new_lineno = (int) PyLong_AsLong(p_new_lineno);
if (new_lineno < f->f_code->co_firstlineno) {
PyErr_Format(PyExc_ValueError,
"line %d comes before the current code block",
return NULL;
len = seqsize - it->it_index;
if (len >= 0)
- return PyInt_FromSsize_t(len);
+ return PyLong_FromSsize_t(len);
}
- return PyInt_FromLong(0);
+ return PyLong_FromLong(0);
}
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
Py_DECREF(res);
return -1;
}
- i = PyInt_AsLong(res);
+ i = PyLong_AsLong(res);
Py_DECREF(res);
return i < 0;
}
for (i = start; i < stop && i < Py_Size(self); i++) {
int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
if (cmp > 0)
- return PyInt_FromSsize_t(i);
+ return PyLong_FromSsize_t(i);
else if (cmp < 0)
return NULL;
}
else if (cmp < 0)
return NULL;
}
- return PyInt_FromSsize_t(count);
+ return PyLong_FromSsize_t(count);
}
static PyObject *
if (it->it_seq) {
len = PyList_GET_SIZE(it->it_seq) - it->it_index;
if (len >= 0)
- return PyInt_FromSsize_t(len);
+ return PyLong_FromSsize_t(len);
}
- return PyInt_FromLong(0);
+ return PyLong_FromLong(0);
}
/*********************** List Reverse Iterator **************************/
be a small integer, so negating it must go to PyLong_FromLong */
#define NEGATE(x) \
do if (Py_Refcnt(x) == 1) Py_Size(x) = -Py_Size(x); \
- else { PyObject* tmp=PyInt_FromLong(-MEDIUM_VALUE(x)); \
+ else { PyObject* tmp=PyLong_FromLong(-MEDIUM_VALUE(x)); \
Py_DECREF(x); (x) = (PyLongObject*)tmp; } \
while(0)
/* For long multiplication, use the O(N**2) school algorithm unless
#endif
/* special-case null pointer */
if (!p)
- return PyInt_FromLong(0);
+ return PyLong_FromLong(0);
return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)(Py_uintptr_t)p);
}
CHECK_BINOP(a, b);
if (ABS(Py_Size(a)) <= 1 && ABS(Py_Size(b)) <= 1) {
- PyObject *result = PyInt_FromLong(MEDIUM_VALUE(a) +
+ PyObject *result = PyLong_FromLong(MEDIUM_VALUE(a) +
MEDIUM_VALUE(b));
return result;
}
static PyObject *
memory_itemsize_get(PyMemoryViewObject *self)
{
- return PyInt_FromSsize_t(self->view.itemsize);
+ return PyLong_FromSsize_t(self->view.itemsize);
}
static PyObject *
intTuple = PyTuple_New(len);
if (!intTuple) return NULL;
for(i=0; i<len; i++) {
- o = PyInt_FromSsize_t(vals[i]);
+ o = PyLong_FromSsize_t(vals[i]);
if (!o) {
Py_DECREF(intTuple);
return NULL;
static PyObject *
memory_size_get(PyMemoryViewObject *self)
{
- return PyInt_FromSsize_t(self->view.len);
+ return PyLong_FromSsize_t(self->view.len);
}
static PyObject *
static PyObject *
memory_ndim_get(PyMemoryViewObject *self)
{
- return PyInt_FromLong(self->view.ndim);
+ return PyLong_FromLong(self->view.ndim);
}
static PyGetSetDef memory_getsetlist[] ={
{
/* No step specified, use a step of 1. */
if (!step)
- return PyInt_FromLong(1);
+ return PyLong_FromLong(1);
step = PyNumber_Index(step);
if (step) {
stop = PyNumber_Index(stop);
if (!stop)
goto Fail;
- start = PyInt_FromLong(0);
- step = PyInt_FromLong(1);
+ start = PyLong_FromLong(0);
+ step = PyLong_FromLong(1);
if (!start || !step)
goto Fail;
}
/* Return number of items in range (lo, hi, step), when arguments are
* PyInt or PyLong objects. step > 0 required. Return a value < 0 if
* & only if the true value is too large to fit in a signed long.
- * Arguments MUST return 1 with either PyInt_Check() or
+ * Arguments MUST return 1 with either PyLong_Check() or
* PyLong_Check(). Return -1 when there is an error.
*/
static PyObject*
rangeiter_next(rangeiterobject *r)
{
if (r->index < r->len)
- return PyInt_FromLong(r->start + (r->index++) * r->step);
+ return PyLong_FromLong(r->start + (r->index++) * r->step);
return NULL;
}
static PyObject *
rangeiter_len(rangeiterobject *r)
{
- return PyInt_FromLong(r->len - r->index);
+ return PyLong_FromLong(r->len - r->index);
}
typedef struct {
Py_ssize_t len = 0;
if (si->si_set != NULL && si->si_used == si->si_set->used)
len = si->len;
- return PyInt_FromLong(len);
+ return PyLong_FromLong(len);
}
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
_PySlice_FromIndices(Py_ssize_t istart, Py_ssize_t istop)
{
PyObject *start, *end, *slice;
- start = PyInt_FromSsize_t(istart);
+ start = PyLong_FromSsize_t(istart);
if (!start)
return NULL;
- end = PyInt_FromSsize_t(istop);
+ end = PyLong_FromSsize_t(istop);
if (!end) {
Py_DECREF(start);
return NULL;
*step = 1;
} else {
if (!PyLong_Check(r->step)) return -1;
- *step = PyInt_AsSsize_t(r->step);
+ *step = PyLong_AsSsize_t(r->step);
}
if (r->start == Py_None) {
*start = *step < 0 ? length-1 : 0;
} else {
- if (!PyInt_Check(r->start)) return -1;
- *start = PyInt_AsSsize_t(r->start);
+ 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 (!PyInt_Check(r->stop)) return -1;
- *stop = PyInt_AsSsize_t(r->stop);
+ if (!PyLong_Check(r->stop)) return -1;
+ *stop = PyLong_AsSsize_t(r->stop);
if (*stop < 0) *stop += length;
}
if (*stop > length) return -1;
/* taken from unicodeobject.c formatchar() */
/* Integer input truncated to a character */
- x = PyInt_AsLong(value);
+ x = PyLong_AsLong(value);
if (x == -1 && PyErr_Occurred())
goto done;
#ifdef Py_UNICODE_WIDE
getitem_idx(PyObject *obj, Py_ssize_t idx)
{
PyObject *newobj;
- PyObject *idx_obj = PyInt_FromSsize_t(idx);
+ PyObject *idx_obj = PyLong_FromSsize_t(idx);
if (idx_obj == NULL)
return NULL;
newobj = PyObject_GetItem(obj, idx_obj);
/* either an integer or a string */
if (idx != -1)
- obj = PyInt_FromSsize_t(idx);
+ obj = PyLong_FromSsize_t(idx);
else
obj = SubString_new_object(&name);
if (obj == NULL)
/* first becomes an integer, if possible; else a string */
if (first_idx != -1)
- first_obj = PyInt_FromSsize_t(first_idx);
+ first_obj = PyLong_FromSsize_t(first_idx);
else
/* convert "first" into a string object */
first_obj = SubString_new_object(&first);
PyErr_SetString(PyExc_IndexError, "string index out of range");
return NULL;
}
- return PyInt_FromLong((unsigned char)a->ob_sval[i]);
+ return PyLong_FromLong((unsigned char)a->ob_sval[i]);
}
static PyObject*
"string index out of range");
return NULL;
}
- return PyInt_FromLong((unsigned char)self->ob_sval[i]);
+ return PyLong_FromLong((unsigned char)self->ob_sval[i]);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
Py_ssize_t result = string_find_internal(self, args, +1);
if (result == -2)
return NULL;
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
"substring not found");
return NULL;
}
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
Py_ssize_t result = string_find_internal(self, args, -1);
if (result == -2)
return NULL;
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
"substring not found");
return NULL;
}
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
string_adjust_indices(&start, &end, PyString_GET_SIZE(self));
- return PyInt_FromSsize_t(
+ return PyLong_FromSsize_t(
stringlib_count(str + start, end - start, sub, sub_len)
);
}
assert(PyString_Check(seq));
if (it->it_index < PyString_GET_SIZE(seq)) {
- item = PyInt_FromLong(
+ item = PyLong_FromLong(
(unsigned char)seq->ob_sval[it->it_index]);
if (item != NULL)
++it->it_index;
Py_ssize_t len = 0;
if (it->it_seq)
len = PyString_GET_SIZE(it->it_seq) - it->it_index;
- return PyInt_FromSsize_t(len);
+ return PyLong_FromSsize_t(len);
}
PyDoc_STRVAR(length_hint_doc,
char *PyStructSequence_UnnamedField = "unnamed field";
#define VISIBLE_SIZE(op) Py_Size(op)
-#define VISIBLE_SIZE_TP(tp) PyInt_AsLong( \
+#define VISIBLE_SIZE_TP(tp) PyLong_AsLong( \
PyDict_GetItemString((tp)->tp_dict, visible_length_key))
-#define REAL_SIZE_TP(tp) PyInt_AsLong( \
+#define REAL_SIZE_TP(tp) PyLong_AsLong( \
PyDict_GetItemString((tp)->tp_dict, real_length_key))
#define REAL_SIZE(op) REAL_SIZE_TP(Py_Type(op))
-#define UNNAMED_FIELDS_TP(tp) PyInt_AsLong( \
+#define UNNAMED_FIELDS_TP(tp) PyLong_AsLong( \
PyDict_GetItemString((tp)->tp_dict, unnamed_fields_key))
#define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP(Py_Type(op))
dict = type->tp_dict;
PyDict_SetItemString(dict, visible_length_key,
- PyInt_FromLong((long) desc->n_in_sequence));
+ PyLong_FromLong((long) desc->n_in_sequence));
PyDict_SetItemString(dict, real_length_key,
- PyInt_FromLong((long) n_members));
+ PyLong_FromLong((long) n_members));
PyDict_SetItemString(dict, unnamed_fields_key,
- PyInt_FromLong((long) n_unnamed_members));
+ PyLong_FromLong((long) n_unnamed_members));
}
Py_ssize_t len = 0;
if (it->it_seq)
len = PyTuple_GET_SIZE(it->it_seq) - it->it_index;
- return PyInt_FromSsize_t(len);
+ return PyLong_FromSsize_t(len);
}
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
res = (*func)(self);
if (res == -1 && PyErr_Occurred())
return NULL;
- return PyInt_FromLong((long)res);
+ return PyLong_FromLong((long)res);
}
static PyObject *
res = (*func)(self, other);
if (PyErr_Occurred())
return NULL;
- return PyInt_FromLong((long)res);
+ return PyLong_FromLong((long)res);
}
/* Helper to check for object.__setattr__ or __delattr__ applied to a type.
res = (*func)(self);
if (res == -1 && PyErr_Occurred())
return NULL;
- return PyInt_FromLong(res);
+ return PyLong_FromLong(res);
}
static PyObject *
if (res == NULL)
return -1;
- len = PyInt_AsSsize_t(res);
+ len = PyLong_AsSsize_t(res);
Py_DECREF(res);
if (len < 0) {
if (!PyErr_Occurred())
return NULL;
}
}
- ival = PyInt_FromSsize_t(i);
+ ival = PyLong_FromSsize_t(i);
if (ival != NULL) {
args = PyTuple_New(1);
if (args != NULL) {
if (res != Py_NotImplemented) {
if (res == NULL)
return -2;
- c = PyInt_AsLong(res);
+ c = PyLong_AsLong(res);
Py_DECREF(res);
if (c == -1 && PyErr_Occurred())
return -2;
if (PyLong_Check(res))
h = PyLong_Type.tp_hash(res);
else
- h = PyInt_AsLong(res);
+ h = PyLong_AsLong(res);
Py_DECREF(res);
if (h == -1 && !PyErr_Occurred())
h = -2;
PyObject *w, *x;
/* Get mapping (char ordinal -> integer, Unicode char or None) */
- w = PyInt_FromLong((long)ch);
+ w = PyLong_FromLong((long)ch);
if (w == NULL)
goto onError;
x = PyObject_GetItem(mapping, w);
}
/* Apply mapping */
- if (PyInt_Check(x)) {
- long value = PyInt_AS_LONG(x);
+ if (PyLong_Check(x)) {
+ long value = PyLong_AS_LONG(x);
if (value < 0 || value > 65535) {
PyErr_SetString(PyExc_TypeError,
"character mapping must be in range(65536)");
encoding_map_size(PyObject *obj, PyObject* args)
{
struct encoding_map *map = (struct encoding_map*)obj;
- return PyInt_FromLong(sizeof(*map) - 1 + 16*map->count2 +
+ return PyLong_FromLong(sizeof(*map) - 1 + 16*map->count2 +
128*map->count3);
}
return NULL;
for (i = 0; i < 256; i++) {
key = value = NULL;
- key = PyInt_FromLong(decode[i]);
- value = PyInt_FromLong(i);
+ key = PyLong_FromLong(decode[i]);
+ value = PyLong_FromLong(i);
if (!key || !value)
goto failed1;
if (PyDict_SetItem(result, key, value) == -1)
error occurred). */
static PyObject *charmapencode_lookup(Py_UNICODE c, PyObject *mapping)
{
- PyObject *w = PyInt_FromLong((long)c);
+ PyObject *w = PyLong_FromLong((long)c);
PyObject *x;
if (w == NULL)
}
else if (x == Py_None)
return x;
- else if (PyInt_Check(x)) {
- long value = PyInt_AS_LONG(x);
+ else if (PyLong_Check(x)) {
+ long value = PyLong_AS_LONG(x);
if (value < 0 || value > 255) {
PyErr_SetString(PyExc_TypeError,
"character mapping must be in range(256)");
Py_DECREF(rep);
return enc_FAILED;
} else {
- if (PyInt_Check(rep)) {
+ if (PyLong_Check(rep)) {
Py_ssize_t requiredsize = *outpos+1;
if (outsize<requiredsize)
if (charmapencode_resize(outobj, outpos, requiredsize)) {
return enc_EXCEPTION;
}
outstart = PyString_AS_STRING(*outobj);
- outstart[(*outpos)++] = (char)PyInt_AS_LONG(rep);
+ outstart[(*outpos)++] = (char)PyLong_AS_LONG(rep);
}
else {
const char *repchars = PyString_AS_STRING(rep);
static
int charmaptranslate_lookup(Py_UNICODE c, PyObject *mapping, PyObject **result)
{
- PyObject *w = PyInt_FromLong((long)c);
+ PyObject *w = PyLong_FromLong((long)c);
PyObject *x;
if (w == NULL)
*result = x;
return 0;
}
- else if (PyInt_Check(x)) {
- long value = PyInt_AS_LONG(x);
+ else if (PyLong_Check(x)) {
+ long value = PyLong_AS_LONG(x);
long max = PyUnicode_GetMax();
if (value < 0 || value > max) {
PyErr_Format(PyExc_TypeError,
}
else if (*res==Py_None)
;
- else if (PyInt_Check(*res)) {
+ else if (PyLong_Check(*res)) {
/* no overflow check, because we know that the space is enough */
- *(*outp)++ = (Py_UNICODE)PyInt_AS_LONG(*res);
+ *(*outp)++ = (Py_UNICODE)PyLong_AS_LONG(*res);
}
else if (PyUnicode_Check(*res)) {
Py_ssize_t repsize = PyUnicode_GET_SIZE(*res);
FIX_START_END(self);
- result = PyInt_FromSsize_t(
+ result = PyLong_FromSsize_t(
stringlib_count(self->str + start, end - start,
substring->str, substring->length)
);
Py_DECREF(substring);
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
static PyObject *
return NULL;
}
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
PyDoc_STRVAR(islower__doc__,
Py_DECREF(substring);
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
PyDoc_STRVAR(rindex__doc__,
PyErr_SetString(PyExc_ValueError, "substring not found");
return NULL;
}
- return PyInt_FromSsize_t(result);
+ return PyLong_FromSsize_t(result);
}
PyDoc_STRVAR(rjust__doc__,
}
/* create entries for translating chars in x to those in y */
for (i = 0; i < PyUnicode_GET_SIZE(x); i++) {
- key = PyInt_FromLong(PyUnicode_AS_UNICODE(x)[i]);
- value = PyInt_FromLong(PyUnicode_AS_UNICODE(y)[i]);
+ key = PyLong_FromLong(PyUnicode_AS_UNICODE(x)[i]);
+ value = PyLong_FromLong(PyUnicode_AS_UNICODE(y)[i]);
if (!key || !value)
goto err;
res = PyDict_SetItem(new, key, value);
/* create entries for deleting chars in z */
if (z != NULL) {
for (i = 0; i < PyUnicode_GET_SIZE(z); i++) {
- key = PyInt_FromLong(PyUnicode_AS_UNICODE(z)[i]);
+ key = PyLong_FromLong(PyUnicode_AS_UNICODE(z)[i]);
if (!key)
goto err;
res = PyDict_SetItem(new, key, Py_None);
"table must be of length 1");
goto err;
}
- newkey = PyInt_FromLong(PyUnicode_AS_UNICODE(key)[0]);
+ newkey = PyLong_FromLong(PyUnicode_AS_UNICODE(key)[0]);
if (!newkey)
goto err;
res = PyDict_SetItem(new, newkey, value);
Py_DECREF(newkey);
if (res < 0)
goto err;
- } else if (PyInt_Check(key)) {
+ } else if (PyLong_Check(key)) {
/* just keep integer keys */
if (PyDict_SetItem(new, key, value) < 0)
goto err;
static PyObject*
unicode_freelistsize(PyUnicodeObject *self)
{
- return PyInt_FromLong(unicode_freelist_size);
+ return PyLong_FromLong(unicode_freelist_size);
}
#endif
char *sign;
long x;
- x = PyInt_AsLong(v);
+ x = PyLong_AsLong(v);
if (x == -1 && PyErr_Occurred())
return -1;
if (x < 0 && type == 'u') {
else {
/* Integer input truncated to a character */
long x;
- x = PyInt_AsLong(v);
+ x = PyLong_AsLong(v);
if (x == -1 && PyErr_Occurred())
goto onError;
#ifdef Py_UNICODE_WIDE
v = getnextarg(args, arglen, &argidx);
if (v == NULL)
goto onError;
- if (!PyInt_Check(v)) {
+ if (!PyLong_Check(v)) {
PyErr_SetString(PyExc_TypeError,
"* wants int");
goto onError;
}
- width = PyInt_AsLong(v);
+ width = PyLong_AsLong(v);
if (width == -1 && PyErr_Occurred())
goto onError;
if (width < 0) {
v = getnextarg(args, arglen, &argidx);
if (v == NULL)
goto onError;
- if (!PyInt_Check(v)) {
+ if (!PyLong_Check(v)) {
PyErr_SetString(PyExc_TypeError,
"* wants int");
goto onError;
}
- prec = PyInt_AsLong(v);
+ prec = PyLong_AsLong(v);
if (prec == -1 && PyErr_Occurred())
goto onError;
if (prec < 0)
Py_ssize_t len = 0;
if (it->it_seq)
len = PyUnicode_GET_SIZE(it->it_seq) - it->it_index;
- return PyInt_FromSsize_t(len);
+ return PyLong_FromSsize_t(len);
}
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
static PyObject*
record_getfieldcount(msiobj* record, PyObject* args)
{
- return PyInt_FromLong(MsiRecordGetFieldCount(record->h));
+ return PyLong_FromLong(MsiRecordGetFieldCount(record->h));
}
static PyObject*
switch(type) {
case VT_I2: case VT_I4:
- return PyInt_FromLong(ival);
+ return PyLong_FromLong(ival);
case VT_FILETIME:
PyErr_SetString(PyExc_NotImplementedError, "FILETIME result");
return NULL;
if (status != ERROR_SUCCESS)
return msierror(status);
- return PyInt_FromLong(result);
+ return PyLong_FromLong(result);
}
static PyObject*
0, NULL, PyString_AsString(data));
} else if (PyInt_CheckExact(data)) {
status = MsiSummaryInfoSetProperty(si->h, field, VT_I4,
- PyInt_AsLong(data), NULL, NULL);
+ PyLong_AsLong(data), NULL, NULL);
} else {
PyErr_SetString(PyExc_TypeError, "unsupported type");
return NULL;
self->handle = NULL;
/* note: return the current handle, as an integer */
- return PyInt_FromLong((long) handle);
+ return PyLong_FromLong((long) handle);
}
static PyObject*
static PyObject*
sp_handle_as_int(sp_handle_object* self)
{
- return PyInt_FromLong((long) self->handle);
+ return PyLong_FromLong((long) self->handle);
}
static PyNumberMethods sp_handle_as_number;
}
/* note: returns integer, not handle object */
- return PyInt_FromLong((long) handle);
+ return PyLong_FromLong((long) handle);
}
static PyObject *
PyErr_Clear(); /* FIXME: propagate error? */
return 0;
}
- ret = (int) PyInt_AsLong(value);
+ ret = (int) PyLong_AsLong(value);
Py_DECREF(value);
return ret;
}
if (! result)
return PyErr_SetFromWindowsErr(GetLastError());
- return PyInt_FromLong(exit_code);
+ return PyLong_FromLong(exit_code);
}
static PyObject *
if (result == WAIT_FAILED)
return PyErr_SetFromWindowsErr(GetLastError());
- return PyInt_FromLong((int) result);
+ return PyLong_FromLong((int) result);
}
static PyObject *
if (! PyArg_ParseTuple(args, ":GetVersion"))
return NULL;
- return PyInt_FromLong((int) GetVersion());
+ return PyLong_FromLong((int) GetVersion());
}
static PyObject *
static void
defint(PyObject* d, const char* name, int value)
{
- PyObject* v = PyInt_FromLong((long) value);
+ PyObject* v = PyLong_FromLong((long) value);
if (v) {
PyDict_SetItemString(d, (char*) name, v);
Py_DECREF(v);
ok = PyHKEY_Close(obHandle);
}
#if SIZEOF_LONG >= SIZEOF_HKEY
- else if (PyInt_Check(obHandle)) {
- long rc = RegCloseKey((HKEY)PyInt_AsLong(obHandle));
+ else if (PyLong_Check(obHandle)) {
+ long rc = RegCloseKey((HKEY)PyLong_AsLong(obHandle));
ok = (rc == ERROR_SUCCESS);
if (!ok)
PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");
switch (typ) {
case REG_DWORD:
if (retDataSize == 0)
- obData = PyInt_FromLong(0);
+ obData = PyLong_FromLong(0);
else
- obData = PyInt_FromLong(*(int *)retDataBuf);
+ obData = PyLong_FromLong(*(int *)retDataBuf);
break;
case REG_SZ:
case REG_EXPAND_SZ:
static void
insint(PyObject * d, char * name, long value)
{
- PyObject *v = PyInt_FromLong(value);
+ PyObject *v = PyLong_FromLong(value);
if (!v || PyDict_SetItemString(d, name, v))
PyErr_Clear();
Py_XDECREF(v);
if (flags == -1)
return PyErr_SetFromErrno(PyExc_IOError);
- return PyInt_FromLong(flags);
+ return PyLong_FromLong(flags);
}
// Convert an OS file handle to a C runtime file descriptor.
if (fd == -1)
return PyErr_SetFromErrno(PyExc_IOError);
- return PyInt_FromLong(fd);
+ return PyLong_FromLong(fd);
}
// Convert a C runtime file descriptor to an OS file handle.
return NULL;
ok = _kbhit();
- return PyInt_FromLong(ok);
+ return PyLong_FromLong(ok);
}
static PyObject *
static void
insertint(PyObject *d, char *name, int value)
{
- PyObject *v = PyInt_FromLong((long) value);
+ PyObject *v = PyLong_FromLong((long) value);
if (v == NULL) {
/* Don't bother reporting this error */
PyErr_Clear();
if (!PyArg_ParseTuple(args, "ii", &type, &file))
return NULL;
res = _CrtSetReportFile(type, (_HFILE)file);
- return PyInt_FromLong((long)res);
+ return PyLong_FromLong((long)res);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject* ast2obj_int(long b)
{
- return PyInt_FromLong(b);
+ return PyLong_FromLong(b);
}
static int init_types(void)
if (!errstr)
return;
Py_INCREF(errstr);
- lineno = PyInt_AsLong(PyTuple_GetItem(value, 1));
+ lineno = PyLong_AsLong(PyTuple_GetItem(value, 1));
if (lineno == -1) {
Py_DECREF(errstr);
return;
if (*end == '\0') {
if (errno != 0)
return PyLong_FromString((char *)s, (char **)0, 0);
- return PyInt_FromLong(x);
+ return PyLong_FromLong(x);
}
/* XXX Huge floats may silently fail */
#ifndef WITHOUT_COMPLEX
return NULL;
if (PyObject_Cmp(a, b, &c) < 0)
return NULL;
- return PyInt_FromLong((long)c);
+ return PyLong_FromLong((long)c);
}
PyDoc_STRVAR(cmp_doc,
x = PyObject_Hash(v);
if (x == -1)
return NULL;
- return PyInt_FromLong(x);
+ return PyLong_FromLong(x);
}
PyDoc_STRVAR(hash_doc,
res = PyObject_Size(v);
if (res < 0 && PyErr_Occurred())
return NULL;
- return PyInt_FromSsize_t(res);
+ return PyLong_FromSsize_t(res);
}
PyDoc_STRVAR(len_doc,
size = PyString_GET_SIZE(obj);
if (size == 1) {
ord = (long)((unsigned char)*PyString_AS_STRING(obj));
- return PyInt_FromLong(ord);
+ return PyLong_FromLong(ord);
}
}
else if (PyUnicode_Check(obj)) {
size = PyUnicode_GET_SIZE(obj);
if (size == 1) {
ord = (long)*PyUnicode_AS_UNICODE(obj);
- return PyInt_FromLong(ord);
+ return PyLong_FromLong(ord);
}
#ifndef Py_UNICODE_WIDE
if (size == 2) {
0xDC00 <= c1 && c1 <= 0xDFFF) {
ord = ((((c0 & 0x03FF) << 10) | (c1 & 0x03FF)) +
0x00010000);
- return PyInt_FromLong(ord);
+ return PyLong_FromLong(ord);
}
}
#endif
size = PyBytes_GET_SIZE(obj);
if (size == 1) {
ord = (long)((unsigned char)*PyBytes_AS_STRING(obj));
- return PyInt_FromLong(ord);
+ return PyLong_FromLong(ord);
}
}
else {
tty = 0;
}
else {
- fd = PyInt_AsLong(tmp);
+ fd = PyLong_AsLong(tmp);
Py_DECREF(tmp);
if (fd < 0 && PyErr_Occurred())
return NULL;
if (tmp == NULL)
PyErr_Clear();
else {
- fd = PyInt_AsLong(tmp);
+ fd = PyLong_AsLong(tmp);
Py_DECREF(tmp);
if (fd < 0 && PyErr_Occurred())
return NULL;
return NULL;
if (result == NULL) {
- result = PyInt_FromLong(0);
+ result = PyLong_FromLong(0);
if (result == NULL) {
Py_DECREF(iter);
return NULL;
to the more general routine.
*/
if (PyInt_CheckExact(result)) {
- long i_result = PyInt_AS_LONG(result);
+ long i_result = PyLong_AS_LONG(result);
Py_DECREF(result);
result = NULL;
while(result == NULL) {
Py_DECREF(iter);
if (PyErr_Occurred())
return NULL;
- return PyInt_FromLong(i_result);
+ return PyLong_FromLong(i_result);
}
if (PyInt_CheckExact(item)) {
- long b = PyInt_AS_LONG(item);
+ long b = PyLong_AS_LONG(item);
long x = i_result + b;
if ((x^i_result) >= 0 || (x^b) >= 0) {
i_result = x;
}
}
/* Either overflowed or is not an int. Restore real objects and process normally */
- result = PyInt_FromLong(i_result);
+ result = PyLong_FromLong(i_result);
temp = PyNumber_Add(result, item);
Py_DECREF(result);
Py_DECREF(item);
}
if (PyInt_CheckExact(item)) {
PyFPE_START_PROTECT("add", return 0)
- f_result += (double)PyInt_AS_LONG(item);
+ f_result += (double)PyLong_AS_LONG(item);
PyFPE_END_PROTECT(f_result)
Py_DECREF(item);
continue;
if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
/* INLINE: int + int */
register long a, b, i;
- a = PyInt_AS_LONG(v);
- b = PyInt_AS_LONG(w);
+ a = PyLong_AS_LONG(v);
+ b = PyLong_AS_LONG(w);
i = a + b;
if ((i^a) < 0 && (i^b) < 0)
goto slow_add;
- x = PyInt_FromLong(i);
+ x = PyLong_FromLong(i);
}
else if (PyUnicode_CheckExact(v) &&
PyUnicode_CheckExact(w)) {
if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
/* INLINE: int - int */
register long a, b, i;
- a = PyInt_AS_LONG(v);
- b = PyInt_AS_LONG(w);
+ a = PyLong_AS_LONG(v);
+ b = PyLong_AS_LONG(w);
i = a - b;
if ((i^a) < 0 && (i^~b) < 0)
goto slow_sub;
- x = PyInt_FromLong(i);
+ x = PyLong_FromLong(i);
}
else {
slow_sub:
v = TOP();
if (PyList_CheckExact(v) && PyInt_CheckExact(w)) {
/* INLINE: list[int] */
- Py_ssize_t i = PyInt_AsSsize_t(w);
+ Py_ssize_t i = PyLong_AsSsize_t(w);
if (i < 0)
i += PyList_GET_SIZE(v);
if (i >= 0 && i < PyList_GET_SIZE(v)) {
if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
/* INLINE: int + int */
register long a, b, i;
- a = PyInt_AS_LONG(v);
- b = PyInt_AS_LONG(w);
+ a = PyLong_AS_LONG(v);
+ b = PyLong_AS_LONG(w);
i = a + b;
if ((i^a) < 0 && (i^b) < 0)
goto slow_iadd;
- x = PyInt_FromLong(i);
+ x = PyLong_FromLong(i);
}
else if (PyUnicode_CheckExact(v) &&
PyUnicode_CheckExact(w)) {
if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
/* INLINE: int - int */
register long a, b, i;
- a = PyInt_AS_LONG(v);
- b = PyInt_AS_LONG(w);
+ a = PyLong_AS_LONG(v);
+ b = PyLong_AS_LONG(w);
i = a - b;
if ((i^a) < 0 && (i^~b) < 0)
goto slow_isub;
- x = PyInt_FromLong(i);
+ x = PyLong_FromLong(i);
}
else {
slow_isub:
case END_FINALLY:
v = POP();
- if (PyInt_Check(v)) {
- why = (enum why_code) PyInt_AS_LONG(v);
+ if (PyLong_Check(v)) {
+ why = (enum why_code) PyLong_AS_LONG(v);
assert(why != WHY_YIELD);
if (why == WHY_RETURN ||
why == WHY_CONTINUE)
/* INLINE: cmp(int, int) */
register long a, b;
register int res;
- a = PyInt_AS_LONG(v);
- b = PyInt_AS_LONG(w);
+ a = PyLong_AS_LONG(v);
+ b = PyLong_AS_LONG(w);
switch (oparg) {
case PyCmp_LT: res = a < b; break;
case PyCmp_LE: res = a <= b; break;
}
v = POP();
u = TOP();
- if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
+ if (PyLong_AsLong(u) != -1 || PyErr_Occurred())
w = PyTuple_Pack(5,
w,
f->f_globals,
goto fast_block_end;
case CONTINUE_LOOP:
- retval = PyInt_FromLong(oparg);
+ retval = PyLong_FromLong(oparg);
if (!retval) {
x = NULL;
break;
x = TOP();
u = SECOND();
- if (PyInt_Check(u) || u == Py_None) {
+ if (PyLong_Check(u) || u == Py_None) {
u = v = w = Py_None;
}
else {
PyFrame_BlockSetup(f, b->b_type, b->b_handler,
b->b_level);
why = WHY_NOT;
- JUMPTO(PyInt_AS_LONG(retval));
+ JUMPTO(PyLong_AS_LONG(retval));
Py_DECREF(retval);
break;
}
else {
if (why & (WHY_RETURN | WHY_CONTINUE))
PUSH(retval);
- v = PyInt_FromLong((long)why);
+ v = PyLong_FromLong((long)why);
PUSH(v);
}
why = WHY_NOT;
if (v != NULL) {
Py_ssize_t x;
if (PyInt_CheckExact(v)) {
- /* XXX(nnorwitz): I think PyInt_AS_LONG is correct,
+ /* XXX(nnorwitz): I think PyLong_AS_LONG is correct,
however, it looks like it should be AsSsize_t.
There should be a comment here explaining why.
*/
- x = PyInt_AS_LONG(v);
+ x = PyLong_AS_LONG(v);
}
else if (PyIndex_Check(v)) {
x = PyNumber_AsSsize_t(v, NULL);
PyObject *l = PyList_New(256);
if (l == NULL) return NULL;
for (i = 0; i < 256; i++) {
- PyObject *x = PyInt_FromLong(a[i]);
+ PyObject *x = PyLong_FromLong(a[i]);
if (x == NULL) {
Py_DECREF(l);
return NULL;
n = PyList_Size(list);
for (i = 0; i < n; i++) {
- v = PyInt_FromLong(i);
+ v = PyLong_FromLong(i);
if (!v) {
Py_DECREF(dict);
return NULL;
while (PyDict_Next(src, &pos, &k, &v)) {
/* XXX this should probably be a macro in symtable.h */
long vi;
- assert(PyInt_Check(v));
- vi = PyInt_AS_LONG(v);
+ assert(PyLong_Check(v));
+ vi = PyLong_AS_LONG(v);
scope = (vi >> SCOPE_OFFSET) & SCOPE_MASK;
if (scope == scope_type || vi & flag) {
- PyObject *tuple, *item = PyInt_FromLong(i);
+ PyObject *tuple, *item = PyLong_FromLong(i);
if (item == NULL) {
Py_DECREF(dest);
return NULL;
if (PyErr_Occurred())
return -1;
arg = PyDict_Size(dict);
- v = PyInt_FromLong(arg);
+ v = PyLong_FromLong(arg);
if (!v) {
Py_DECREF(t);
return -1;
Py_DECREF(v);
}
else
- arg = PyInt_AsLong(v);
+ arg = PyLong_AsLong(v);
Py_DECREF(t);
return arg;
}
Py_DECREF(k);
if (v == NULL)
return -1;
- return PyInt_AS_LONG(v);
+ return PyLong_AS_LONG(v);
}
static int
int r;
PyObject *level;
- level = PyInt_FromLong(0);
+ level = PyLong_FromLong(0);
if (level == NULL)
return 0;
if (!names)
return 0;
- level = PyInt_FromLong(s->v.ImportFrom.level);
+ level = PyLong_FromLong(s->v.ImportFrom.level);
if (!level) {
Py_DECREF(names);
return 0;
if (tuple == NULL)
return NULL;
while (PyDict_Next(dict, &pos, &k, &v)) {
- i = PyInt_AS_LONG(v);
+ i = PyLong_AS_LONG(v);
k = PyTuple_GET_ITEM(k, 0);
Py_INCREF(k);
assert((i - offset) < size);
PyErr_NormalizeException(&exc, &v, &tb);
/* XXX check that it is, indeed, a syntax error. It might not
* be, though. */
- tmp = PyInt_FromLong(lineno);
+ tmp = PyLong_FromLong(lineno);
if (tmp == NULL)
PyErr_Clear();
else {
long ival;
if (float_argument_error(arg))
return converterr("integer<b>", arg, msgbuf, bufsize);
- ival = PyInt_AsLong(arg);
+ ival = PyLong_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<b>", arg, msgbuf, bufsize);
else if (ival < 0) {
long ival;
if (float_argument_error(arg))
return converterr("integer<B>", arg, msgbuf, bufsize);
- ival = PyInt_AsUnsignedLongMask(arg);
+ ival = PyLong_AsUnsignedLongMask(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<B>", arg, msgbuf, bufsize);
else
long ival;
if (float_argument_error(arg))
return converterr("integer<h>", arg, msgbuf, bufsize);
- ival = PyInt_AsLong(arg);
+ ival = PyLong_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<h>", arg, msgbuf, bufsize);
else if (ival < SHRT_MIN) {
long ival;
if (float_argument_error(arg))
return converterr("integer<H>", arg, msgbuf, bufsize);
- ival = PyInt_AsUnsignedLongMask(arg);
+ ival = PyLong_AsUnsignedLongMask(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<H>", arg, msgbuf, bufsize);
else
long ival;
if (float_argument_error(arg))
return converterr("integer<i>", arg, msgbuf, bufsize);
- ival = PyInt_AsLong(arg);
+ ival = PyLong_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<i>", arg, msgbuf, bufsize);
else if (ival > INT_MAX) {
unsigned int ival;
if (float_argument_error(arg))
return converterr("integer<I>", arg, msgbuf, bufsize);
- ival = (unsigned int)PyInt_AsUnsignedLongMask(arg);
+ ival = (unsigned int)PyLong_AsUnsignedLongMask(arg);
if (ival == (unsigned int)-1 && PyErr_Occurred())
return converterr("integer<I>", arg, msgbuf, bufsize);
else
return converterr("integer<n>", arg, msgbuf, bufsize);
iobj = PyNumber_Index(arg);
if (iobj != NULL)
- ival = PyInt_AsSsize_t(arg);
+ ival = PyLong_AsSsize_t(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<n>", arg, msgbuf, bufsize);
*p = ival;
long ival;
if (float_argument_error(arg))
return converterr("integer<l>", arg, msgbuf, bufsize);
- ival = PyInt_AsLong(arg);
+ ival = PyLong_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<l>", arg, msgbuf, bufsize);
else
char *name;
if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
return NULL;
- return PyInt_FromLong(is_builtin(name));
+ return PyLong_FromLong(is_builtin(name));
}
static PyObject *
PyObject *v;
int err;
- v = PyInt_FromLong((long)value);
+ v = PyLong_FromLong((long)value);
err = PyDict_SetItemString(d, name, v);
Py_XDECREF(v);
return err;
int
PyMac_Getwide(PyObject *v, wide *rv)
{
- if (PyInt_Check(v)) {
+ if (PyLong_Check(v)) {
rv->hi = 0;
- rv->lo = PyInt_AsLong(v);
+ rv->lo = PyLong_AsLong(v);
if( rv->lo & 0x80000000 )
rv->hi = -1;
return 1;
{
if ( (w->hi == 0 && (w->lo & 0x80000000) == 0) ||
(w->hi == -1 && (w->lo & 0x80000000) ) )
- return PyInt_FromLong(w->lo);
+ return PyLong_FromLong(w->lo);
return Py_BuildValue("(ll)", w->hi, w->lo);
}
long hi4 = r_long(p);
#if SIZEOF_LONG > 4
long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);
- return PyInt_FromLong(x);
+ return PyLong_FromLong(x);
#else
unsigned char buf[8];
int one = 1;
break;
case TYPE_INT:
- retval = PyInt_FromLong(r_long(p));
+ retval = PyLong_FromLong(r_long(p));
break;
case TYPE_INT64:
case 'B':
case 'h':
case 'i':
- return PyInt_FromLong((long)va_arg(*p_va, int));
+ return PyLong_FromLong((long)va_arg(*p_va, int));
case 'H':
- return PyInt_FromLong((long)va_arg(*p_va, unsigned int));
+ return PyLong_FromLong((long)va_arg(*p_va, unsigned int));
case 'I':
{
if (n > (unsigned long)PyInt_GetMax())
return PyLong_FromUnsignedLong((unsigned long)n);
else
- return PyInt_FromLong(n);
+ return PyLong_FromLong(n);
}
case 'n':
#if SIZEOF_SIZE_T!=SIZEOF_LONG
- return PyInt_FromSsize_t(va_arg(*p_va, Py_ssize_t));
+ return PyLong_FromSsize_t(va_arg(*p_va, Py_ssize_t));
#endif
/* Fall through from 'n' to 'l' if Py_ssize_t is long */
case 'l':
- return PyInt_FromLong(va_arg(*p_va, long));
+ return PyLong_FromLong(va_arg(*p_va, long));
case 'k':
{
if (n > (unsigned long)PyInt_GetMax())
return PyLong_FromUnsignedLong(n);
else
- return PyInt_FromLong(n);
+ return PyLong_FromLong(n);
}
#ifdef HAVE_LONG_LONG
int
PyModule_AddIntConstant(PyObject *m, const char *name, long value)
{
- return PyModule_AddObject(m, name, PyInt_FromLong(value));
+ return PyModule_AddObject(m, name, PyLong_FromLong(value));
}
int
struct _frame *frame = t->frame;
if (frame == NULL)
continue;
- id = PyInt_FromLong(t->thread_id);
+ id = PyLong_FromLong(t->thread_id);
if (id == NULL)
goto Fail;
stat = PyDict_SetItem(result, id, (PyObject *)frame);
Py_DECREF(v);
if (!(v = PyObject_GetAttrString(err, "lineno")))
goto finally;
- hold = PyInt_AsLong(v);
+ hold = PyLong_AsLong(v);
Py_DECREF(v);
v = NULL;
if (hold < 0 && PyErr_Occurred())
Py_DECREF(v);
v = NULL;
} else {
- hold = PyInt_AsLong(v);
+ hold = PyLong_AsLong(v);
Py_DECREF(v);
v = NULL;
if (hold < 0 && PyErr_Occurred())
/* If we failed to dig out the 'code' attribute,
just let the else clause below print the error. */
}
- if (PyInt_Check(value))
- exitcode = (int)PyInt_AsLong(value);
+ if (PyLong_Check(value))
+ exitcode = (int)PyLong_AsLong(value);
else {
PyObject_Print(value, stderr, Py_PRINT_RAW);
PySys_WriteStderr("\n");
addr += l->offset;
switch (l->type) {
case T_BYTE:
- v = PyInt_FromLong(*(char*)addr);
+ v = PyLong_FromLong(*(char*)addr);
break;
case T_UBYTE:
v = PyLong_FromUnsignedLong(*(unsigned char*)addr);
break;
case T_SHORT:
- v = PyInt_FromLong(*(short*)addr);
+ v = PyLong_FromLong(*(short*)addr);
break;
case T_USHORT:
v = PyLong_FromUnsignedLong(*(unsigned short*)addr);
break;
case T_INT:
- v = PyInt_FromLong(*(int*)addr);
+ v = PyLong_FromLong(*(int*)addr);
break;
case T_UINT:
v = PyLong_FromUnsignedLong(*(unsigned int*)addr);
break;
case T_LONG:
- v = PyInt_FromLong(*(long*)addr);
+ v = PyLong_FromLong(*(long*)addr);
break;
case T_ULONG:
v = PyLong_FromUnsignedLong(*(unsigned long*)addr);
break;
case T_PYSSIZET:
- v = PyInt_FromSsize_t(*(Py_ssize_t*)addr);
+ v = PyLong_FromSsize_t(*(Py_ssize_t*)addr);
break;
case T_FLOAT:
v = PyFloat_FromDouble((double)*(float*)addr);
addr += l->offset;
switch (l->type) {
case T_BYTE:{
- long long_val = PyInt_AsLong(v);
+ long long_val = PyLong_AsLong(v);
if ((long_val == -1) && PyErr_Occurred())
return -1;
*(char*)addr = (char)long_val;
break;
}
case T_UBYTE:{
- long long_val = PyInt_AsLong(v);
+ long long_val = PyLong_AsLong(v);
if ((long_val == -1) && PyErr_Occurred())
return -1;
*(unsigned char*)addr = (unsigned char)long_val;
break;
}
case T_SHORT:{
- long long_val = PyInt_AsLong(v);
+ long long_val = PyLong_AsLong(v);
if ((long_val == -1) && PyErr_Occurred())
return -1;
*(short*)addr = (short)long_val;
break;
}
case T_USHORT:{
- long long_val = PyInt_AsLong(v);
+ long long_val = PyLong_AsLong(v);
if ((long_val == -1) && PyErr_Occurred())
return -1;
*(unsigned short*)addr = (unsigned short)long_val;
break;
}
case T_INT:{
- long long_val = PyInt_AsLong(v);
+ long long_val = PyLong_AsLong(v);
if ((long_val == -1) && PyErr_Occurred())
return -1;
*(int *)addr = (int)long_val;
break;
}
case T_PYSSIZET:{
- *(Py_ssize_t*)addr = PyInt_AsSsize_t(v);
+ *(Py_ssize_t*)addr = PyLong_AsSsize_t(v);
if ((*(Py_ssize_t*)addr == (Py_ssize_t)-1)
&& PyErr_Occurred())
return -1;
if (PyLong_Check(v))
*(unsigned PY_LONG_LONG*)addr = value = PyLong_AsUnsignedLongLong(v);
else
- *(unsigned PY_LONG_LONG*)addr = value = PyInt_AsLong(v);
+ *(unsigned PY_LONG_LONG*)addr = value = PyLong_AsLong(v);
if ((value == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())
return -1;
break;
{
return PyUnicode_FromFormat("<symtable entry %U(%ld), line %d>",
ste->ste_name,
- PyInt_AS_LONG(ste->ste_id), ste->ste_lineno);
+ PyLong_AS_LONG(ste->ste_id), ste->ste_lineno);
}
static void
PyObject *v = PyDict_GetItem(ste->ste_symbols, name);
if (!v)
return 0;
- assert(PyInt_Check(v));
- return (PyInt_AS_LONG(v) >> SCOPE_OFFSET) & SCOPE_MASK;
+ assert(PyLong_Check(v));
+ return (PyLong_AS_LONG(v) >> SCOPE_OFFSET) & SCOPE_MASK;
}
*/
#define SET_SCOPE(DICT, NAME, I) { \
- PyObject *o = PyInt_FromLong(I); \
+ PyObject *o = PyLong_FromLong(I); \
if (!o) \
return 0; \
if (PyDict_SetItem((DICT), (NAME), o) < 0) { \
int success = 0;
Py_ssize_t pos = 0;
- v_cell = PyInt_FromLong(CELL);
+ v_cell = PyLong_FromLong(CELL);
if (!v_cell)
return 0;
while (PyDict_Next(scopes, &pos, &name, &v)) {
long scope;
- assert(PyInt_Check(v));
- scope = PyInt_AS_LONG(v);
+ assert(PyLong_Check(v));
+ scope = PyLong_AS_LONG(v);
if (scope != LOCAL)
continue;
if (!PySet_Contains(free, name))
/* Update scope information for all symbols in this scope */
while (PyDict_Next(symbols, &pos, &name, &v)) {
long scope, flags;
- assert(PyInt_Check(v));
- flags = PyInt_AS_LONG(v);
+ assert(PyLong_Check(v));
+ flags = PyLong_AS_LONG(v);
v_scope = PyDict_GetItem(scopes, name);
- assert(v_scope && PyInt_Check(v_scope));
- scope = PyInt_AS_LONG(v_scope);
+ assert(v_scope && PyLong_Check(v_scope));
+ scope = PyLong_AS_LONG(v_scope);
flags |= (scope << SCOPE_OFFSET);
- v_new = PyInt_FromLong(flags);
+ v_new = PyLong_FromLong(flags);
if (!v_new)
return 0;
if (PyDict_SetItem(symbols, name, v_new) < 0) {
}
/* Record not yet resolved free variables from children (if any) */
- v_free = PyInt_FromLong(FREE << SCOPE_OFFSET);
+ v_free = PyLong_FromLong(FREE << SCOPE_OFFSET);
if (!v_free)
return 0;
or global in the class scope.
*/
if (classflag &&
- PyInt_AS_LONG(v) & (DEF_BOUND | DEF_GLOBAL)) {
- long flags = PyInt_AS_LONG(v) | DEF_FREE_CLASS;
- v_new = PyInt_FromLong(flags);
+ PyLong_AS_LONG(v) & (DEF_BOUND | DEF_GLOBAL)) {
+ long flags = PyLong_AS_LONG(v) | DEF_FREE_CLASS;
+ v_new = PyLong_FromLong(flags);
if (!v_new) {
goto error;
}
assert(PySTEntry_Check(ste));
assert(PyDict_Check(ste->ste_symbols));
while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) {
- long flags = PyInt_AS_LONG(v);
+ long flags = PyLong_AS_LONG(v);
if (!analyze_name(ste, scopes, name, flags, bound, local, free,
global))
goto error;
Py_DECREF(mangled);
if (!o)
return 0;
- return PyInt_AsLong(o);
+ return PyLong_AsLong(o);
}
static int
return 0;
dict = st->st_cur->ste_symbols;
if ((o = PyDict_GetItem(dict, mangled))) {
- val = PyInt_AS_LONG(o);
+ val = PyLong_AS_LONG(o);
if ((flag & DEF_PARAM) && (val & DEF_PARAM)) {
/* Is it better to use 'mangled' or 'name' here? */
PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT, name);
val |= flag;
} else
val = flag;
- o = PyInt_FromLong(val);
+ o = PyLong_FromLong(val);
if (o == NULL)
goto error;
if (PyDict_SetItem(dict, mangled, o) < 0) {
perhaps only DEF_FREE_GLOBAL */
val = flag;
if ((o = PyDict_GetItem(st->st_global, mangled))) {
- val |= PyInt_AS_LONG(o);
+ val |= PyLong_AS_LONG(o);
}
- o = PyInt_FromLong(val);
+ o = PyLong_FromLong(val);
if (o == NULL)
goto error;
if (PyDict_SetItem(st->st_global, mangled, o) < 0) {
static PyObject *
sys_getcheckinterval(PyObject *self, PyObject *args)
{
- return PyInt_FromLong(_Py_CheckInterval);
+ return PyLong_FromLong(_Py_CheckInterval);
}
PyDoc_STRVAR(getcheckinterval_doc,
static PyObject *
sys_getrecursionlimit(PyObject *self)
{
- return PyInt_FromLong(Py_GetRecursionLimit());
+ return PyLong_FromLong(Py_GetRecursionLimit());
}
PyDoc_STRVAR(getrecursionlimit_doc,
PyThreadState *tstate = PyThreadState_GET();
if (!tstate)
return NULL;
- return PyInt_FromLong(tstate->interp->dlopenflags);
+ return PyLong_FromLong(tstate->interp->dlopenflags);
}
PyDoc_STRVAR(getdlopenflags_doc,
static PyObject *
sys_getrefcount(PyObject *self, PyObject *arg)
{
- return PyInt_FromSsize_t(arg->ob_refcnt);
+ return PyLong_FromSsize_t(arg->ob_refcnt);
}
#ifdef Py_REF_DEBUG
static PyObject *
sys_gettotalrefcount(PyObject *self)
{
- return PyInt_FromSsize_t(_Py_GetRefTotal());
+ return PyLong_FromSsize_t(_Py_GetRefTotal());
}
#endif /* Py_REF_DEBUG */
v = PyUnicode_FromString(Py_GetVersion()));
Py_XDECREF(v);
PyDict_SetItemString(sysdict, "hexversion",
- v = PyInt_FromLong(PY_VERSION_HEX));
+ v = PyLong_FromLong(PY_VERSION_HEX));
Py_XDECREF(v);
svnversion_init();
v = Py_BuildValue("(UUU)", "CPython", branch, svn_revision);
PY_MICRO_VERSION, s,
PY_RELEASE_SERIAL));
SET_SYS_FROM_STRING("api_version",
- PyInt_FromLong(PYTHON_API_VERSION));
+ PyLong_FromLong(PYTHON_API_VERSION));
SET_SYS_FROM_STRING("copyright",
PyUnicode_FromString(Py_GetCopyright()));
SET_SYS_FROM_STRING("platform",
SET_SYS_FROM_STRING("exec_prefix",
PyUnicode_DecodeFSDefault(Py_GetExecPrefix()));
SET_SYS_FROM_STRING("maxint",
- PyInt_FromLong(PyInt_GetMax()));
+ PyLong_FromLong(PyInt_GetMax()));
SET_SYS_FROM_STRING("maxsize",
- PyInt_FromSsize_t(PY_SSIZE_T_MAX));
+ PyLong_FromSsize_t(PY_SSIZE_T_MAX));
SET_SYS_FROM_STRING("float_info",
PyFloat_GetInfo());
SET_SYS_FROM_STRING("maxunicode",
- PyInt_FromLong(PyUnicode_GetMax()));
+ PyLong_FromLong(PyUnicode_GetMax()));
SET_SYS_FROM_STRING("builtin_module_names",
list_builtin_module_names());
{
}
limitv = PySys_GetObject("tracebacklimit");
if (limitv && PyInt_CheckExact(limitv)) {
- limit = PyInt_AsLong(limitv);
+ limit = PyLong_AsLong(limitv);
if (limit <= 0)
return 0;
}
projects / thirdparty / Python / cpython.git / commitdiff
