0-terminated (passing a string with embedded NULL characters will
cause an exception). */
PyAPI_FUNC(int) PyBytes_AsStringAndSize(
- register PyObject *obj, /* string or Unicode object */
- register char **s, /* pointer to buffer variable */
- register Py_ssize_t *len /* pointer to length variable or NULL
- (only possible for 0-terminated
- strings) */
+ PyObject *obj, /* string or Unicode object */
+ char **s, /* pointer to buffer variable */
+ Py_ssize_t *len /* pointer to length variable or NULL
+ (only possible for 0-terminated
+ strings) */
);
/* Using the current locale, insert the thousands grouping
*/
PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject(
- register PyObject *obj, /* Object */
+ PyObject *obj, /* Object */
const char *encoding, /* encoding */
const char *errors /* error handling */
);
*/
PyAPI_FUNC(PyObject*) PyUnicode_FromObject(
- register PyObject *obj /* Object */
+ PyObject *obj /* Object */
);
PyAPI_FUNC(PyObject *) PyUnicode_FromFormatV(
The buffer is copied into the new object. */
PyAPI_FUNC(PyObject*) PyUnicode_FromWideChar(
- register const wchar_t *w, /* wchar_t buffer */
+ const wchar_t *w, /* wchar_t buffer */
Py_ssize_t size /* size of buffer */
);
PyAPI_FUNC(Py_ssize_t) PyUnicode_AsWideChar(
PyObject *unicode, /* Unicode object */
- register wchar_t *w, /* wchar_t buffer */
+ wchar_t *w, /* wchar_t buffer */
Py_ssize_t size /* size of buffer */
);
Core and Builtins
-----------------
+- Issue #18722: Remove uses of the "register" keyword in C code.
+
- Issue #18667: Add missing "HAVE_FCHOWNAT" symbol to posix._have_functions.
- Issue #16499: Add command line option for isolated mode.
return NULL;
}
else {
- register Py_ssize_t i;
- register char c;
- register char *p = PyBytes_AS_STRING(v);
+ Py_ssize_t i;
+ char c;
+ char *p = PyBytes_AS_STRING(v);
for (i = 0; i < size; i++) {
/* There's at least enough room for a hex escape */
/* Methods */
static void
-dbm_dealloc(register dbmobject *dp)
+dbm_dealloc(dbmobject *dp)
{
if ( dp->di_dbm )
dbm_close(dp->di_dbm);
}
static PyObject *
-dbm_subscript(dbmobject *dp, register PyObject *key)
+dbm_subscript(dbmobject *dp, PyObject *key)
{
datum drec, krec;
Py_ssize_t tmp_size;
};
static PyObject *
-dbm__close(register dbmobject *dp, PyObject *unused)
+dbm__close(dbmobject *dp, PyObject *unused)
{
if (dp->di_dbm)
dbm_close(dp->di_dbm);
}
static PyObject *
-dbm_keys(register dbmobject *dp, PyObject *unused)
+dbm_keys(dbmobject *dp, PyObject *unused)
{
- register PyObject *v, *item;
+ PyObject *v, *item;
datum key;
int err;
};
static PyObject *
-dbm_get(register dbmobject *dp, PyObject *args)
+dbm_get(dbmobject *dp, PyObject *args)
{
datum key, val;
PyObject *defvalue = Py_None;
}
static PyObject *
-dbm_setdefault(register dbmobject *dp, PyObject *args)
+dbm_setdefault(dbmobject *dp, PyObject *args)
{
datum key, val;
PyObject *defvalue = NULL;
/* Methods */
static void
-dbm_dealloc(register dbmobject *dp)
+dbm_dealloc(dbmobject *dp)
{
if (dp->di_dbm)
gdbm_close(dp->di_dbm);
}
static PyObject *
-dbm_subscript(dbmobject *dp, register PyObject *key)
+dbm_subscript(dbmobject *dp, PyObject *key)
{
PyObject *v;
datum drec, krec;
Closes the database.");
static PyObject *
-dbm_close(register dbmobject *dp, PyObject *unused)
+dbm_close(dbmobject *dp, PyObject *unused)
{
if (dp->di_dbm)
gdbm_close(dp->di_dbm);
Get a list of all keys in the database.");
static PyObject *
-dbm_keys(register dbmobject *dp, PyObject *unused)
+dbm_keys(dbmobject *dp, PyObject *unused)
{
- register PyObject *v, *item;
+ PyObject *v, *item;
datum key, nextkey;
int err;
returns the starting key.");
static PyObject *
-dbm_firstkey(register dbmobject *dp, PyObject *unused)
+dbm_firstkey(dbmobject *dp, PyObject *unused)
{
- register PyObject *v;
+ PyObject *v;
datum key;
check_dbmobject_open(dp);
k = db.nextkey(k)");
static PyObject *
-dbm_nextkey(register dbmobject *dp, PyObject *args)
+dbm_nextkey(dbmobject *dp, PyObject *args)
{
- register PyObject *v;
+ PyObject *v;
datum key, nextkey;
if (!PyArg_ParseTuple(args, "s#:nextkey", &key.dptr, &key.dsize))
kept and reused as new (key,value) pairs are added.");
static PyObject *
-dbm_reorganize(register dbmobject *dp, PyObject *unused)
+dbm_reorganize(dbmobject *dp, PyObject *unused)
{
check_dbmobject_open(dp);
errno = 0;
any unwritten data to be written to the disk.");
static PyObject *
-dbm_sync(register dbmobject *dp, PyObject *unused)
+dbm_sync(dbmobject *dp, PyObject *unused)
{
check_dbmobject_open(dp);
gdbm_sync(dp->di_dbm);
static PyObject *
getarrayitem(PyObject *op, Py_ssize_t i)
{
- register arrayobject *ap;
+ arrayobject *ap;
assert(array_Check(op));
ap = (arrayobject *)op;
assert(i>=0 && i<Py_SIZE(ap));
static PyObject *
array_reverse(arrayobject *self, PyObject *unused)
{
- register Py_ssize_t itemsize = self->ob_descr->itemsize;
- register char *p, *q;
+ Py_ssize_t itemsize = self->ob_descr->itemsize;
+ char *p, *q;
/* little buffer to hold items while swapping */
char tmp[256]; /* 8 is probably enough -- but why skimp */
assert((size_t)itemsize <= sizeof(tmp));
/* 15 == strlen(quote_prefix) + 2 + strlen(quote_postfix) + 1 */
size_t newsize;
PyObject *v;
- register Py_ssize_t i;
- register char c;
- register char *p;
+ Py_ssize_t i;
+ char c;
+ char *p;
int quote;
char *test, *start;
char *buffer;
static PyObject *
bytearray_translate(PyByteArrayObject *self, PyObject *args)
{
- register char *input, *output;
- register const char *table;
- register Py_ssize_t i, c;
+ char *input, *output;
+ const char *table;
+ Py_ssize_t i, c;
PyObject *input_obj = (PyObject*)self;
const char *output_start;
Py_ssize_t inlen;
PyObject*
_Py_bytes_isspace(const char *cptr, Py_ssize_t len)
{
- register const unsigned char *p
+ const unsigned char *p
= (unsigned char *) cptr;
- register const unsigned char *e;
+ const unsigned char *e;
/* Shortcut for single character strings */
if (len == 1 && Py_ISSPACE(*p))
PyObject*
_Py_bytes_isalpha(const char *cptr, Py_ssize_t len)
{
- register const unsigned char *p
+ const unsigned char *p
= (unsigned char *) cptr;
- register const unsigned char *e;
+ const unsigned char *e;
/* Shortcut for single character strings */
if (len == 1 && Py_ISALPHA(*p))
PyObject*
_Py_bytes_isalnum(const char *cptr, Py_ssize_t len)
{
- register const unsigned char *p
+ const unsigned char *p
= (unsigned char *) cptr;
- register const unsigned char *e;
+ const unsigned char *e;
/* Shortcut for single character strings */
if (len == 1 && Py_ISALNUM(*p))
PyObject*
_Py_bytes_isdigit(const char *cptr, Py_ssize_t len)
{
- register const unsigned char *p
+ const unsigned char *p
= (unsigned char *) cptr;
- register const unsigned char *e;
+ const unsigned char *e;
/* Shortcut for single character strings */
if (len == 1 && Py_ISDIGIT(*p))
PyObject*
_Py_bytes_islower(const char *cptr, Py_ssize_t len)
{
- register const unsigned char *p
+ const unsigned char *p
= (unsigned char *) cptr;
- register const unsigned char *e;
+ const unsigned char *e;
int cased;
/* Shortcut for single character strings */
PyObject*
_Py_bytes_isupper(const char *cptr, Py_ssize_t len)
{
- register const unsigned char *p
+ const unsigned char *p
= (unsigned char *) cptr;
- register const unsigned char *e;
+ const unsigned char *e;
int cased;
/* Shortcut for single character strings */
PyObject*
_Py_bytes_istitle(const char *cptr, Py_ssize_t len)
{
- register const unsigned char *p
+ const unsigned char *p
= (unsigned char *) cptr;
- register const unsigned char *e;
+ const unsigned char *e;
int cased, previous_is_cased;
/* Shortcut for single character strings */
cased = 0;
previous_is_cased = 0;
for (; p < e; p++) {
- register const unsigned char ch = *p;
+ const unsigned char ch = *p;
if (Py_ISUPPER(ch)) {
if (previous_is_cased)
PyObject *
PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)
{
- register PyBytesObject *op;
+ PyBytesObject *op;
if (size < 0) {
PyErr_SetString(PyExc_SystemError,
"Negative size passed to PyBytes_FromStringAndSize");
PyObject *
PyBytes_FromString(const char *str)
{
- register size_t size;
- register PyBytesObject *op;
+ size_t size;
+ PyBytesObject *op;
assert(str != NULL);
size = strlen(str);
/* object api */
Py_ssize_t
-PyBytes_Size(register PyObject *op)
+PyBytes_Size(PyObject *op)
{
if (!PyBytes_Check(op)) {
PyErr_Format(PyExc_TypeError,
}
char *
-PyBytes_AsString(register PyObject *op)
+PyBytes_AsString(PyObject *op)
{
if (!PyBytes_Check(op)) {
PyErr_Format(PyExc_TypeError,
}
int
-PyBytes_AsStringAndSize(register PyObject *obj,
- register char **s,
- register Py_ssize_t *len)
+PyBytes_AsStringAndSize(PyObject *obj,
+ char **s,
+ Py_ssize_t *len)
{
if (s == NULL) {
PyErr_BadInternalCall();
PyObject *
PyBytes_Repr(PyObject *obj, int smartquotes)
{
- register PyBytesObject* op = (PyBytesObject*) obj;
+ PyBytesObject* op = (PyBytesObject*) obj;
Py_ssize_t i, length = Py_SIZE(op);
size_t newsize, squotes, dquotes;
PyObject *v;
}
static PyObject *
-bytes_repeat(register PyBytesObject *a, register Py_ssize_t n)
+bytes_repeat(PyBytesObject *a, Py_ssize_t n)
{
- register Py_ssize_t i;
- register Py_ssize_t j;
- register Py_ssize_t size;
- register PyBytesObject *op;
+ Py_ssize_t i;
+ Py_ssize_t j;
+ Py_ssize_t size;
+ PyBytesObject *op;
size_t nbytes;
if (n < 0)
n = 0;
}
static PyObject *
-bytes_item(PyBytesObject *a, register Py_ssize_t i)
+bytes_item(PyBytesObject *a, Py_ssize_t i)
{
if (i < 0 || i >= Py_SIZE(a)) {
PyErr_SetString(PyExc_IndexError, "index out of range");
static PyObject *
bytes_translate(PyBytesObject *self, PyObject *args)
{
- register char *input, *output;
+ char *input, *output;
const char *table;
- register Py_ssize_t i, c, changed = 0;
+ Py_ssize_t i, c, changed = 0;
PyObject *input_obj = (PyObject*)self;
const char *output_start, *del_table=NULL;
Py_ssize_t inlen, tablen, dellen = 0;
};
void
-PyBytes_Concat(register PyObject **pv, register PyObject *w)
+PyBytes_Concat(PyObject **pv, PyObject *w)
{
- register PyObject *v;
+ PyObject *v;
assert(pv != NULL);
if (*pv == NULL)
return;
}
void
-PyBytes_ConcatAndDel(register PyObject **pv, register PyObject *w)
+PyBytes_ConcatAndDel(PyObject **pv, PyObject *w)
{
PyBytes_Concat(pv, w);
Py_XDECREF(w);
int
_PyBytes_Resize(PyObject **pv, Py_ssize_t newsize)
{
- register PyObject *v;
- register PyBytesObject *sv;
+ PyObject *v;
+ PyBytesObject *sv;
v = *pv;
if (!PyBytes_Check(v) || Py_REFCNT(v) != 1 || newsize < 0) {
*pv = 0;
PyObject *
PyMethod_New(PyObject *func, PyObject *self)
{
- register PyMethodObject *im;
+ PyMethodObject *im;
if (self == NULL) {
PyErr_BadInternalCall();
return NULL;
}
static void
-method_dealloc(register PyMethodObject *im)
+method_dealloc(PyMethodObject *im)
{
_PyObject_GC_UNTRACK(im);
if (im->im_weakreflist != NULL)
static PyObject *
instancemethod_descr_get(PyObject *descr, PyObject *obj, PyObject *type) {
- register PyObject *func = PyInstanceMethod_GET_FUNCTION(descr);
+ PyObject *func = PyInstanceMethod_GET_FUNCTION(descr);
if (obj == NULL) {
Py_INCREF(func);
return func;
PyObject *
PyComplex_FromCComplex(Py_complex cval)
{
- register PyComplexObject *op;
+ PyComplexObject *op;
/* Inline PyObject_New */
op = (PyComplexObject *) PyObject_MALLOC(sizeof(PyComplexObject));
lookdict(PyDictObject *mp, PyObject *key,
Py_hash_t hash, PyObject ***value_addr)
{
- register size_t i;
- register size_t perturb;
- register PyDictKeyEntry *freeslot;
- register size_t mask;
+ size_t i;
+ size_t perturb;
+ PyDictKeyEntry *freeslot;
+ size_t mask;
PyDictKeyEntry *ep0;
- register PyDictKeyEntry *ep;
- register int cmp;
+ PyDictKeyEntry *ep;
+ int cmp;
PyObject *startkey;
top:
lookdict_unicode(PyDictObject *mp, PyObject *key,
Py_hash_t hash, PyObject ***value_addr)
{
- register size_t i;
- register size_t perturb;
- register PyDictKeyEntry *freeslot;
- register size_t mask = DK_MASK(mp->ma_keys);
+ size_t i;
+ size_t perturb;
+ PyDictKeyEntry *freeslot;
+ size_t mask = DK_MASK(mp->ma_keys);
PyDictKeyEntry *ep0 = &mp->ma_keys->dk_entries[0];
- register PyDictKeyEntry *ep;
+ PyDictKeyEntry *ep;
/* Make sure this function doesn't have to handle non-unicode keys,
including subclasses of str; e.g., one reason to subclass
lookdict_unicode_nodummy(PyDictObject *mp, PyObject *key,
Py_hash_t hash, PyObject ***value_addr)
{
- register size_t i;
- register size_t perturb;
- register size_t mask = DK_MASK(mp->ma_keys);
+ size_t i;
+ size_t perturb;
+ size_t mask = DK_MASK(mp->ma_keys);
PyDictKeyEntry *ep0 = &mp->ma_keys->dk_entries[0];
- register PyDictKeyEntry *ep;
+ PyDictKeyEntry *ep;
/* Make sure this function doesn't have to handle non-unicode keys,
including subclasses of str; e.g., one reason to subclass
lookdict_split(PyDictObject *mp, PyObject *key,
Py_hash_t hash, PyObject ***value_addr)
{
- register size_t i;
- register size_t perturb;
- register size_t mask = DK_MASK(mp->ma_keys);
+ size_t i;
+ size_t perturb;
+ size_t mask = DK_MASK(mp->ma_keys);
PyDictKeyEntry *ep0 = &mp->ma_keys->dk_entries[0];
- register PyDictKeyEntry *ep;
+ PyDictKeyEntry *ep;
if (!PyUnicode_CheckExact(key)) {
ep = lookdict(mp, key, hash, value_addr);
}
static PyObject *
-dict_subscript(PyDictObject *mp, register PyObject *key)
+dict_subscript(PyDictObject *mp, PyObject *key)
{
PyObject *v;
Py_hash_t hash;
};
static PyObject *
-dict_keys(register PyDictObject *mp)
+dict_keys(PyDictObject *mp)
{
- register PyObject *v;
- register Py_ssize_t i, j;
+ PyObject *v;
+ Py_ssize_t i, j;
PyDictKeyEntry *ep;
Py_ssize_t size, n, offset;
PyObject **value_ptr;
}
static PyObject *
-dict_values(register PyDictObject *mp)
+dict_values(PyDictObject *mp)
{
- register PyObject *v;
- register Py_ssize_t i, j;
+ PyObject *v;
+ Py_ssize_t i, j;
Py_ssize_t size, n, offset;
PyObject **value_ptr;
}
static PyObject *
-dict_items(register PyDictObject *mp)
+dict_items(PyDictObject *mp)
{
- register PyObject *v;
- register Py_ssize_t i, j, n;
+ PyObject *v;
+ Py_ssize_t i, j, n;
Py_ssize_t size, offset;
PyObject *item, *key;
PyDictKeyEntry *ep;
int
PyDict_Merge(PyObject *a, PyObject *b, int override)
{
- register PyDictObject *mp, *other;
- register Py_ssize_t i, n;
+ PyDictObject *mp, *other;
+ Py_ssize_t i, n;
PyDictKeyEntry *entry;
/* We accept for the argument either a concrete dictionary object,
}
static PyObject *
-dict_copy(register PyDictObject *mp)
+dict_copy(PyDictObject *mp)
{
return PyDict_Copy((PyObject*)mp);
}
}
static PyObject *
-dict_contains(register PyDictObject *mp, PyObject *key)
+dict_contains(PyDictObject *mp, PyObject *key)
{
Py_hash_t hash;
PyDictKeyEntry *ep;
}
static PyObject *
-dict_get(register PyDictObject *mp, PyObject *args)
+dict_get(PyDictObject *mp, PyObject *args)
{
PyObject *key;
PyObject *failobj = Py_None;
}
static PyObject *
-dict_clear(register PyDictObject *mp)
+dict_clear(PyDictObject *mp)
{
PyDict_Clear((PyObject *)mp);
Py_RETURN_NONE;
static PyObject *dictiter_iternextkey(dictiterobject *di)
{
PyObject *key;
- register Py_ssize_t i, mask, offset;
- register PyDictKeysObject *k;
+ Py_ssize_t i, mask, offset;
+ PyDictKeysObject *k;
PyDictObject *d = di->di_dict;
PyObject **value_ptr;
static PyObject *dictiter_iternextvalue(dictiterobject *di)
{
PyObject *value;
- register Py_ssize_t i, mask, offset;
+ Py_ssize_t i, mask, offset;
PyDictObject *d = di->di_dict;
PyObject **value_ptr;
static PyObject *dictiter_iternextitem(dictiterobject *di)
{
PyObject *key, *value, *result = di->di_result;
- register Py_ssize_t i, mask, offset;
+ Py_ssize_t i, mask, offset;
PyDictObject *d = di->di_dict;
PyObject **value_ptr;
PyObject *
PyFloat_FromDouble(double fval)
{
- register PyFloatObject *op = free_list;
+ PyFloatObject *op = free_list;
if (op != NULL) {
free_list = (PyFloatObject *) Py_TYPE(op);
numfree--;
static int
convert_to_double(PyObject **v, double *dbl)
{
- register PyObject *obj = *v;
+ PyObject *obj = *v;
if (PyLong_Check(obj)) {
*dbl = PyLong_AsDouble(obj);
}
int
-PyList_SetItem(register PyObject *op, register Py_ssize_t i,
- register PyObject *newitem)
+PyList_SetItem(PyObject *op, Py_ssize_t i,
+ PyObject *newitem)
{
- register PyObject *olditem;
- register PyObject **p;
+ PyObject *olditem;
+ PyObject **p;
if (!PyList_Check(op)) {
Py_XDECREF(newitem);
PyErr_BadInternalCall();
static int
binarysort(sortslice lo, PyObject **hi, PyObject **start)
{
- register Py_ssize_t k;
- register PyObject **l, **p, **r;
- register PyObject *pivot;
+ Py_ssize_t k;
+ PyObject **l, **p, **r;
+ PyObject *pivot;
assert(lo.keys <= start && start <= hi);
/* assert [lo, start) is sorted */
of the algorithms used, this could save at most be one word anyway. */
static PyLongObject *
-long_normalize(register PyLongObject *v)
+long_normalize(PyLongObject *v)
{
Py_ssize_t j = ABS(Py_SIZE(v));
Py_ssize_t i = j;
PyLong_AsLongAndOverflow(PyObject *vv, int *overflow)
{
/* This version by Tim Peters */
- register PyLongObject *v;
+ PyLongObject *v;
unsigned long x, prev;
long res;
Py_ssize_t i;
Py_ssize_t
PyLong_AsSsize_t(PyObject *vv) {
- register PyLongObject *v;
+ PyLongObject *v;
size_t x, prev;
Py_ssize_t i;
int sign;
unsigned long
PyLong_AsUnsignedLong(PyObject *vv)
{
- register PyLongObject *v;
+ PyLongObject *v;
unsigned long x, prev;
Py_ssize_t i;
size_t
PyLong_AsSize_t(PyObject *vv)
{
- register PyLongObject *v;
+ PyLongObject *v;
size_t x, prev;
Py_ssize_t i;
static unsigned long
_PyLong_AsUnsignedLongMask(PyObject *vv)
{
- register PyLongObject *v;
+ PyLongObject *v;
unsigned long x;
Py_ssize_t i;
int sign;
}
unsigned long
-PyLong_AsUnsignedLongMask(register PyObject *op)
+PyLong_AsUnsignedLongMask(PyObject *op)
{
PyNumberMethods *nb;
PyLongObject *lo;
static unsigned PY_LONG_LONG
_PyLong_AsUnsignedLongLongMask(PyObject *vv)
{
- register PyLongObject *v;
+ PyLongObject *v;
unsigned PY_LONG_LONG x;
Py_ssize_t i;
int sign;
}
unsigned PY_LONG_LONG
-PyLong_AsUnsignedLongLongMask(register PyObject *op)
+PyLong_AsUnsignedLongLongMask(PyObject *op)
{
PyNumberMethods *nb;
PyLongObject *lo;
PyLong_AsLongLongAndOverflow(PyObject *vv, int *overflow)
{
/* This version by Tim Peters */
- register PyLongObject *v;
+ PyLongObject *v;
unsigned PY_LONG_LONG x, prev;
PY_LONG_LONG res;
Py_ssize_t i;
long_format_binary(PyObject *aa, int base, int alternate,
PyObject **p_output, _PyUnicodeWriter *writer)
{
- register PyLongObject *a = (PyLongObject *)aa;
+ PyLongObject *a = (PyLongObject *)aa;
PyObject *v;
Py_ssize_t sz;
Py_ssize_t size_a;
just 1 digit at the start, so that the copying code was exercised for every
digit beyond the first.
***/
- register twodigits c; /* current input character */
+ twodigits c; /* current input character */
Py_ssize_t size_z;
int i;
int convwidth;
PyDoc_STRVAR(namespace_reduce__doc__, "Return state information for pickling");
static PyObject *
-namespace_reduce(register _PyNamespaceObject *ns)
+namespace_reduce(_PyNamespaceObject *ns)
{
PyObject *result, *args = PyTuple_New(0);
}
void
-_Py_ForgetReference(register PyObject *op)
+_Py_ForgetReference(PyObject *op)
{
#ifdef SLOW_UNREF_CHECK
- register PyObject *p;
+ PyObject *p;
#endif
if (op->ob_refcnt < 0)
Py_FatalError("UNREF negative refcnt");
*/
static setentry *
-set_lookkey(PySetObject *so, PyObject *key, register Py_hash_t hash)
+set_lookkey(PySetObject *so, PyObject *key, Py_hash_t hash)
{
- register size_t i; /* Unsigned for defined overflow behavior. */
- register size_t perturb;
- register setentry *freeslot;
- register size_t mask = so->mask;
+ size_t i; /* Unsigned for defined overflow behavior. */
+ size_t perturb;
+ setentry *freeslot;
+ size_t mask = so->mask;
setentry *table = so->table;
- register setentry *entry;
- register int cmp;
+ setentry *entry;
+ int cmp;
PyObject *startkey;
i = (size_t)hash & mask;
* see if the comparison altered the table.
*/
static setentry *
-set_lookkey_unicode(PySetObject *so, PyObject *key, register Py_hash_t hash)
+set_lookkey_unicode(PySetObject *so, PyObject *key, Py_hash_t hash)
{
- register size_t i; /* Unsigned for defined overflow behavior. */
- register size_t perturb;
- register setentry *freeslot;
- register size_t mask = so->mask;
+ size_t i; /* Unsigned for defined overflow behavior. */
+ size_t perturb;
+ setentry *freeslot;
+ size_t mask = so->mask;
setentry *table = so->table;
- register setentry *entry;
+ setentry *entry;
/* Make sure this function doesn't have to handle non-unicode keys,
including subclasses of str; e.g., one reason to subclass
Eats a reference to key.
*/
static int
-set_insert_key(register PySetObject *so, PyObject *key, Py_hash_t hash)
+set_insert_key(PySetObject *so, PyObject *key, Py_hash_t hash)
{
- register setentry *entry;
+ setentry *entry;
assert(so->lookup != NULL);
entry = so->lookup(so, key, hash);
is responsible for incref'ing `key`.
*/
static void
-set_insert_clean(register PySetObject *so, PyObject *key, Py_hash_t hash)
+set_insert_clean(PySetObject *so, PyObject *key, Py_hash_t hash)
{
- register size_t i;
- register size_t perturb;
- register size_t mask = (size_t)so->mask;
+ size_t i;
+ size_t perturb;
+ size_t mask = (size_t)so->mask;
setentry *table = so->table;
- register setentry *entry;
+ setentry *entry;
i = (size_t)hash & mask;
entry = &table[i];
/* CAUTION: set_add_key/entry() must guarantee it won't resize the table */
static int
-set_add_entry(register PySetObject *so, setentry *entry)
+set_add_entry(PySetObject *so, setentry *entry)
{
- register Py_ssize_t n_used;
+ Py_ssize_t n_used;
PyObject *key = entry->key;
Py_hash_t hash = entry->hash;
}
static int
-set_add_key(register PySetObject *so, PyObject *key)
+set_add_key(PySetObject *so, PyObject *key)
{
- register Py_hash_t hash;
- register Py_ssize_t n_used;
+ Py_hash_t hash;
+ Py_ssize_t n_used;
if (!PyUnicode_CheckExact(key) ||
(hash = ((PyASCIIObject *) key)->hash) == -1) {
static int
set_discard_entry(PySetObject *so, setentry *oldentry)
-{ register setentry *entry;
+{ setentry *entry;
PyObject *old_key;
entry = (so->lookup)(so, oldentry->key, oldentry->hash);
static int
set_discard_key(PySetObject *so, PyObject *key)
{
- register Py_hash_t hash;
- register setentry *entry;
+ Py_hash_t hash;
+ setentry *entry;
PyObject *old_key;
assert (PyAnySet_Check(so));
{
Py_ssize_t i;
Py_ssize_t mask;
- register setentry *table;
+ setentry *table;
assert (PyAnySet_Check(so));
i = *pos_ptr;
static void
set_dealloc(PySetObject *so)
{
- register setentry *entry;
+ setentry *entry;
Py_ssize_t fill = so->fill;
PyObject_GC_UnTrack(so);
Py_TRASHCAN_SAFE_BEGIN(so)
PySetObject *other;
PyObject *key;
Py_hash_t hash;
- register Py_ssize_t i;
- register setentry *entry;
+ Py_ssize_t i;
+ setentry *entry;
assert (PyAnySet_Check(so));
assert (PyAnySet_Check(otherset));
static PyObject *
set_pop(PySetObject *so)
{
- register Py_ssize_t i = 0;
- register setentry *entry;
+ Py_ssize_t i = 0;
+ setentry *entry;
PyObject *key;
assert (PyAnySet_Check(so));
static PyObject *setiter_iternext(setiterobject *si)
{
PyObject *key;
- register Py_ssize_t i, mask;
- register setentry *entry;
+ Py_ssize_t i, mask;
+ setentry *entry;
PySetObject *so = si->si_set;
if (so == NULL)
static PyObject *
make_new_set(PyTypeObject *type, PyObject *iterable)
{
- register PySetObject *so = NULL;
+ PySetObject *so = NULL;
if (dummy == NULL) { /* Auto-initialize dummy */
dummy = PyUnicode_FromString("<dummy key>");
*/
if (_Py_IS_ALIGNED(s, SIZEOF_LONG)) {
/* Help register allocation */
- register const char *_s = s;
- register STRINGLIB_CHAR *_p = p;
+ const char *_s = s;
+ STRINGLIB_CHAR *_p = p;
while (_s < aligned_end) {
/* Read a whole long at a time (either 4 or 8 bytes),
and do a fast unrolled copy if it only contains ASCII
reads are more expensive, better to defer to another iteration. */
if (_Py_IS_ALIGNED(q, SIZEOF_LONG)) {
/* Fast path for runs of in-range non-surrogate chars. */
- register const unsigned char *_q = q;
+ const unsigned char *_q = q;
while (_q < aligned_end) {
unsigned long block = * (unsigned long *) _q;
if (native_ordering) {
Py_LOCAL_INLINE(int)
unicode_eq(PyObject *aa, PyObject *bb)
{
- register PyUnicodeObject *a = (PyUnicodeObject *)aa;
- register PyUnicodeObject *b = (PyUnicodeObject *)bb;
+ PyUnicodeObject *a = (PyUnicodeObject *)aa;
+ PyUnicodeObject *b = (PyUnicodeObject *)bb;
if (PyUnicode_READY(a) == -1 || PyUnicode_READY(b) == -1) {
assert(0 && "unicode_eq ready fail");
while (p < end) {
if (_Py_IS_ALIGNED(p, SIZEOF_LONG)) {
/* Help register allocation */
- register const unsigned char *_p = p;
+ const unsigned char *_p = p;
while (_p < aligned_end) {
unsigned long value = *(unsigned long *) _p;
if (value & UCS1_ASCII_CHAR_MASK)
#else
#error Invalid STRINGLIB_SIZEOF_CHAR (must be 1, 2 or 4)
#endif
- register Py_UCS4 mask;
+ Py_UCS4 mask;
Py_ssize_t n = end - begin;
const STRINGLIB_CHAR *p = begin;
const STRINGLIB_CHAR *unrolled_end = begin + _Py_SIZE_ROUND_DOWN(n, 4);
and the appends only done when the prealloc buffer is full.
That's too much work for little gain.*/
- register Py_ssize_t i;
- register Py_ssize_t j;
+ Py_ssize_t i;
+ Py_ssize_t j;
PyObject *list = PyList_New(0);
PyObject *sub;
}
PyObject *
-PyTuple_New(register Py_ssize_t size)
+PyTuple_New(Py_ssize_t size)
{
- register PyTupleObject *op;
+ PyTupleObject *op;
Py_ssize_t i;
if (size < 0) {
PyErr_BadInternalCall();
}
Py_ssize_t
-PyTuple_Size(register PyObject *op)
+PyTuple_Size(PyObject *op)
{
if (!PyTuple_Check(op)) {
PyErr_BadInternalCall();
}
PyObject *
-PyTuple_GetItem(register PyObject *op, register Py_ssize_t i)
+PyTuple_GetItem(PyObject *op, Py_ssize_t i)
{
if (!PyTuple_Check(op)) {
PyErr_BadInternalCall();
}
int
-PyTuple_SetItem(register PyObject *op, register Py_ssize_t i, PyObject *newitem)
+PyTuple_SetItem(PyObject *op, Py_ssize_t i, PyObject *newitem)
{
- register PyObject *olditem;
- register PyObject **p;
+ PyObject *olditem;
+ PyObject **p;
if (!PyTuple_Check(op) || op->ob_refcnt != 1) {
Py_XDECREF(newitem);
PyErr_BadInternalCall();
/* Methods */
static void
-tupledealloc(register PyTupleObject *op)
+tupledealloc(PyTupleObject *op)
{
- register Py_ssize_t i;
- register Py_ssize_t len = Py_SIZE(op);
+ Py_ssize_t i;
+ Py_ssize_t len = Py_SIZE(op);
PyObject_GC_UnTrack(op);
Py_TRASHCAN_SAFE_BEGIN(op)
if (len > 0) {
static Py_hash_t
tuplehash(PyTupleObject *v)
{
- register Py_uhash_t x; /* Unsigned for defined overflow behavior. */
- register Py_hash_t y;
- register Py_ssize_t len = Py_SIZE(v);
- register PyObject **p;
+ Py_uhash_t x; /* Unsigned for defined overflow behavior. */
+ Py_hash_t y;
+ Py_ssize_t len = Py_SIZE(v);
+ PyObject **p;
Py_uhash_t mult = _PyHASH_MULTIPLIER;
x = 0x345678UL;
p = v->ob_item;
}
static PyObject *
-tupleitem(register PyTupleObject *a, register Py_ssize_t i)
+tupleitem(PyTupleObject *a, Py_ssize_t i)
{
if (i < 0 || i >= Py_SIZE(a)) {
PyErr_SetString(PyExc_IndexError, "tuple index out of range");
}
static PyObject *
-tupleslice(register PyTupleObject *a, register Py_ssize_t ilow,
- register Py_ssize_t ihigh)
+tupleslice(PyTupleObject *a, Py_ssize_t ilow,
+ Py_ssize_t ihigh)
{
- register PyTupleObject *np;
+ PyTupleObject *np;
PyObject **src, **dest;
- register Py_ssize_t i;
+ Py_ssize_t i;
Py_ssize_t len;
if (ilow < 0)
ilow = 0;
}
static PyObject *
-tupleconcat(register PyTupleObject *a, register PyObject *bb)
+tupleconcat(PyTupleObject *a, PyObject *bb)
{
- register Py_ssize_t size;
- register Py_ssize_t i;
+ Py_ssize_t size;
+ Py_ssize_t i;
PyObject **src, **dest;
PyTupleObject *np;
if (!PyTuple_Check(bb)) {
int
_PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)
{
- register PyTupleObject *v;
- register PyTupleObject *sv;
+ PyTupleObject *v;
+ PyTupleObject *sv;
Py_ssize_t i;
Py_ssize_t oldsize;
/* Returns the titlecase Unicode characters corresponding to ch or just
ch if no titlecase mapping is known. */
-Py_UCS4 _PyUnicode_ToTitlecase(register Py_UCS4 ch)
+Py_UCS4 _PyUnicode_ToTitlecase(Py_UCS4 ch)
{
const _PyUnicode_TypeRecord *ctype = gettyperecord(ch);
static PyUnicodeObject *
_PyUnicode_New(Py_ssize_t length)
{
- register PyUnicodeObject *unicode;
+ PyUnicodeObject *unicode;
size_t new_size;
/* Optimization for empty strings */
}
static void
-unicode_dealloc(register PyObject *unicode)
+unicode_dealloc(PyObject *unicode)
{
switch (PyUnicode_CHECK_INTERNED(unicode)) {
case SSTATE_NOT_INTERNED:
#ifdef HAVE_WCHAR_H
PyObject *
-PyUnicode_FromWideChar(register const wchar_t *w, Py_ssize_t size)
+PyUnicode_FromWideChar(const wchar_t *w, Py_ssize_t size)
{
if (w == NULL) {
if (size == 0)
}
PyObject *
-PyUnicode_FromObject(register PyObject *obj)
+PyUnicode_FromObject(PyObject *obj)
{
/* XXX Perhaps we should make this API an alias of
PyObject_Str() instead ?! */
}
PyObject *
-PyUnicode_FromEncodedObject(register PyObject *obj,
+PyUnicode_FromEncodedObject(PyObject *obj,
const char *encoding,
const char *errors)
{
if (_Py_IS_ALIGNED(p, SIZEOF_LONG)) {
/* Fast path, see in STRINGLIB(utf8_decode) for
an explanation. */
- /* Help register allocation */
- register const char *_p = p;
- register Py_UCS1 * q = dest;
+ /* Help allocation */
+ const char *_p = p;
+ Py_UCS1 * q = dest;
while (_p < aligned_end) {
unsigned long value = *(const unsigned long *) _p;
if (value & ASCII_CHAR_MASK)
/* Fast path, see in STRINGLIB(utf8_decode) in stringlib/codecs.h
for an explanation. */
if (_Py_IS_ALIGNED(p, SIZEOF_LONG)) {
- /* Help register allocation */
- register const char *_p = p;
+ /* Help allocation */
+ const char *_p = p;
while (_p < aligned_end) {
unsigned long value = *(unsigned long *) _p;
if (value & ASCII_CHAR_MASK)
s += writer.pos;
kind = writer.kind;
while (s < e) {
- register unsigned char c = (unsigned char)*s;
+ unsigned char c = (unsigned char)*s;
if (c < 128) {
PyUnicode_WRITE(kind, data, writer.pos, c);
writer.pos++;
void
PyUnicode_InternInPlace(PyObject **p)
{
- register PyObject *s = *p;
+ PyObject *s = *p;
PyObject *t;
#ifdef Py_DEBUG
assert(s != NULL);
int
Py_UNICODE_strncmp(const Py_UNICODE *s1, const Py_UNICODE *s2, size_t n)
{
- register Py_UNICODE u1, u2;
+ Py_UNICODE u1, u2;
for (; n != 0; n--) {
u1 = *s1;
u2 = *s2;
/* Returns 1 for Unicode characters having the bidirectional
* type 'WS', 'B' or 'S' or the category 'Zs', 0 otherwise.
*/
-int _PyUnicode_IsWhitespace(register const Py_UCS4 ch)
+int _PyUnicode_IsWhitespace(const Py_UCS4 ch)
{
switch (ch) {
case 0x0009:
* property 'BK', 'CR', 'LF' or 'NL' or having bidirectional
* type 'B', 0 otherwise.
*/
-int _PyUnicode_IsLinebreak(register const Py_UCS4 ch)
+int _PyUnicode_IsLinebreak(const Py_UCS4 ch)
{
switch (ch) {
case 0x000A:
/* Return the DFA for the given type */
dfa *
-PyGrammar_FindDFA(grammar *g, register int type)
+PyGrammar_FindDFA(grammar *g, int type)
{
- register dfa *d;
+ dfa *d;
#if 1
/* Massive speed-up */
d = &g->g_dfa[type - NT_OFFSET];
return d;
#else
/* Old, slow version */
- register int i;
+ int i;
for (i = g->g_ndfas, d = g->g_dfa; --i >= 0; d++) {
if (d->d_type == type)
int
-PyNode_AddChild(register node *n1, int type, char *str, int lineno, int col_offset)
+PyNode_AddChild(node *n1, int type, char *str, int lineno, int col_offset)
{
const int nch = n1->n_nchildren;
int current_capacity;
#define s_empty(s) ((s)->s_top == &(s)->s_base[MAXSTACK])
static int
-s_push(register stack *s, dfa *d, node *parent)
+s_push(stack *s, dfa *d, node *parent)
{
- register stackentry *top;
+ stackentry *top;
if (s->s_top == s->s_base) {
fprintf(stderr, "s_push: parser stack overflow\n");
return E_NOMEM;
#ifdef Py_DEBUG
static void
-s_pop(register stack *s)
+s_pop(stack *s)
{
if (s_empty(s))
Py_FatalError("s_pop: parser stack underflow -- FATAL");
/* PARSER STACK OPERATIONS */
static int
-shift(register stack *s, int type, char *str, int newstate, int lineno, int col_offset)
+shift(stack *s, int type, char *str, int newstate, int lineno, int col_offset)
{
int err;
assert(!s_empty(s));
}
static int
-push(register stack *s, int type, dfa *d, int newstate, int lineno, int col_offset)
+push(stack *s, int type, dfa *d, int newstate, int lineno, int col_offset)
{
int err;
- register node *n;
+ node *n;
n = s->s_top->s_parent;
assert(!s_empty(s));
err = PyNode_AddChild(n, type, (char *)NULL, lineno, col_offset);
classify(parser_state *ps, int type, char *str)
{
grammar *g = ps->p_grammar;
- register int n = g->g_ll.ll_nlabels;
+ int n = g->g_ll.ll_nlabels;
if (type == NAME) {
- register char *s = str;
- register label *l = g->g_ll.ll_label;
- register int i;
+ char *s = str;
+ label *l = g->g_ll.ll_label;
+ int i;
for (i = n; i > 0; i--, l++) {
if (l->lb_type != NAME || l->lb_str == NULL ||
l->lb_str[0] != s[0] ||
}
{
- register label *l = g->g_ll.ll_label;
- register int i;
+ label *l = g->g_ll.ll_label;
+ int i;
for (i = n; i > 0; i--, l++) {
if (l->lb_type == type && l->lb_str == NULL) {
D(printf("It's a token we know\n"));
#endif /* future keyword */
int
-PyParser_AddToken(register parser_state *ps, register int type, char *str,
+PyParser_AddToken(parser_state *ps, int type, char *str,
int lineno, int col_offset, int *expected_ret)
{
- register int ilabel;
+ int ilabel;
int err;
D(printf("Token %s/'%s' ... ", _PyParser_TokenNames[type], str));
/* Loop until the token is shifted or an error occurred */
for (;;) {
/* Fetch the current dfa and state */
- register dfa *d = ps->p_stack.s_top->s_dfa;
- register state *s = &d->d_state[ps->p_stack.s_top->s_state];
+ dfa *d = ps->p_stack.s_top->s_dfa;
+ state *s = &d->d_state[ps->p_stack.s_top->s_state];
D(printf(" DFA '%s', state %d:",
d->d_name, ps->p_stack.s_top->s_state));
/* Check accelerator */
if (s->s_lower <= ilabel && ilabel < s->s_upper) {
- register int x = s->s_accel[ilabel - s->s_lower];
+ int x = s->s_accel[ilabel - s->s_lower];
if (x != -1) {
if (x & (1<<7)) {
/* Push non-terminal */
/* Get next char, updating state; error code goes into tok->done */
static int
-tok_nextc(register struct tok_state *tok)
+tok_nextc(struct tok_state *tok)
{
for (;;) {
if (tok->cur != tok->inp) {
/* Back-up one character */
static void
-tok_backup(register struct tok_state *tok, register int c)
+tok_backup(struct tok_state *tok, int c)
{
if (c != EOF) {
if (--tok->cur < tok->buf)
/* Get next token, after space stripping etc. */
static int
-tok_get(register struct tok_state *tok, char **p_start, char **p_end)
+tok_get(struct tok_state *tok, char **p_start, char **p_end)
{
- register int c;
+ int c;
int blankline, nonascii;
*p_start = *p_end = NULL;
/* Get indentation level */
if (tok->atbol) {
- register int col = 0;
- register int altcol = 0;
+ int col = 0;
+ int altcol = 0;
tok->atbol = 0;
for (;;) {
c = tok_nextc(tok);
static void
ppc_getcounter(uint64 *v)
{
- register unsigned long tbu, tb, tbu2;
+ unsigned long tbu, tb, tbu2;
loop:
asm volatile ("mftbu %0" : "=r" (tbu) );
#ifdef DXPAIRS
int lastopcode = 0;
#endif
- register PyObject **stack_pointer; /* Next free slot in value stack */
- register unsigned char *next_instr;
- register int opcode; /* Current opcode */
- register int oparg; /* Current opcode argument, if any */
- register enum why_code why; /* Reason for block stack unwind */
- register PyObject **fastlocals, **freevars;
+ PyObject **stack_pointer; /* Next free slot in value stack */
+ unsigned char *next_instr;
+ int opcode; /* Current opcode */
+ int oparg; /* Current opcode argument, if any */
+ enum why_code why; /* Reason for block stack unwind */
+ PyObject **fastlocals, **freevars;
PyObject *retval = NULL; /* Return value */
PyThreadState *tstate = PyThreadState_GET();
PyCodeObject *co;
PyObject **defs, int defcount, PyObject *kwdefs, PyObject *closure)
{
PyCodeObject* co = (PyCodeObject*)_co;
- register PyFrameObject *f;
- register PyObject *retval = NULL;
- register PyObject **fastlocals, **freevars;
+ PyFrameObject *f;
+ PyObject *retval = NULL;
+ PyObject **fastlocals, **freevars;
PyThreadState *tstate = PyThreadState_GET();
PyObject *x, *u;
int total_args = co->co_argcount + co->co_kwonlyargcount;
call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
int what, PyObject *arg)
{
- register PyThreadState *tstate = frame->f_tstate;
+ PyThreadState *tstate = frame->f_tstate;
int result;
if (tstate->tracing)
return 0;
"BaseException is not allowed"
static PyObject *
-cmp_outcome(int op, register PyObject *v, register PyObject *w)
+cmp_outcome(int op, PyObject *v, PyObject *w)
{
int res = 0;
switch (op) {
static
PyObject *normalizestring(const char *string)
{
- register size_t i;
+ size_t i;
size_t len = strlen(string);
char *p;
PyObject *v;
if (p == NULL)
return PyErr_NoMemory();
for (i = 0; i < len; i++) {
- register char ch = string[i];
+ char ch = string[i];
if (ch == ' ')
ch = '-';
else
static int
aix_getoldmodules(void **modlistptr)
{
- register ModulePtr modptr, prevmodptr;
- register struct ld_info *ldiptr;
- register char *ldibuf;
- register int errflag, bufsize = 1024;
- register unsigned int offset;
+ ModulePtr modptr, prevmodptr;
+ struct ld_info *ldiptr;
+ char *ldibuf;
+ int errflag, bufsize = 1024;
+ unsigned int offset;
char *progname = Py_GetProgramName();
/*
char *message[1024], errbuf[1024];
PyObject *pathname_ob = NULL;
PyObject *errbuf_ob = NULL;
- register int i,j;
+ int i,j;
struct errtab {
int errNo;
static int
r_short(RFILE *p)
{
- register short x;
+ short x;
unsigned char buffer[2];
r_string((char *) buffer, 2, p);
static long
r_long(RFILE *p)
{
- register long x;
+ long x;
unsigned char buffer[4];
r_string((char *) buffer, 4, p);
** exceptions - we don't check for them.
*/
unsigned long
-PyOS_strtoul(register char *str, char **ptr, int base)
+PyOS_strtoul(char *str, char **ptr, int base)
{
- register unsigned long result = 0; /* return value of the function */
- register int c; /* current input character */
- register int ovlimit; /* required digits to overflow */
+ unsigned long result = 0; /* return value of the function */
+ int c; /* current input character */
+ int ovlimit; /* required digits to overflow */
/* skip leading white space */
while (*str && Py_ISSPACE(Py_CHARMASK(*str)))
if (ovlimit > 0) /* no overflow check required */
result = result * base + c;
else { /* requires overflow check */
- register unsigned long temp_result;
+ unsigned long temp_result;
if (ovlimit < 0) /* guaranteed overflow */
goto overflowed;
strdup(const char *str)
{
if (str != NULL) {
- register char *copy = malloc(strlen(str) + 1);
+ char *copy = malloc(strlen(str) + 1);
if (copy != NULL)
return strcpy(copy, str);
}
print("/* Returns 1 for Unicode characters having the bidirectional", file=fp)
print(" * type 'WS', 'B' or 'S' or the category 'Zs', 0 otherwise.", file=fp)
print(" */", file=fp)
- print('int _PyUnicode_IsWhitespace(register const Py_UCS4 ch)', file=fp)
+ print('int _PyUnicode_IsWhitespace(const Py_UCS4 ch)', file=fp)
print('{', file=fp)
print(' switch (ch) {', file=fp)
print(" * property 'BK', 'CR', 'LF' or 'NL' or having bidirectional", file=fp)
print(" * type 'B', 0 otherwise.", file=fp)
print(" */", file=fp)
- print('int _PyUnicode_IsLinebreak(register const Py_UCS4 ch)', file=fp)
+ print('int _PyUnicode_IsLinebreak(const Py_UCS4 ch)', file=fp)
print('{', file=fp)
print(' switch (ch) {', file=fp)
for codepoint in sorted(linebreaks):
projects / python / commitdiff