Lines Matching defs:keys
1086 /* A sortslice contains a pointer to an array of keys and a pointer to
1087 * an array of corresponding values. In other words, keys[i]
1088 * corresponds with values[i]. If values == NULL, then the keys are
1091 * Several convenience routines are provided here, so that keys and
1096 PyObject **keys;
1103 s1->keys[i] = s2->keys[j];
1111 *dst->keys++ = *src->keys++;
1119 *dst->keys-- = *src->keys--;
1129 memcpy(&s1->keys[i], &s2->keys[j], sizeof(PyObject *) * n);
1138 memmove(&s1->keys[i], &s2->keys[j], sizeof(PyObject *) * n);
1146 slice->keys += n;
1198 PyObject **basekeys; /* base address of keys array - read only */
1221 /* This is the function we will use to compare two keys,
1255 assert(lo.keys <= start && start <= hi);
1257 if (lo.keys == start)
1261 l = lo.keys;
1289 Py_ssize_t offset = lo.values - lo.keys;
1551 * enough extra space, listsort() will use it to store the keys.
1555 /* ms->alloced describes how many keys will be stored at
1566 ms->a.keys = ms->temparray;
1570 ms->basekeys = lo->keys;
1581 if (ms->a.keys != ms->temparray) {
1582 PyMem_Free(ms->a.keys);
1583 ms->a.keys = NULL;
1609 ms->a.keys = (PyObject **)PyMem_Malloc(multiplier * need
1611 if (ms->a.keys != NULL) {
1614 ms->a.values = &ms->a.keys[need];
1624 * ssb.keys = ssa.keys + na in a stable way, in-place. na and nb must be > 0.
1625 * Must also have that ssa.keys[na-1] belongs at the end of the merge, and
1638 assert(ms && ssa.keys && ssb.keys && na > 0 && nb > 0);
1639 assert(ssa.keys + na == ssb.keys);
1663 k = ISLT(ssb.keys[0], ssa.keys[0]);
1698 k = gallop_right(ms, ssb.keys[0], ssa.keys, na, 0);
1721 k = gallop_left(ms, ssa.keys[0], ssb.keys, nb, 0);
1756 * ssb.keys = ssa.keys + na in a stable way, in-place. na and nb must be > 0.
1757 * Must also have that ssa.keys[na-1] belongs at the end of the merge, and
1770 assert(ms && ssa.keys && ssb.keys && na > 0 && nb > 0);
1771 assert(ssa.keys + na == ssb.keys);
1779 ssb.keys = ms->a.keys + nb - 1;
1801 k = ISLT(ssb.keys[0], ssa.keys[0]);
1836 k = gallop_right(ms, ssb.keys[0], basea.keys, na, na-1);
1854 k = gallop_left(ms, ssa.keys[0], baseb.keys, nb, nb-1);
1917 assert(ssa.keys + na == ssb.keys);
1931 k = gallop_right(ms, *ssb.keys, ssa.keys, na, 0);
1942 nb = gallop_left(ms, ssa.keys[na-1], ssb.keys, nb, nb-1);
2014 Py_ssize_t s1 = p[ms->n - 1].base.keys - ms->basekeys; /* start index */
2074 reverse_slice(s->keys, &s->keys[n]);
2280 PyObject **keys;
2300 keys = NULL;
2301 lo.keys = saved_ob_item;
2307 keys = &ms.temparray[saved_ob_size+1];
2309 keys = PyMem_Malloc(sizeof(PyObject *) * saved_ob_size);
2310 if (keys == NULL) {
2317 keys[i] = PyObject_CallOneArg(keyfunc, saved_ob_item[i]);
2318 if (keys[i] == NULL) {
2320 Py_DECREF(keys[i]);
2322 PyMem_Free(keys);
2327 lo.keys = keys;
2338 int keys_are_in_tuples = (Py_IS_TYPE(lo.keys[0], &PyTuple_Type) &&
2339 Py_SIZE(lo.keys[0]) > 0);
2342 Py_TYPE(PyTuple_GET_ITEM(lo.keys[0], 0)) :
2343 Py_TYPE(lo.keys[0]));
2353 !(Py_IS_TYPE(lo.keys[i], &PyTuple_Type) && Py_SIZE(lo.keys[i]) != 0)) {
2360 * lo.keys[i], not lo.keys[i] itself! We verify type-homogeneity
2363 PyTuple_GET_ITEM(lo.keys[i], 0) :
2364 lo.keys[i]);
2368 /* If keys are in tuple we must loop over the whole list to make
2391 /* Choose the best compare, given what we now know about the keys. */
2416 * (remember: here, key_type refers list [key[0] for key in keys]) */
2429 merge_init(&ms, saved_ob_size, keys != NULL, &lo);
2438 if (keys != NULL)
2439 reverse_slice(&keys[0], &keys[saved_ob_size]);
2452 n = count_run(&ms, lo.keys, lo.keys + nremaining, &descending);
2461 if (binarysort(&ms, lo, lo.keys + force, lo.keys + n) < 0)
2466 assert(ms.n == 0 || ms.pending[ms.n -1].base.keys +
2467 ms.pending[ms.n-1].len == lo.keys);
2483 assert(keys == NULL
2484 ? ms.pending[0].base.keys == saved_ob_item
2485 : ms.pending[0].base.keys == &keys[0]);
2492 if (keys != NULL) {
2494 Py_DECREF(keys[i]);
2496 PyMem_Free(keys);