@@ -685,9 +685,9 @@ free_keys_object(PyDictKeysObject *keys)
685
685
}
686
686
687
687
static inline PyDictValues *
688
- new_values (Py_ssize_t size )
688
+ new_values (size_t size )
689
689
{
690
- assert (size > 0 );
690
+ assert (size >= 1 );
691
691
size_t prefix_size = _Py_SIZE_ROUND_UP (size + 2 , sizeof (PyObject * ));
692
692
assert (prefix_size < 256 );
693
693
size_t n = prefix_size + size * sizeof (PyObject * );
@@ -746,27 +746,24 @@ new_dict(PyDictKeysObject *keys, PyDictValues *values, Py_ssize_t used, int free
746
746
return (PyObject * )mp ;
747
747
}
748
748
749
- static inline Py_ssize_t
749
+ static inline size_t
750
750
shared_keys_usable_size (PyDictKeysObject * keys )
751
751
{
752
- return keys -> dk_nentries + keys -> dk_usable ;
752
+ return ( size_t ) keys -> dk_nentries + ( size_t ) keys -> dk_usable ;
753
753
}
754
754
755
755
/* Consumes a reference to the keys object */
756
756
static PyObject *
757
757
new_dict_with_shared_keys (PyDictKeysObject * keys )
758
758
{
759
- PyDictValues * values ;
760
- Py_ssize_t i , size ;
761
-
762
- size = shared_keys_usable_size (keys );
763
- values = new_values (size );
759
+ size_t size = shared_keys_usable_size (keys );
760
+ PyDictValues * values = new_values (size );
764
761
if (values == NULL ) {
765
762
dictkeys_decref (keys );
766
763
return PyErr_NoMemory ();
767
764
}
768
765
((char * )values )[-2 ] = 0 ;
769
- for (i = 0 ; i < size ; i ++ ) {
766
+ for (size_t i = 0 ; i < size ; i ++ ) {
770
767
values -> values [i ] = NULL ;
771
768
}
772
769
return new_dict (keys , values , 0 , 1 );
@@ -781,7 +778,7 @@ clone_combined_dict_keys(PyDictObject *orig)
781
778
assert (orig -> ma_values == NULL );
782
779
assert (orig -> ma_keys -> dk_refcnt == 1 );
783
780
784
- Py_ssize_t keys_size = _PyDict_KeysSize (orig -> ma_keys );
781
+ size_t keys_size = _PyDict_KeysSize (orig -> ma_keys );
785
782
PyDictKeysObject * keys = PyObject_Malloc (keys_size );
786
783
if (keys == NULL ) {
787
784
PyErr_NoMemory ();
@@ -2959,7 +2956,6 @@ PyDict_Copy(PyObject *o)
2959
2956
{
2960
2957
PyObject * copy ;
2961
2958
PyDictObject * mp ;
2962
- Py_ssize_t i , n ;
2963
2959
2964
2960
if (o == NULL || !PyDict_Check (o )) {
2965
2961
PyErr_BadInternalCall ();
@@ -2974,9 +2970,8 @@ PyDict_Copy(PyObject *o)
2974
2970
2975
2971
if (_PyDict_HasSplitTable (mp )) {
2976
2972
PyDictObject * split_copy ;
2977
- Py_ssize_t size = shared_keys_usable_size (mp -> ma_keys );
2978
- PyDictValues * newvalues ;
2979
- newvalues = new_values (size );
2973
+ size_t size = shared_keys_usable_size (mp -> ma_keys );
2974
+ PyDictValues * newvalues = new_values (size );
2980
2975
if (newvalues == NULL )
2981
2976
return PyErr_NoMemory ();
2982
2977
split_copy = PyObject_GC_New (PyDictObject , & PyDict_Type );
@@ -2991,7 +2986,7 @@ PyDict_Copy(PyObject *o)
2991
2986
split_copy -> ma_used = mp -> ma_used ;
2992
2987
split_copy -> ma_version_tag = DICT_NEXT_VERSION ();
2993
2988
dictkeys_incref (mp -> ma_keys );
2994
- for (i = 0 , n = size ; i < n ; i ++ ) {
2989
+ for (size_t i = 0 ; i < size ; i ++ ) {
2995
2990
PyObject * value = mp -> ma_values -> values [i ];
2996
2991
split_copy -> ma_values -> values [i ] = Py_XNewRef (value );
2997
2992
}
@@ -3514,9 +3509,7 @@ static PyObject *dictiter_new(PyDictObject *, PyTypeObject *);
3514
3509
Py_ssize_t
3515
3510
_PyDict_SizeOf (PyDictObject * mp )
3516
3511
{
3517
- Py_ssize_t res ;
3518
-
3519
- res = _PyObject_SIZE (Py_TYPE (mp ));
3512
+ size_t res = _PyObject_SIZE (Py_TYPE (mp ));
3520
3513
if (mp -> ma_values ) {
3521
3514
res += shared_keys_usable_size (mp -> ma_keys ) * sizeof (PyObject * );
3522
3515
}
@@ -3525,17 +3518,19 @@ _PyDict_SizeOf(PyDictObject *mp)
3525
3518
if (mp -> ma_keys -> dk_refcnt == 1 ) {
3526
3519
res += _PyDict_KeysSize (mp -> ma_keys );
3527
3520
}
3528
- return res ;
3521
+ assert (res <= (size_t )PY_SSIZE_T_MAX );
3522
+ return (Py_ssize_t )res ;
3529
3523
}
3530
3524
3531
- Py_ssize_t
3525
+ size_t
3532
3526
_PyDict_KeysSize (PyDictKeysObject * keys )
3533
3527
{
3534
- size_t es = keys -> dk_kind == DICT_KEYS_GENERAL
3535
- ? sizeof (PyDictKeyEntry ) : sizeof (PyDictUnicodeEntry );
3536
- return (sizeof (PyDictKeysObject )
3537
- + ((size_t )1 << keys -> dk_log2_index_bytes )
3538
- + USABLE_FRACTION (DK_SIZE (keys )) * es );
3528
+ size_t es = (keys -> dk_kind == DICT_KEYS_GENERAL
3529
+ ? sizeof (PyDictKeyEntry ) : sizeof (PyDictUnicodeEntry ));
3530
+ size_t size = sizeof (PyDictKeysObject );
3531
+ size += (size_t )1 << keys -> dk_log2_index_bytes ;
3532
+ size += USABLE_FRACTION ((size_t )DK_SIZE (keys )) * es ;
3533
+ return size ;
3539
3534
}
3540
3535
3541
3536
static PyObject *
@@ -5286,16 +5281,15 @@ init_inline_values(PyObject *obj, PyTypeObject *tp)
5286
5281
if (keys -> dk_usable > 1 ) {
5287
5282
keys -> dk_usable -- ;
5288
5283
}
5289
- Py_ssize_t size = shared_keys_usable_size (keys );
5290
- assert (size > 0 );
5284
+ size_t size = shared_keys_usable_size (keys );
5291
5285
PyDictValues * values = new_values (size );
5292
5286
if (values == NULL ) {
5293
5287
PyErr_NoMemory ();
5294
5288
return -1 ;
5295
5289
}
5296
- assert (((uint8_t * )values )[-1 ] >= size + 2 );
5290
+ assert (((uint8_t * )values )[-1 ] >= ( size + 2 ) );
5297
5291
((uint8_t * )values )[-2 ] = 0 ;
5298
- for (int i = 0 ; i < size ; i ++ ) {
5292
+ for (size_t i = 0 ; i < size ; i ++ ) {
5299
5293
values -> values [i ] = NULL ;
5300
5294
}
5301
5295
_PyDictOrValues_SetValues (_PyObject_DictOrValuesPointer (obj ), values );
@@ -5335,7 +5329,8 @@ make_dict_from_instance_attributes(PyDictKeysObject *keys, PyDictValues *values)
5335
5329
dictkeys_incref (keys );
5336
5330
Py_ssize_t used = 0 ;
5337
5331
Py_ssize_t track = 0 ;
5338
- for (Py_ssize_t i = 0 ; i < shared_keys_usable_size (keys ); i ++ ) {
5332
+ size_t size = shared_keys_usable_size (keys );
5333
+ for (size_t i = 0 ; i < size ; i ++ ) {
5339
5334
PyObject * val = values -> values [i ];
5340
5335
if (val != NULL ) {
5341
5336
used += 1 ;
0 commit comments