### Bug Summary

File: | Objects/dictobject.c
Location: | line 338, column 40
Description: | Both operands to '==' always have the same value

### Annotated Source Code

1 |
2 | /* Dictionary object implementation using a hash table */
3 |
4 | /* The distribution includes a separate file, Objects/dictnotes.txt,
5 | describing explorations into dictionary design and optimization.
6 | It covers typical dictionary use patterns, the parameters for
7 | tuning dictionaries, and several ideas for possible optimizations.
8 | */
9 |
10 | #include "Python.h"
11 | #include "stringlib/eq.h"
12 |
13 |
14 | /* Set a key error with the specified argument, wrapping it in a
15 | * tuple automatically so that tuple keys are not unpacked as the
16 | * exception arguments. */
17 | static void
18 | set_key_error(PyObject *arg)
19 | {
20 | PyObject *tup;
21 | tup = PyTuple_Pack(1, arg);
22 | if (!tup)
23 | return; /* caller will expect error to be set anyway */
24 | PyErr_SetObject(PyExc_KeyError, tup);
25 | Py_DECREF(tup)do { if (_Py_RefTotal-- , --((PyObject*)(tup))->ob_refcnt != 0) { if (((PyObject*)tup)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 25, (PyObject *)(tup)); } else _Py_Dealloc ((PyObject *)(tup)); } while (0);
26 | }
27 |
28 | /* Define this out if you don't want conversion statistics on exit. */
29 | #undef SHOW_CONVERSION_COUNTS
30 |
31 | /* See large comment block below. This must be >= 1. */
32 | #define PERTURB_SHIFT5 5
33 |
34 | /*
35 | Major subtleties ahead: Most hash schemes depend on having a "good" hash
36 | function, in the sense of simulating randomness. Python doesn't: its most
37 | important hash functions (for strings and ints) are very regular in common
38 | cases:
39 |
40 | >>> map(hash, (0, 1, 2, 3))
41 | [0, 1, 2, 3]
42 | >>> map(hash, ("namea", "nameb", "namec", "named"))
43 | [-1658398457, -1658398460, -1658398459, -1658398462]
44 | >>>
45 |
46 | This isn't necessarily bad! To the contrary, in a table of size 2**i, taking
47 | the low-order i bits as the initial table index is extremely fast, and there
48 | are no collisions at all for dicts indexed by a contiguous range of ints.
49 | The same is approximately true when keys are "consecutive" strings. So this
50 | gives better-than-random behavior in common cases, and that's very desirable.
51 |
52 | OTOH, when collisions occur, the tendency to fill contiguous slices of the
53 | hash table makes a good collision resolution strategy crucial. Taking only
54 | the last i bits of the hash code is also vulnerable: for example, consider
55 | the list [i << 16 for i in range(20000)] as a set of keys. Since ints are
56 | their own hash codes, and this fits in a dict of size 2**15, the last 15 bits
57 | of every hash code are all 0: they *all* map to the same table index.
58 |
59 | But catering to unusual cases should not slow the usual ones, so we just take
60 | the last i bits anyway. It's up to collision resolution to do the rest. If
61 | we *usually* find the key we're looking for on the first try (and, it turns
62 | out, we usually do -- the table load factor is kept under 2/3, so the odds
63 | are solidly in our favor), then it makes best sense to keep the initial index
64 | computation dirt cheap.
65 |
66 | The first half of collision resolution is to visit table indices via this
67 | recurrence:
68 |
69 | j = ((5*j) + 1) mod 2**i
70 |
71 | For any initial j in range(2**i), repeating that 2**i times generates each
72 | int in range(2**i) exactly once (see any text on random-number generation for
73 | proof). By itself, this doesn't help much: like linear probing (setting
74 | j += 1, or j -= 1, on each loop trip), it scans the table entries in a fixed
75 | order. This would be bad, except that's not the only thing we do, and it's
76 | actually *good* in the common cases where hash keys are consecutive. In an
77 | example that's really too small to make this entirely clear, for a table of
78 | size 2**3 the order of indices is:
79 |
80 | 0 -> 1 -> 6 -> 7 -> 4 -> 5 -> 2 -> 3 -> 0 [and here it's repeating]
81 |
82 | If two things come in at index 5, the first place we look after is index 2,
83 | not 6, so if another comes in at index 6 the collision at 5 didn't hurt it.
84 | Linear probing is deadly in this case because there the fixed probe order
85 | is the *same* as the order consecutive keys are likely to arrive. But it's
86 | extremely unlikely hash codes will follow a 5*j+1 recurrence by accident,
87 | and certain that consecutive hash codes do not.
88 |
89 | The other half of the strategy is to get the other bits of the hash code
90 | into play. This is done by initializing a (unsigned) vrbl "perturb" to the
91 | full hash code, and changing the recurrence to:
92 |
93 | j = (5*j) + 1 + perturb;
94 | perturb >>= PERTURB_SHIFT;
95 | use j % 2**i as the next table index;
96 |
97 | Now the probe sequence depends (eventually) on every bit in the hash code,
98 | and the pseudo-scrambling property of recurring on 5*j+1 is more valuable,
99 | because it quickly magnifies small differences in the bits that didn't affect
100 | the initial index. Note that because perturb is unsigned, if the recurrence
101 | is executed often enough perturb eventually becomes and remains 0. At that
102 | point (very rarely reached) the recurrence is on (just) 5*j+1 again, and
103 | that's certain to find an empty slot eventually (since it generates every int
104 | in range(2**i), and we make sure there's always at least one empty slot).
105 |
106 | Selecting a good value for PERTURB_SHIFT is a balancing act. You want it
107 | small so that the high bits of the hash code continue to affect the probe
108 | sequence across iterations; but you want it large so that in really bad cases
109 | the high-order hash bits have an effect on early iterations. 5 was "the
110 | best" in minimizing total collisions across experiments Tim Peters ran (on
111 | both normal and pathological cases), but 4 and 6 weren't significantly worse.
112 |
113 | Historical: Reimer Behrends contributed the idea of using a polynomial-based
114 | approach, using repeated multiplication by x in GF(2**n) where an irreducible
115 | polynomial for each table size was chosen such that x was a primitive root.
116 | Christian Tismer later extended that to use division by x instead, as an
117 | efficient way to get the high bits of the hash code into play. This scheme
118 | also gave excellent collision statistics, but was more expensive: two
119 | if-tests were required inside the loop; computing "the next" index took about
120 | the same number of operations but without as much potential parallelism
121 | (e.g., computing 5*j can go on at the same time as computing 1+perturb in the
122 | above, and then shifting perturb can be done while the table index is being
123 | masked); and the PyDictObject struct required a member to hold the table's
124 | polynomial. In Tim's experiments the current scheme ran faster, produced
125 | equally good collision statistics, needed less code & used less memory.
126 |
127 | */
128 |
129 | /* Object used as dummy key to fill deleted entries */
130 | static PyObject *dummy = NULL((void *)0); /* Initialized by first call to newPyDictObject() */
131 |
132 | #ifdef Py_REF_DEBUG
133 | PyObject *
134 | _PyDict_Dummy(void)
135 | {
136 | return dummy;
137 | }
138 | #endif
139 |
140 | /* forward declarations */
141 | static PyDictEntry *
142 | lookdict_unicode(PyDictObject *mp, PyObject *key, Py_hash_t hash);
143 |
144 | #ifdef SHOW_CONVERSION_COUNTS
145 | static long created = 0L;
146 | static long converted = 0L;
147 |
148 | static void
149 | show_counts(void)
150 | {
151 | fprintf(stderr__stderrp, "created %ld string dicts\n", created);
152 | fprintf(stderr__stderrp, "converted %ld to normal dicts\n", converted);
153 | fprintf(stderr__stderrp, "%.2f%% conversion rate\n", (100.0*converted)/created);
154 | }
155 | #endif
156 |
157 | /* Debug statistic to compare allocations with reuse through the free list */
158 | #undef SHOW_ALLOC_COUNT
159 | #ifdef SHOW_ALLOC_COUNT
160 | static size_t count_alloc = 0;
161 | static size_t count_reuse = 0;
162 |
163 | static void
164 | show_alloc(void)
165 | {
166 | fprintf(stderr__stderrp, "Dict allocations: %" PY_FORMAT_SIZE_T"l" "d\n",
167 | count_alloc);
168 | fprintf(stderr__stderrp, "Dict reuse through freelist: %" PY_FORMAT_SIZE_T"l"
169 | "d\n", count_reuse);
170 | fprintf(stderr__stderrp, "%.2f%% reuse rate\n\n",
171 | (100.0*count_reuse/(count_alloc+count_reuse)));
172 | }
173 | #endif
174 |
175 | /* Debug statistic to count GC tracking of dicts */
176 | #ifdef SHOW_TRACK_COUNT
177 | static Py_ssize_t count_untracked = 0;
178 | static Py_ssize_t count_tracked = 0;
179 |
180 | static void
181 | show_track(void)
182 | {
183 | fprintf(stderr__stderrp, "Dicts created: %" PY_FORMAT_SIZE_T"l" "d\n",
184 | count_tracked + count_untracked);
185 | fprintf(stderr__stderrp, "Dicts tracked by the GC: %" PY_FORMAT_SIZE_T"l"
186 | "d\n", count_tracked);
187 | fprintf(stderr__stderrp, "%.2f%% dict tracking rate\n\n",
188 | (100.0*count_tracked/(count_untracked+count_tracked)));
189 | }
190 | #endif
191 |
192 |
193 | /* Initialization macros.
194 | There are two ways to create a dict: PyDict_New() is the main C API
195 | function, and the tp_new slot maps to dict_new(). In the latter case we
196 | can save a little time over what PyDict_New does because it's guaranteed
197 | that the PyDictObject struct is already zeroed out.
198 | Everyone except dict_new() should use EMPTY_TO_MINSIZE (unless they have
199 | an excellent reason not to).
200 | */
201 |
202 | #define INIT_NONZERO_DICT_SLOTS(mp)do { (mp)->ma_table = (mp)->ma_smalltable; (mp)->ma_mask = 8 - 1; } while(0) do { \
203 | (mp)->ma_table = (mp)->ma_smalltable; \
204 | (mp)->ma_mask = PyDict_MINSIZE8 - 1; \
205 | } while(0)
206 |
207 | #define EMPTY_TO_MINSIZE(mp)do { ((__builtin_object_size ((mp)->ma_smalltable, 0) != ( size_t) -1) ? __builtin___memset_chk ((mp)->ma_smalltable, 0, sizeof((mp)->ma_smalltable), __builtin_object_size ((mp )->ma_smalltable, 0)) : __inline_memset_chk ((mp)->ma_smalltable , 0, sizeof((mp)->ma_smalltable))); (mp)->ma_used = (mp )->ma_fill = 0; do { (mp)->ma_table = (mp)->ma_smalltable ; (mp)->ma_mask = 8 - 1; } while(0); } while(0) do { \
208 | memset((mp)->ma_smalltable, 0, sizeof((mp)->ma_smalltable))((__builtin_object_size ((mp)->ma_smalltable, 0) != (size_t ) -1) ? __builtin___memset_chk ((mp)->ma_smalltable, 0, sizeof ((mp)->ma_smalltable), __builtin_object_size ((mp)->ma_smalltable , 0)) : __inline_memset_chk ((mp)->ma_smalltable, 0, sizeof ((mp)->ma_smalltable))); \
209 | (mp)->ma_used = (mp)->ma_fill = 0; \
210 | INIT_NONZERO_DICT_SLOTS(mp)do { (mp)->ma_table = (mp)->ma_smalltable; (mp)->ma_mask = 8 - 1; } while(0); \
211 | } while(0)
212 |
213 | /* Dictionary reuse scheme to save calls to malloc, free, and memset */
214 | #ifndef PyDict_MAXFREELIST80
215 | #define PyDict_MAXFREELIST80 80
216 | #endif
217 | static PyDictObject *free_list[PyDict_MAXFREELIST80];
218 | static int numfree = 0;
219 |
220 | void
221 | PyDict_Fini(void)
222 | {
223 | PyDictObject *op;
224 |
225 | while (numfree) {
226 | op = free_list[--numfree];
227 | assert(PyDict_CheckExact(op))(__builtin_expect(!(((((PyObject*)(op))->ob_type) == & PyDict_Type)), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 227, "PyDict_CheckExact(op)") : (void)0);
228 | PyObject_GC_Del(op);
229 | }
230 | }
231 |
232 | PyObject *
233 | PyDict_New(void)
234 | {
235 | register PyDictObject *mp;
236 | if (dummy == NULL((void *)0)) { /* Auto-initialize dummy */
237 | dummy = PyUnicode_FromStringPyUnicodeUCS2_FromString("<dummy key>");
238 | if (dummy == NULL((void *)0))
239 | return NULL((void *)0);
240 | #ifdef SHOW_CONVERSION_COUNTS
241 | Py_AtExit(show_counts);
242 | #endif
243 | #ifdef SHOW_ALLOC_COUNT
244 | Py_AtExit(show_alloc);
245 | #endif
246 | #ifdef SHOW_TRACK_COUNT
247 | Py_AtExit(show_track);
248 | #endif
249 | }
250 | if (numfree) {
251 | mp = free_list[--numfree];
252 | assert (mp != NULL)(__builtin_expect(!(mp != ((void *)0)), 0) ? __assert_rtn(__func__ , "Objects/dictobject.c", 252, "mp != NULL") : (void)0);
253 | assert (Py_TYPE(mp) == &PyDict_Type)(__builtin_expect(!((((PyObject*)(mp))->ob_type) == &PyDict_Type ), 0) ? __assert_rtn(__func__, "Objects/dictobject.c", 253, "Py_TYPE(mp) == &PyDict_Type" ) : (void)0);
254 | _Py_NewReference((PyObject *)mp);
255 | if (mp->ma_fill) {
256 | EMPTY_TO_MINSIZE(mp)do { ((__builtin_object_size ((mp)->ma_smalltable, 0) != ( size_t) -1) ? __builtin___memset_chk ((mp)->ma_smalltable, 0, sizeof((mp)->ma_smalltable), __builtin_object_size ((mp )->ma_smalltable, 0)) : __inline_memset_chk ((mp)->ma_smalltable , 0, sizeof((mp)->ma_smalltable))); (mp)->ma_used = (mp )->ma_fill = 0; do { (mp)->ma_table = (mp)->ma_smalltable ; (mp)->ma_mask = 8 - 1; } while(0); } while(0);
257 | } else {
258 | /* At least set ma_table and ma_mask; these are wrong
259 | if an empty but presized dict is added to freelist */
260 | INIT_NONZERO_DICT_SLOTS(mp)do { (mp)->ma_table = (mp)->ma_smalltable; (mp)->ma_mask = 8 - 1; } while(0);
261 | }
262 | assert (mp->ma_used == 0)(__builtin_expect(!(mp->ma_used == 0), 0) ? __assert_rtn(__func__ , "Objects/dictobject.c", 262, "mp->ma_used == 0") : (void )0);
263 | assert (mp->ma_table == mp->ma_smalltable)(__builtin_expect(!(mp->ma_table == mp->ma_smalltable), 0) ? __assert_rtn(__func__, "Objects/dictobject.c", 263, "mp->ma_table == mp->ma_smalltable" ) : (void)0);
264 | assert (mp->ma_mask == PyDict_MINSIZE - 1)(__builtin_expect(!(mp->ma_mask == 8 - 1), 0) ? __assert_rtn (__func__, "Objects/dictobject.c", 264, "mp->ma_mask == PyDict_MINSIZE - 1" ) : (void)0);
265 | #ifdef SHOW_ALLOC_COUNT
266 | count_reuse++;
267 | #endif
268 | } else {
269 | mp = PyObject_GC_New(PyDictObject, &PyDict_Type)( (PyDictObject *) _PyObject_GC_New(&PyDict_Type) );
270 | if (mp == NULL((void *)0))
271 | return NULL((void *)0);
272 | EMPTY_TO_MINSIZE(mp)do { ((__builtin_object_size ((mp)->ma_smalltable, 0) != ( size_t) -1) ? __builtin___memset_chk ((mp)->ma_smalltable, 0, sizeof((mp)->ma_smalltable), __builtin_object_size ((mp )->ma_smalltable, 0)) : __inline_memset_chk ((mp)->ma_smalltable , 0, sizeof((mp)->ma_smalltable))); (mp)->ma_used = (mp )->ma_fill = 0; do { (mp)->ma_table = (mp)->ma_smalltable ; (mp)->ma_mask = 8 - 1; } while(0); } while(0);
273 | #ifdef SHOW_ALLOC_COUNT
274 | count_alloc++;
275 | #endif
276 | }
277 | mp->ma_lookup = lookdict_unicode;
278 | #ifdef SHOW_TRACK_COUNT
279 | count_untracked++;
280 | #endif
281 | #ifdef SHOW_CONVERSION_COUNTS
282 | ++created;
283 | #endif
284 | return (PyObject *)mp;
285 | }
286 |
287 | /*
288 | The basic lookup function used by all operations.
289 | This is based on Algorithm D from Knuth Vol. 3, Sec. 6.4.
290 | Open addressing is preferred over chaining since the link overhead for
291 | chaining would be substantial (100% with typical malloc overhead).
292 |
293 | The initial probe index is computed as hash mod the table size. Subsequent
294 | probe indices are computed as explained earlier.
295 |
296 | All arithmetic on hash should ignore overflow.
297 |
298 | The details in this version are due to Tim Peters, building on many past
299 | contributions by Reimer Behrends, Jyrki Alakuijala, Vladimir Marangozov and
300 | Christian Tismer.
301 |
302 | lookdict() is general-purpose, and may return NULL if (and only if) a
303 | comparison raises an exception (this was new in Python 2.5).
304 | lookdict_unicode() below is specialized to string keys, comparison of which can
305 | never raise an exception; that function can never return NULL. For both, when
306 | the key isn't found a PyDictEntry* is returned for which the me_value field is
307 | NULL; this is the slot in the dict at which the key would have been found, and
308 | the caller can (if it wishes) add the <key, value> pair to the returned
309 | PyDictEntry*.
310 | */
311 | static PyDictEntry *
312 | lookdict(PyDictObject *mp, PyObject *key, register Py_hash_t hash)
313 | {
314 | register size_t i;
315 | register size_t perturb;
316 | register PyDictEntry *freeslot;
317 | register size_t mask = (size_t)mp->ma_mask;
318 | PyDictEntry *ep0 = mp->ma_table;
319 | register PyDictEntry *ep;
320 | register int cmp;
321 | PyObject *startkey;
322 |
323 | i = (size_t)hash & mask;
324 | ep = &ep0[i];
325 | if (ep->me_key == NULL((void *)0) || ep->me_key == key)
1 | Taking false branch
326 | return ep;
327 |
328 | if (ep->me_key == dummy)
2 | Taking false branch
329 | freeslot = ep;
330 | else {
331 | if (ep->me_hash == hash) {
3 | Taking true branch
332 | startkey = ep->me_key;
333 | Py_INCREF(startkey)( _Py_RefTotal++ , ((PyObject*)(startkey))->ob_refcnt++);
334 | cmp = PyObject_RichCompareBool(startkey, key, Py_EQ2);
335 | Py_DECREF(startkey)do { if (_Py_RefTotal-- , --((PyObject*)(startkey))->ob_refcnt != 0) { if (((PyObject*)startkey)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 335, (PyObject *)(startkey)); } else _Py_Dealloc((PyObject *)(startkey)); } while (0);
336 | if (cmp < 0)
4 | Taking false branch
337 | return NULL((void *)0);
338 | if (ep0 == mp->ma_table && ep->me_key == startkey) {
5 | Both operands to '==' always have the same value
339 | if (cmp > 0)
340 | return ep;
341 | }
342 | else {
343 | /* The compare did major nasty stuff to the
344 | * dict: start over.
345 | * XXX A clever adversary could prevent this
346 | * XXX from terminating.
347 | */
348 | return lookdict(mp, key, hash);
349 | }
350 | }
351 | freeslot = NULL((void *)0);
352 | }
353 |
354 | /* In the loop, me_key == dummy is by far (factor of 100s) the
355 | least likely outcome, so test for that last. */
356 | for (perturb = hash; ; perturb >>= PERTURB_SHIFT5) {
357 | i = (i << 2) + i + perturb + 1;
358 | ep = &ep0[i & mask];
359 | if (ep->me_key == NULL((void *)0))
360 | return freeslot == NULL((void *)0) ? ep : freeslot;
361 | if (ep->me_key == key)
362 | return ep;
363 | if (ep->me_hash == hash && ep->me_key != dummy) {
364 | startkey = ep->me_key;
365 | Py_INCREF(startkey)( _Py_RefTotal++ , ((PyObject*)(startkey))->ob_refcnt++);
366 | cmp = PyObject_RichCompareBool(startkey, key, Py_EQ2);
367 | Py_DECREF(startkey)do { if (_Py_RefTotal-- , --((PyObject*)(startkey))->ob_refcnt != 0) { if (((PyObject*)startkey)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 367, (PyObject *)(startkey)); } else _Py_Dealloc((PyObject *)(startkey)); } while (0);
368 | if (cmp < 0)
369 | return NULL((void *)0);
370 | if (ep0 == mp->ma_table && ep->me_key == startkey) {
371 | if (cmp > 0)
372 | return ep;
373 | }
374 | else {
375 | /* The compare did major nasty stuff to the
376 | * dict: start over.
377 | * XXX A clever adversary could prevent this
378 | * XXX from terminating.
379 | */
380 | return lookdict(mp, key, hash);
381 | }
382 | }
383 | else if (ep->me_key == dummy && freeslot == NULL((void *)0))
384 | freeslot = ep;
385 | }
386 | assert(0)(__builtin_expect(!(0), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 386, "0") : (void)0); /* NOT REACHED */
387 | return 0;
388 | }
389 |
390 | /*
391 | * Hacked up version of lookdict which can assume keys are always
392 | * unicodes; this assumption allows testing for errors during
393 | * PyObject_RichCompareBool() to be dropped; unicode-unicode
394 | * comparisons never raise exceptions. This also means we don't need
395 | * to go through PyObject_RichCompareBool(); we can always use
396 | * unicode_eq() directly.
397 | *
398 | * This is valuable because dicts with only unicode keys are very common.
399 | */
400 | static PyDictEntry *
401 | lookdict_unicode(PyDictObject *mp, PyObject *key, register Py_hash_t hash)
402 | {
403 | register size_t i;
404 | register size_t perturb;
405 | register PyDictEntry *freeslot;
406 | register size_t mask = (size_t)mp->ma_mask;
407 | PyDictEntry *ep0 = mp->ma_table;
408 | register PyDictEntry *ep;
409 |
410 | /* Make sure this function doesn't have to handle non-unicode keys,
411 | including subclasses of str; e.g., one reason to subclass
412 | unicodes is to override __eq__, and for speed we don't cater to
413 | that here. */
414 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type)) {
415 | #ifdef SHOW_CONVERSION_COUNTS
416 | ++converted;
417 | #endif
418 | mp->ma_lookup = lookdict;
419 | return lookdict(mp, key, hash);
420 | }
421 | i = hash & mask;
422 | ep = &ep0[i];
423 | if (ep->me_key == NULL((void *)0) || ep->me_key == key)
424 | return ep;
425 | if (ep->me_key == dummy)
426 | freeslot = ep;
427 | else {
428 | if (ep->me_hash == hash && unicode_eq(ep->me_key, key))
429 | return ep;
430 | freeslot = NULL((void *)0);
431 | }
432 |
433 | /* In the loop, me_key == dummy is by far (factor of 100s) the
434 | least likely outcome, so test for that last. */
435 | for (perturb = hash; ; perturb >>= PERTURB_SHIFT5) {
436 | i = (i << 2) + i + perturb + 1;
437 | ep = &ep0[i & mask];
438 | if (ep->me_key == NULL((void *)0))
439 | return freeslot == NULL((void *)0) ? ep : freeslot;
440 | if (ep->me_key == key
441 | || (ep->me_hash == hash
442 | && ep->me_key != dummy
443 | && unicode_eq(ep->me_key, key)))
444 | return ep;
445 | if (ep->me_key == dummy && freeslot == NULL((void *)0))
446 | freeslot = ep;
447 | }
448 | assert(0)(__builtin_expect(!(0), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 448, "0") : (void)0); /* NOT REACHED */
449 | return 0;
450 | }
451 |
452 | int
453 | _PyDict_HasOnlyStringKeys(PyObject *dict)
454 | {
455 | Py_ssize_t pos = 0;
456 | PyObject *key, *value;
457 | assert(PyDict_Check(dict))(__builtin_expect(!(((((((PyObject*)(dict))->ob_type))-> tp_flags & ((1L<<29))) != 0)), 0) ? __assert_rtn(__func__ , "Objects/dictobject.c", 457, "PyDict_Check(dict)") : (void) 0);
458 | /* Shortcut */
459 | if (((PyDictObject *)dict)->ma_lookup == lookdict_unicode)
460 | return 1;
461 | while (PyDict_Next(dict, &pos, &key, &value))
462 | if (!PyUnicode_Check(key)((((((PyObject*)(key))->ob_type))->tp_flags & ((1L<< 28))) != 0))
463 | return 0;
464 | return 1;
465 | }
466 |
467 | #ifdef SHOW_TRACK_COUNT
468 | #define INCREASE_TRACK_COUNT \
469 | (count_tracked++, count_untracked--);
470 | #define DECREASE_TRACK_COUNT \
471 | (count_tracked--, count_untracked++);
472 | #else
473 | #define INCREASE_TRACK_COUNT
474 | #define DECREASE_TRACK_COUNT
475 | #endif
476 |
477 | #define MAINTAIN_TRACKING(mp, key, value)do { if (!((((PyGC_Head *)(mp)-1))->gc.gc_refs != (-2))) { if ((((((((((PyObject*)(key))->ob_type)))->tp_flags & ((1L<<14))) != 0) && ((((PyObject*)(key))-> ob_type)->tp_is_gc == ((void *)0) || (((PyObject*)(key))-> ob_type)->tp_is_gc(key))) && (!((((PyObject*)(key) )->ob_type) == &PyTuple_Type) || ((((PyGC_Head *)(key) -1))->gc.gc_refs != (-2)))) || (((((((((PyObject*)(value)) ->ob_type)))->tp_flags & ((1L<<14))) != 0) && ((((PyObject*)(value))->ob_type)->tp_is_gc == ((void * )0) || (((PyObject*)(value))->ob_type)->tp_is_gc(value) )) && (!((((PyObject*)(value))->ob_type) == &PyTuple_Type ) || ((((PyGC_Head *)(value)-1))->gc.gc_refs != (-2))))) { do { PyGC_Head *g = ((PyGC_Head *)(mp)-1); if (g->gc.gc_refs != (-2)) Py_FatalError("GC object already tracked"); g->gc .gc_refs = (-3); g->gc.gc_next = _PyGC_generation0; g-> gc.gc_prev = _PyGC_generation0->gc.gc_prev; g->gc.gc_prev ->gc.gc_next = g; _PyGC_generation0->gc.gc_prev = g; } while (0);; } } } while(0) \
478 | do { \
479 | if (!_PyObject_GC_IS_TRACKED(mp)((((PyGC_Head *)(mp)-1))->gc.gc_refs != (-2))) { \
480 | if (_PyObject_GC_MAY_BE_TRACKED(key)(((((((((PyObject*)(key))->ob_type)))->tp_flags & ( (1L<<14))) != 0) && ((((PyObject*)(key))->ob_type )->tp_is_gc == ((void *)0) || (((PyObject*)(key))->ob_type )->tp_is_gc(key))) && (!((((PyObject*)(key))->ob_type ) == &PyTuple_Type) || ((((PyGC_Head *)(key)-1))->gc.gc_refs != (-2)))) || \
481 | _PyObject_GC_MAY_BE_TRACKED(value)(((((((((PyObject*)(value))->ob_type)))->tp_flags & ((1L<<14))) != 0) && ((((PyObject*)(value))-> ob_type)->tp_is_gc == ((void *)0) || (((PyObject*)(value)) ->ob_type)->tp_is_gc(value))) && (!((((PyObject *)(value))->ob_type) == &PyTuple_Type) || ((((PyGC_Head *)(value)-1))->gc.gc_refs != (-2))))) { \
482 | _PyObject_GC_TRACK(mp)do { PyGC_Head *g = ((PyGC_Head *)(mp)-1); if (g->gc.gc_refs != (-2)) Py_FatalError("GC object already tracked"); g->gc .gc_refs = (-3); g->gc.gc_next = _PyGC_generation0; g-> gc.gc_prev = _PyGC_generation0->gc.gc_prev; g->gc.gc_prev ->gc.gc_next = g; _PyGC_generation0->gc.gc_prev = g; } while (0);; \
483 | INCREASE_TRACK_COUNT \
484 | } \
485 | } \
486 | } while(0)
487 |
488 | void
489 | _PyDict_MaybeUntrack(PyObject *op)
490 | {
491 | PyDictObject *mp;
492 | PyObject *value;
493 | Py_ssize_t mask, i;
494 | PyDictEntry *ep;
495 |
496 | if (!PyDict_CheckExact(op)((((PyObject*)(op))->ob_type) == &PyDict_Type) || !_PyObject_GC_IS_TRACKED(op)((((PyGC_Head *)(op)-1))->gc.gc_refs != (-2)))
497 | return;
498 |
499 | mp = (PyDictObject *) op;
500 | ep = mp->ma_table;
501 | mask = mp->ma_mask;
502 | for (i = 0; i <= mask; i++) {
503 | if ((value = ep[i].me_value) == NULL((void *)0))
504 | continue;
505 | if (_PyObject_GC_MAY_BE_TRACKED(value)(((((((((PyObject*)(value))->ob_type)))->tp_flags & ((1L<<14))) != 0) && ((((PyObject*)(value))-> ob_type)->tp_is_gc == ((void *)0) || (((PyObject*)(value)) ->ob_type)->tp_is_gc(value))) && (!((((PyObject *)(value))->ob_type) == &PyTuple_Type) || ((((PyGC_Head *)(value)-1))->gc.gc_refs != (-2)))) ||
506 | _PyObject_GC_MAY_BE_TRACKED(ep[i].me_key)(((((((((PyObject*)(ep[i].me_key))->ob_type)))->tp_flags & ((1L<<14))) != 0) && ((((PyObject*)(ep[i ].me_key))->ob_type)->tp_is_gc == ((void *)0) || (((PyObject *)(ep[i].me_key))->ob_type)->tp_is_gc(ep[i].me_key))) && (!((((PyObject*)(ep[i].me_key))->ob_type) == &PyTuple_Type ) || ((((PyGC_Head *)(ep[i].me_key)-1))->gc.gc_refs != (-2 )))))
507 | return;
508 | }
509 | DECREASE_TRACK_COUNT
510 | _PyObject_GC_UNTRACK(op)do { PyGC_Head *g = ((PyGC_Head *)(op)-1); (__builtin_expect( !(g->gc.gc_refs != (-2)), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 510, "g->gc.gc_refs != _PyGC_REFS_UNTRACKED") : (void)0) ; g->gc.gc_refs = (-2); g->gc.gc_prev->gc.gc_next = g ->gc.gc_next; g->gc.gc_next->gc.gc_prev = g->gc.gc_prev ; g->gc.gc_next = ((void *)0); } while (0);;
511 | }
512 |
513 |
514 | /*
515 | Internal routine to insert a new item into the table.
516 | Used both by the internal resize routine and by the public insert routine.
517 | Eats a reference to key and one to value.
518 | Returns -1 if an error occurred, or 0 on success.
519 | */
520 | static int
521 | insertdict(register PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject *value)
522 | {
523 | PyObject *old_value;
524 | register PyDictEntry *ep;
525 | typedef PyDictEntry *(*lookupfunc)(PyDictObject *, PyObject *, Py_hash_t);
526 |
527 | assert(mp->ma_lookup != NULL)(__builtin_expect(!(mp->ma_lookup != ((void *)0)), 0) ? __assert_rtn (__func__, "Objects/dictobject.c", 527, "mp->ma_lookup != NULL" ) : (void)0);
528 | ep = mp->ma_lookup(mp, key, hash);
529 | if (ep == NULL((void *)0)) {
530 | Py_DECREF(key)do { if (_Py_RefTotal-- , --((PyObject*)(key))->ob_refcnt != 0) { if (((PyObject*)key)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 530, (PyObject *)(key)); } else _Py_Dealloc ((PyObject *)(key)); } while (0);
531 | Py_DECREF(value)do { if (_Py_RefTotal-- , --((PyObject*)(value))->ob_refcnt != 0) { if (((PyObject*)value)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 531, (PyObject *)(value)); } else _Py_Dealloc ((PyObject *)(value)); } while (0);
532 | return -1;
533 | }
534 | MAINTAIN_TRACKING(mp, key, value)do { if (!((((PyGC_Head *)(mp)-1))->gc.gc_refs != (-2))) { if ((((((((((PyObject*)(key))->ob_type)))->tp_flags & ((1L<<14))) != 0) && ((((PyObject*)(key))-> ob_type)->tp_is_gc == ((void *)0) || (((PyObject*)(key))-> ob_type)->tp_is_gc(key))) && (!((((PyObject*)(key) )->ob_type) == &PyTuple_Type) || ((((PyGC_Head *)(key) -1))->gc.gc_refs != (-2)))) || (((((((((PyObject*)(value)) ->ob_type)))->tp_flags & ((1L<<14))) != 0) && ((((PyObject*)(value))->ob_type)->tp_is_gc == ((void * )0) || (((PyObject*)(value))->ob_type)->tp_is_gc(value) )) && (!((((PyObject*)(value))->ob_type) == &PyTuple_Type ) || ((((PyGC_Head *)(value)-1))->gc.gc_refs != (-2))))) { do { PyGC_Head *g = ((PyGC_Head *)(mp)-1); if (g->gc.gc_refs != (-2)) Py_FatalError("GC object already tracked"); g->gc .gc_refs = (-3); g->gc.gc_next = _PyGC_generation0; g-> gc.gc_prev = _PyGC_generation0->gc.gc_prev; g->gc.gc_prev ->gc.gc_next = g; _PyGC_generation0->gc.gc_prev = g; } while (0);; } } } while(0);
535 | if (ep->me_value != NULL((void *)0)) {
536 | old_value = ep->me_value;
537 | ep->me_value = value;
538 | Py_DECREF(old_value)do { if (_Py_RefTotal-- , --((PyObject*)(old_value))->ob_refcnt != 0) { if (((PyObject*)old_value)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 538, (PyObject *)(old_value)); } else _Py_Dealloc((PyObject *)(old_value)); } while (0); /* which **CAN** re-enter */
539 | Py_DECREF(key)do { if (_Py_RefTotal-- , --((PyObject*)(key))->ob_refcnt != 0) { if (((PyObject*)key)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 539, (PyObject *)(key)); } else _Py_Dealloc ((PyObject *)(key)); } while (0);
540 | }
541 | else {
542 | if (ep->me_key == NULL((void *)0))
543 | mp->ma_fill++;
544 | else {
545 | assert(ep->me_key == dummy)(__builtin_expect(!(ep->me_key == dummy), 0) ? __assert_rtn (__func__, "Objects/dictobject.c", 545, "ep->me_key == dummy" ) : (void)0);
546 | Py_DECREF(dummy)do { if (_Py_RefTotal-- , --((PyObject*)(dummy))->ob_refcnt != 0) { if (((PyObject*)dummy)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 546, (PyObject *)(dummy)); } else _Py_Dealloc ((PyObject *)(dummy)); } while (0);
547 | }
548 | ep->me_key = key;
549 | ep->me_hash = hash;
550 | ep->me_value = value;
551 | mp->ma_used++;
552 | }
553 | return 0;
554 | }
555 |
556 | /*
557 | Internal routine used by dictresize() to insert an item which is
558 | known to be absent from the dict. This routine also assumes that
559 | the dict contains no deleted entries. Besides the performance benefit,
560 | using insertdict() in dictresize() is dangerous (SF bug #1456209).
561 | Note that no refcounts are changed by this routine; if needed, the caller
562 | is responsible for incref'ing `key` and `value`.
563 | */
564 | static void
565 | insertdict_clean(register PyDictObject *mp, PyObject *key, Py_hash_t hash,
566 | PyObject *value)
567 | {
568 | register size_t i;
569 | register size_t perturb;
570 | register size_t mask = (size_t)mp->ma_mask;
571 | PyDictEntry *ep0 = mp->ma_table;
572 | register PyDictEntry *ep;
573 |
574 | MAINTAIN_TRACKING(mp, key, value)do { if (!((((PyGC_Head *)(mp)-1))->gc.gc_refs != (-2))) { if ((((((((((PyObject*)(key))->ob_type)))->tp_flags & ((1L<<14))) != 0) && ((((PyObject*)(key))-> ob_type)->tp_is_gc == ((void *)0) || (((PyObject*)(key))-> ob_type)->tp_is_gc(key))) && (!((((PyObject*)(key) )->ob_type) == &PyTuple_Type) || ((((PyGC_Head *)(key) -1))->gc.gc_refs != (-2)))) || (((((((((PyObject*)(value)) ->ob_type)))->tp_flags & ((1L<<14))) != 0) && ((((PyObject*)(value))->ob_type)->tp_is_gc == ((void * )0) || (((PyObject*)(value))->ob_type)->tp_is_gc(value) )) && (!((((PyObject*)(value))->ob_type) == &PyTuple_Type ) || ((((PyGC_Head *)(value)-1))->gc.gc_refs != (-2))))) { do { PyGC_Head *g = ((PyGC_Head *)(mp)-1); if (g->gc.gc_refs != (-2)) Py_FatalError("GC object already tracked"); g->gc .gc_refs = (-3); g->gc.gc_next = _PyGC_generation0; g-> gc.gc_prev = _PyGC_generation0->gc.gc_prev; g->gc.gc_prev ->gc.gc_next = g; _PyGC_generation0->gc.gc_prev = g; } while (0);; } } } while(0);
575 | i = hash & mask;
576 | ep = &ep0[i];
577 | for (perturb = hash; ep->me_key != NULL((void *)0); perturb >>= PERTURB_SHIFT5) {
578 | i = (i << 2) + i + perturb + 1;
579 | ep = &ep0[i & mask];
580 | }
581 | assert(ep->me_value == NULL)(__builtin_expect(!(ep->me_value == ((void *)0)), 0) ? __assert_rtn (__func__, "Objects/dictobject.c", 581, "ep->me_value == NULL" ) : (void)0);
582 | mp->ma_fill++;
583 | ep->me_key = key;
584 | ep->me_hash = hash;
585 | ep->me_value = value;
586 | mp->ma_used++;
587 | }
588 |
589 | /*
590 | Restructure the table by allocating a new table and reinserting all
591 | items again. When entries have been deleted, the new table may
592 | actually be smaller than the old one.
593 | */
594 | static int
595 | dictresize(PyDictObject *mp, Py_ssize_t minused)
596 | {
597 | Py_ssize_t newsize;
598 | PyDictEntry *oldtable, *newtable, *ep;
599 | Py_ssize_t i;
600 | int is_oldtable_malloced;
601 | PyDictEntry small_copy[PyDict_MINSIZE8];
602 |
603 | assert(minused >= 0)(__builtin_expect(!(minused >= 0), 0) ? __assert_rtn(__func__ , "Objects/dictobject.c", 603, "minused >= 0") : (void)0);
604 |
605 | /* Find the smallest table size > minused. */
606 | for (newsize = PyDict_MINSIZE8;
607 | newsize <= minused && newsize > 0;
608 | newsize <<= 1)
609 | ;
610 | if (newsize <= 0) {
611 | PyErr_NoMemory();
612 | return -1;
613 | }
614 |
615 | /* Get space for a new table. */
616 | oldtable = mp->ma_table;
617 | assert(oldtable != NULL)(__builtin_expect(!(oldtable != ((void *)0)), 0) ? __assert_rtn (__func__, "Objects/dictobject.c", 617, "oldtable != NULL") : (void)0);
618 | is_oldtable_malloced = oldtable != mp->ma_smalltable;
619 |
620 | if (newsize == PyDict_MINSIZE8) {
621 | /* A large table is shrinking, or we can't get any smaller. */
622 | newtable = mp->ma_smalltable;
623 | if (newtable == oldtable) {
624 | if (mp->ma_fill == mp->ma_used) {
625 | /* No dummies, so no point doing anything. */
626 | return 0;
627 | }
628 | /* We're not going to resize it, but rebuild the
629 | table anyway to purge old dummy entries.
630 | Subtle: This is *necessary* if fill==size,
631 | as lookdict needs at least one virgin slot to
632 | terminate failing searches. If fill < size, it's
633 | merely desirable, as dummies slow searches. */
634 | assert(mp->ma_fill > mp->ma_used)(__builtin_expect(!(mp->ma_fill > mp->ma_used), 0) ? __assert_rtn(__func__, "Objects/dictobject.c", 634, "mp->ma_fill > mp->ma_used" ) : (void)0);
635 | memcpy(small_copy, oldtable, sizeof(small_copy))((__builtin_object_size (small_copy, 0) != (size_t) -1) ? __builtin___memcpy_chk (small_copy, oldtable, sizeof(small_copy), __builtin_object_size (small_copy, 0)) : __inline_memcpy_chk (small_copy, oldtable , sizeof(small_copy)));
636 | oldtable = small_copy;
637 | }
638 | }
639 | else {
640 | newtable = PyMem_NEW(PyDictEntry, newsize)( ((size_t)(newsize) > ((Py_ssize_t)(((size_t)-1)>>1 )) / sizeof(PyDictEntry)) ? ((void *)0) : ( (PyDictEntry *) _PyMem_DebugMalloc ((newsize) * sizeof(PyDictEntry)) ) );
641 | if (newtable == NULL((void *)0)) {
642 | PyErr_NoMemory();
643 | return -1;
644 | }
645 | }
646 |
647 | /* Make the dict empty, using the new table. */
648 | assert(newtable != oldtable)(__builtin_expect(!(newtable != oldtable), 0) ? __assert_rtn( __func__, "Objects/dictobject.c", 648, "newtable != oldtable" ) : (void)0);
649 | mp->ma_table = newtable;
650 | mp->ma_mask = newsize - 1;
651 | memset(newtable, 0, sizeof(PyDictEntry) * newsize)((__builtin_object_size (newtable, 0) != (size_t) -1) ? __builtin___memset_chk (newtable, 0, sizeof(PyDictEntry) * newsize, __builtin_object_size (newtable, 0)) : __inline_memset_chk (newtable, 0, sizeof(PyDictEntry ) * newsize));
652 | mp->ma_used = 0;
653 | i = mp->ma_fill;
654 | mp->ma_fill = 0;
655 |
656 | /* Copy the data over; this is refcount-neutral for active entries;
657 | dummy entries aren't copied over, of course */
658 | for (ep = oldtable; i > 0; ep++) {
659 | if (ep->me_value != NULL((void *)0)) { /* active entry */
660 | --i;
661 | insertdict_clean(mp, ep->me_key, ep->me_hash, ep->me_value);
662 | }
663 | else if (ep->me_key != NULL((void *)0)) { /* dummy entry */
664 | --i;
665 | assert(ep->me_key == dummy)(__builtin_expect(!(ep->me_key == dummy), 0) ? __assert_rtn (__func__, "Objects/dictobject.c", 665, "ep->me_key == dummy" ) : (void)0);
666 | Py_DECREF(ep->me_key)do { if (_Py_RefTotal-- , --((PyObject*)(ep->me_key))-> ob_refcnt != 0) { if (((PyObject*)ep->me_key)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/dictobject.c", 666, (PyObject *)(ep->me_key)); } else _Py_Dealloc((PyObject *)(ep->me_key )); } while (0);
667 | }
668 | /* else key == value == NULL: nothing to do */
669 | }
670 |
671 | if (is_oldtable_malloced)
672 | PyMem_DEL_PyMem_DebugFree(oldtable);
673 | return 0;
674 | }
675 |
676 | /* Create a new dictionary pre-sized to hold an estimated number of elements.
677 | Underestimates are okay because the dictionary will resize as necessary.
678 | Overestimates just mean the dictionary will be more sparse than usual.
679 | */
680 |
681 | PyObject *
682 | _PyDict_NewPresized(Py_ssize_t minused)
683 | {
684 | PyObject *op = PyDict_New();
685 |
686 | if (minused>5 && op != NULL((void *)0) && dictresize((PyDictObject *)op, minused) == -1) {
687 | Py_DECREF(op)do { if (_Py_RefTotal-- , --((PyObject*)(op))->ob_refcnt != 0) { if (((PyObject*)op)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 687, (PyObject *)(op)); } else _Py_Dealloc ((PyObject *)(op)); } while (0);
688 | return NULL((void *)0);
689 | }
690 | return op;
691 | }
692 |
693 | /* Note that, for historical reasons, PyDict_GetItem() suppresses all errors
694 | * that may occur (originally dicts supported only string keys, and exceptions
695 | * weren't possible). So, while the original intent was that a NULL return
696 | * meant the key wasn't present, in reality it can mean that, or that an error
697 | * (suppressed) occurred while computing the key's hash, or that some error
698 | * (suppressed) occurred when comparing keys in the dict's internal probe
699 | * sequence. A nasty example of the latter is when a Python-coded comparison
700 | * function hits a stack-depth error, which can cause this to return NULL
701 | * even if the key is present.
702 | */
703 | PyObject *
704 | PyDict_GetItem(PyObject *op, PyObject *key)
705 | {
706 | Py_hash_t hash;
707 | PyDictObject *mp = (PyDictObject *)op;
708 | PyDictEntry *ep;
709 | PyThreadState *tstate;
710 | if (!PyDict_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1L<< 29))) != 0))
711 | return NULL((void *)0);
712 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type) ||
713 | (hash = ((PyUnicodeObject *) key)->hash) == -1)
714 | {
715 | hash = PyObject_Hash(key);
716 | if (hash == -1) {
717 | PyErr_Clear();
718 | return NULL((void *)0);
719 | }
720 | }
721 |
722 | /* We can arrive here with a NULL tstate during initialization: try
723 | running "python -Wi" for an example related to string interning.
724 | Let's just hope that no exception occurs then... This must be
725 | _PyThreadState_Current and not PyThreadState_GET() because in debug
726 | mode, the latter complains if tstate is NULL. */
727 | tstate = (PyThreadState*)_Py_atomic_load_relaxed(__extension__ ({ __typeof__(&_PyThreadState_Current) atomic_val = &_PyThreadState_Current; __typeof__(atomic_val->_value ) result; volatile __typeof__(result) *volatile_data = &atomic_val ->_value; _Py_memory_order order = _Py_memory_order_relaxed ; _Py_ANNOTATE_MEMORY_ORDER(atomic_val, order); ; switch(order ) { case _Py_memory_order_release: case _Py_memory_order_acq_rel : case _Py_memory_order_seq_cst: _Py_atomic_thread_fence(_Py_memory_order_release ); break; default: break; } result = *volatile_data; switch(order ) { case _Py_memory_order_acquire: case _Py_memory_order_acq_rel : case _Py_memory_order_seq_cst: _Py_atomic_signal_fence(_Py_memory_order_acquire ); break; default: break; } ; result; })
728 | &_PyThreadState_Current)__extension__ ({ __typeof__(&_PyThreadState_Current) atomic_val = &_PyThreadState_Current; __typeof__(atomic_val->_value ) result; volatile __typeof__(result) *volatile_data = &atomic_val ->_value; _Py_memory_order order = _Py_memory_order_relaxed ; _Py_ANNOTATE_MEMORY_ORDER(atomic_val, order); ; switch(order ) { case _Py_memory_order_release: case _Py_memory_order_acq_rel : case _Py_memory_order_seq_cst: _Py_atomic_thread_fence(_Py_memory_order_release ); break; default: break; } result = *volatile_data; switch(order ) { case _Py_memory_order_acquire: case _Py_memory_order_acq_rel : case _Py_memory_order_seq_cst: _Py_atomic_signal_fence(_Py_memory_order_acquire ); break; default: break; } ; result; });
729 | if (tstate != NULL((void *)0) && tstate->curexc_type != NULL((void *)0)) {
730 | /* preserve the existing exception */
731 | PyObject *err_type, *err_value, *err_tb;
732 | PyErr_Fetch(&err_type, &err_value, &err_tb);
733 | ep = (mp->ma_lookup)(mp, key, hash);
734 | /* ignore errors */
735 | PyErr_Restore(err_type, err_value, err_tb);
736 | if (ep == NULL((void *)0))
737 | return NULL((void *)0);
738 | }
739 | else {
740 | ep = (mp->ma_lookup)(mp, key, hash);
741 | if (ep == NULL((void *)0)) {
742 | PyErr_Clear();
743 | return NULL((void *)0);
744 | }
745 | }
746 | return ep->me_value;
747 | }
748 |
749 | /* Variant of PyDict_GetItem() that doesn't suppress exceptions.
750 | This returns NULL *with* an exception set if an exception occurred.
751 | It returns NULL *without* an exception set if the key wasn't present.
752 | */
753 | PyObject *
754 | PyDict_GetItemWithError(PyObject *op, PyObject *key)
755 | {
756 | Py_hash_t hash;
757 | PyDictObject*mp = (PyDictObject *)op;
758 | PyDictEntry *ep;
759 |
760 | if (!PyDict_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1L<< 29))) != 0)) {
761 | PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/dictobject.c", 761);
762 | return NULL((void *)0);
763 | }
764 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type) ||
765 | (hash = ((PyUnicodeObject *) key)->hash) == -1)
766 | {
767 | hash = PyObject_Hash(key);
768 | if (hash == -1) {
769 | return NULL((void *)0);
770 | }
771 | }
772 |
773 | ep = (mp->ma_lookup)(mp, key, hash);
774 | if (ep == NULL((void *)0))
775 | return NULL((void *)0);
776 | return ep->me_value;
777 | }
778 |
779 | /* CAUTION: PyDict_SetItem() must guarantee that it won't resize the
780 | * dictionary if it's merely replacing the value for an existing key.
781 | * This means that it's safe to loop over a dictionary with PyDict_Next()
782 | * and occasionally replace a value -- but you can't insert new keys or
783 | * remove them.
784 | */
785 | int
786 | PyDict_SetItem(register PyObject *op, PyObject *key, PyObject *value)
787 | {
788 | register PyDictObject *mp;
789 | register Py_hash_t hash;
790 | register Py_ssize_t n_used;
791 |
792 | if (!PyDict_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1L<< 29))) != 0)) {
793 | PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/dictobject.c", 793);
794 | return -1;
795 | }
796 | assert(key)(__builtin_expect(!(key), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 796, "key") : (void)0);
797 | assert(value)(__builtin_expect(!(value), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 797, "value") : (void)0);
798 | mp = (PyDictObject *)op;
799 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type) ||
800 | (hash = ((PyUnicodeObject *) key)->hash) == -1)
801 | {
802 | hash = PyObject_Hash(key);
803 | if (hash == -1)
804 | return -1;
805 | }
806 | assert(mp->ma_fill <= mp->ma_mask)(__builtin_expect(!(mp->ma_fill <= mp->ma_mask), 0) ? __assert_rtn(__func__, "Objects/dictobject.c", 806, "mp->ma_fill <= mp->ma_mask" ) : (void)0); /* at least one empty slot */
807 | n_used = mp->ma_used;
808 | Py_INCREF(value)( _Py_RefTotal++ , ((PyObject*)(value))->ob_refcnt++);
809 | Py_INCREF(key)( _Py_RefTotal++ , ((PyObject*)(key))->ob_refcnt++);
810 | if (insertdict(mp, key, hash, value) != 0)
811 | return -1;
812 | /* If we added a key, we can safely resize. Otherwise just return!
813 | * If fill >= 2/3 size, adjust size. Normally, this doubles or
814 | * quaduples the size, but it's also possible for the dict to shrink
815 | * (if ma_fill is much larger than ma_used, meaning a lot of dict
816 | * keys have been * deleted).
817 | *
818 | * Quadrupling the size improves average dictionary sparseness
819 | * (reducing collisions) at the cost of some memory and iteration
820 | * speed (which loops over every possible entry). It also halves
821 | * the number of expensive resize operations in a growing dictionary.
822 | *
823 | * Very large dictionaries (over 50K items) use doubling instead.
824 | * This may help applications with severe memory constraints.
825 | */
826 | if (!(mp->ma_used > n_used && mp->ma_fill*3 >= (mp->ma_mask+1)*2))
827 | return 0;
828 | return dictresize(mp, (mp->ma_used > 50000 ? 2 : 4) * mp->ma_used);
829 | }
830 |
831 | int
832 | PyDict_DelItem(PyObject *op, PyObject *key)
833 | {
834 | register PyDictObject *mp;
835 | register Py_hash_t hash;
836 | register PyDictEntry *ep;
837 | PyObject *old_value, *old_key;
838 |
839 | if (!PyDict_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1L<< 29))) != 0)) {
840 | PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/dictobject.c", 840);
841 | return -1;
842 | }
843 | assert(key)(__builtin_expect(!(key), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 843, "key") : (void)0);
844 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type) ||
845 | (hash = ((PyUnicodeObject *) key)->hash) == -1) {
846 | hash = PyObject_Hash(key);
847 | if (hash == -1)
848 | return -1;
849 | }
850 | mp = (PyDictObject *)op;
851 | ep = (mp->ma_lookup)(mp, key, hash);
852 | if (ep == NULL((void *)0))
853 | return -1;
854 | if (ep->me_value == NULL((void *)0)) {
855 | set_key_error(key);
856 | return -1;
857 | }
858 | old_key = ep->me_key;
859 | Py_INCREF(dummy)( _Py_RefTotal++ , ((PyObject*)(dummy))->ob_refcnt++);
860 | ep->me_key = dummy;
861 | old_value = ep->me_value;
862 | ep->me_value = NULL((void *)0);
863 | mp->ma_used--;
864 | Py_DECREF(old_value)do { if (_Py_RefTotal-- , --((PyObject*)(old_value))->ob_refcnt != 0) { if (((PyObject*)old_value)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 864, (PyObject *)(old_value)); } else _Py_Dealloc((PyObject *)(old_value)); } while (0);
865 | Py_DECREF(old_key)do { if (_Py_RefTotal-- , --((PyObject*)(old_key))->ob_refcnt != 0) { if (((PyObject*)old_key)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 865, (PyObject *)(old_key)); } else _Py_Dealloc ((PyObject *)(old_key)); } while (0);
866 | return 0;
867 | }
868 |
869 | void
870 | PyDict_Clear(PyObject *op)
871 | {
872 | PyDictObject *mp;
873 | PyDictEntry *ep, *table;
874 | int table_is_malloced;
875 | Py_ssize_t fill;
876 | PyDictEntry small_copy[PyDict_MINSIZE8];
877 | #ifdef Py_DEBUG1
878 | Py_ssize_t i, n;
879 | #endif
880 |
881 | if (!PyDict_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1L<< 29))) != 0))
882 | return;
883 | mp = (PyDictObject *)op;
884 | #ifdef Py_DEBUG1
885 | n = mp->ma_mask + 1;
886 | i = 0;
887 | #endif
888 |
889 | table = mp->ma_table;
890 | assert(table != NULL)(__builtin_expect(!(table != ((void *)0)), 0) ? __assert_rtn( __func__, "Objects/dictobject.c", 890, "table != NULL") : (void )0);
891 | table_is_malloced = table != mp->ma_smalltable;
892 |
893 | /* This is delicate. During the process of clearing the dict,
894 | * decrefs can cause the dict to mutate. To avoid fatal confusion
895 | * (voice of experience), we have to make the dict empty before
896 | * clearing the slots, and never refer to anything via mp->xxx while
897 | * clearing.
898 | */
899 | fill = mp->ma_fill;
900 | if (table_is_malloced)
901 | EMPTY_TO_MINSIZE(mp)do { ((__builtin_object_size ((mp)->ma_smalltable, 0) != ( size_t) -1) ? __builtin___memset_chk ((mp)->ma_smalltable, 0, sizeof((mp)->ma_smalltable), __builtin_object_size ((mp )->ma_smalltable, 0)) : __inline_memset_chk ((mp)->ma_smalltable , 0, sizeof((mp)->ma_smalltable))); (mp)->ma_used = (mp )->ma_fill = 0; do { (mp)->ma_table = (mp)->ma_smalltable ; (mp)->ma_mask = 8 - 1; } while(0); } while(0);
902 |
903 | else if (fill > 0) {
904 | /* It's a small table with something that needs to be cleared.
905 | * Afraid the only safe way is to copy the dict entries into
906 | * another small table first.
907 | */
908 | memcpy(small_copy, table, sizeof(small_copy))((__builtin_object_size (small_copy, 0) != (size_t) -1) ? __builtin___memcpy_chk (small_copy, table, sizeof(small_copy), __builtin_object_size (small_copy, 0)) : __inline_memcpy_chk (small_copy, table, sizeof (small_copy)));
909 | table = small_copy;
910 | EMPTY_TO_MINSIZE(mp)do { ((__builtin_object_size ((mp)->ma_smalltable, 0) != ( size_t) -1) ? __builtin___memset_chk ((mp)->ma_smalltable, 0, sizeof((mp)->ma_smalltable), __builtin_object_size ((mp )->ma_smalltable, 0)) : __inline_memset_chk ((mp)->ma_smalltable , 0, sizeof((mp)->ma_smalltable))); (mp)->ma_used = (mp )->ma_fill = 0; do { (mp)->ma_table = (mp)->ma_smalltable ; (mp)->ma_mask = 8 - 1; } while(0); } while(0);
911 | }
912 | /* else it's a small table that's already empty */
913 |
914 | /* Now we can finally clear things. If C had refcounts, we could
915 | * assert that the refcount on table is 1 now, i.e. that this function
916 | * has unique access to it, so decref side-effects can't alter it.
917 | */
918 | for (ep = table; fill > 0; ++ep) {
919 | #ifdef Py_DEBUG1
920 | assert(i < n)(__builtin_expect(!(i < n), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 920, "i < n") : (void)0);
921 | ++i;
922 | #endif
923 | if (ep->me_key) {
924 | --fill;
925 | Py_DECREF(ep->me_key)do { if (_Py_RefTotal-- , --((PyObject*)(ep->me_key))-> ob_refcnt != 0) { if (((PyObject*)ep->me_key)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/dictobject.c", 925, (PyObject *)(ep->me_key)); } else _Py_Dealloc((PyObject *)(ep->me_key )); } while (0);
926 | Py_XDECREF(ep->me_value)do { if ((ep->me_value) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(ep->me_value))->ob_refcnt != 0) { if (((PyObject*)ep->me_value)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 926, (PyObject *)(ep->me_value)); } else _Py_Dealloc((PyObject *)(ep->me_value)); } while ( 0); } while (0);
927 | }
928 | #ifdef Py_DEBUG1
929 | else
930 | assert(ep->me_value == NULL)(__builtin_expect(!(ep->me_value == ((void *)0)), 0) ? __assert_rtn (__func__, "Objects/dictobject.c", 930, "ep->me_value == NULL" ) : (void)0);
931 | #endif
932 | }
933 |
934 | if (table_is_malloced)
935 | PyMem_DEL_PyMem_DebugFree(table);
936 | }
937 |
938 | /*
939 | * Iterate over a dict. Use like so:
940 | *
941 | * Py_ssize_t i;
942 | * PyObject *key, *value;
943 | * i = 0; # important! i should not otherwise be changed by you
944 | * while (PyDict_Next(yourdict, &i, &key, &value)) {
945 | * Refer to borrowed references in key and value.
946 | * }
947 | *
948 | * CAUTION: In general, it isn't safe to use PyDict_Next in a loop that
949 | * mutates the dict. One exception: it is safe if the loop merely changes
950 | * the values associated with the keys (but doesn't insert new keys or
951 | * delete keys), via PyDict_SetItem().
952 | */
953 | int
954 | PyDict_Next(PyObject *op, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue)
955 | {
956 | register Py_ssize_t i;
957 | register Py_ssize_t mask;
958 | register PyDictEntry *ep;
959 |
960 | if (!PyDict_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1L<< 29))) != 0))
961 | return 0;
962 | i = *ppos;
963 | if (i < 0)
964 | return 0;
965 | ep = ((PyDictObject *)op)->ma_table;
966 | mask = ((PyDictObject *)op)->ma_mask;
967 | while (i <= mask && ep[i].me_value == NULL((void *)0))
968 | i++;
969 | *ppos = i+1;
970 | if (i > mask)
971 | return 0;
972 | if (pkey)
973 | *pkey = ep[i].me_key;
974 | if (pvalue)
975 | *pvalue = ep[i].me_value;
976 | return 1;
977 | }
978 |
979 | /* Internal version of PyDict_Next that returns a hash value in addition to the key and value.*/
980 | int
981 | _PyDict_Next(PyObject *op, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue, Py_hash_t *phash)
982 | {
983 | register Py_ssize_t i;
984 | register Py_ssize_t mask;
985 | register PyDictEntry *ep;
986 |
987 | if (!PyDict_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1L<< 29))) != 0))
988 | return 0;
989 | i = *ppos;
990 | if (i < 0)
991 | return 0;
992 | ep = ((PyDictObject *)op)->ma_table;
993 | mask = ((PyDictObject *)op)->ma_mask;
994 | while (i <= mask && ep[i].me_value == NULL((void *)0))
995 | i++;
996 | *ppos = i+1;
997 | if (i > mask)
998 | return 0;
999 | *phash = ep[i].me_hash;
1000 | if (pkey)
1001 | *pkey = ep[i].me_key;
1002 | if (pvalue)
1003 | *pvalue = ep[i].me_value;
1004 | return 1;
1005 | }
1006 |
1007 | /* Methods */
1008 |
1009 | static void
1010 | dict_dealloc(register PyDictObject *mp)
1011 | {
1012 | register PyDictEntry *ep;
1013 | Py_ssize_t fill = mp->ma_fill;
1014 | PyObject_GC_UnTrack(mp);
1015 | Py_TRASHCAN_SAFE_BEGIN(mp)if (_PyTrash_delete_nesting < 50) { ++_PyTrash_delete_nesting ;
1016 | for (ep = mp->ma_table; fill > 0; ep++) {
1017 | if (ep->me_key) {
1018 | --fill;
1019 | Py_DECREF(ep->me_key)do { if (_Py_RefTotal-- , --((PyObject*)(ep->me_key))-> ob_refcnt != 0) { if (((PyObject*)ep->me_key)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/dictobject.c", 1019, ( PyObject *)(ep->me_key)); } else _Py_Dealloc((PyObject *)( ep->me_key)); } while (0);
1020 | Py_XDECREF(ep->me_value)do { if ((ep->me_value) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(ep->me_value))->ob_refcnt != 0) { if (((PyObject*)ep->me_value)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1020, (PyObject *)(ep->me_value)) ; } else _Py_Dealloc((PyObject *)(ep->me_value)); } while ( 0); } while (0);
1021 | }
1022 | }
1023 | if (mp->ma_table != mp->ma_smalltable)
1024 | PyMem_DEL_PyMem_DebugFree(mp->ma_table);
1025 | if (numfree < PyDict_MAXFREELIST80 && Py_TYPE(mp)(((PyObject*)(mp))->ob_type) == &PyDict_Type)
1026 | free_list[numfree++] = mp;
1027 | else
1028 | Py_TYPE(mp)(((PyObject*)(mp))->ob_type)->tp_free((PyObject *)mp);
1029 | Py_TRASHCAN_SAFE_END(mp)--_PyTrash_delete_nesting; if (_PyTrash_delete_later && _PyTrash_delete_nesting <= 0) _PyTrash_destroy_chain(); } else _PyTrash_deposit_object((PyObject*)mp);
1030 | }
1031 |
1032 | static PyObject *
1033 | dict_repr(PyDictObject *mp)
1034 | {
1035 | Py_ssize_t i;
1036 | PyObject *s, *temp, *colon = NULL((void *)0);
1037 | PyObject *pieces = NULL((void *)0), *result = NULL((void *)0);
1038 | PyObject *key, *value;
1039 |
1040 | i = Py_ReprEnter((PyObject *)mp);
1041 | if (i != 0) {
1042 | return i > 0 ? PyUnicode_FromStringPyUnicodeUCS2_FromString("{...}") : NULL((void *)0);
1043 | }
1044 |
1045 | if (mp->ma_used == 0) {
1046 | result = PyUnicode_FromStringPyUnicodeUCS2_FromString("{}");
1047 | goto Done;
1048 | }
1049 |
1050 | pieces = PyList_New(0);
1051 | if (pieces == NULL((void *)0))
1052 | goto Done;
1053 |
1054 | colon = PyUnicode_FromStringPyUnicodeUCS2_FromString(": ");
1055 | if (colon == NULL((void *)0))
1056 | goto Done;
1057 |
1058 | /* Do repr() on each key+value pair, and insert ": " between them.
1059 | Note that repr may mutate the dict. */
1060 | i = 0;
1061 | while (PyDict_Next((PyObject *)mp, &i, &key, &value)) {
1062 | int status;
1063 | /* Prevent repr from deleting value during key format. */
1064 | Py_INCREF(value)( _Py_RefTotal++ , ((PyObject*)(value))->ob_refcnt++);
1065 | s = PyObject_Repr(key);
1066 | PyUnicode_AppendPyUnicodeUCS2_Append(&s, colon);
1067 | PyUnicode_AppendAndDelPyUnicodeUCS2_AppendAndDel(&s, PyObject_Repr(value));
1068 | Py_DECREF(value)do { if (_Py_RefTotal-- , --((PyObject*)(value))->ob_refcnt != 0) { if (((PyObject*)value)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1068, (PyObject *)(value)); } else _Py_Dealloc ((PyObject *)(value)); } while (0);
1069 | if (s == NULL((void *)0))
1070 | goto Done;
1071 | status = PyList_Append(pieces, s);
1072 | Py_DECREF(s)do { if (_Py_RefTotal-- , --((PyObject*)(s))->ob_refcnt != 0) { if (((PyObject*)s)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1072, (PyObject *)(s)); } else _Py_Dealloc ((PyObject *)(s)); } while (0); /* append created a new ref */
1073 | if (status < 0)
1074 | goto Done;
1075 | }
1076 |
1077 | /* Add "{}" decorations to the first and last items. */
1078 | assert(PyList_GET_SIZE(pieces) > 0)(__builtin_expect(!((((PyVarObject*)(pieces))->ob_size) > 0), 0) ? __assert_rtn(__func__, "Objects/dictobject.c", 1078 , "PyList_GET_SIZE(pieces) > 0") : (void)0);
1079 | s = PyUnicode_FromStringPyUnicodeUCS2_FromString("{");
1080 | if (s == NULL((void *)0))
1081 | goto Done;
1082 | temp = PyList_GET_ITEM(pieces, 0)(((PyListObject *)(pieces))->ob_item[0]);
1083 | PyUnicode_AppendAndDelPyUnicodeUCS2_AppendAndDel(&s, temp);
1084 | PyList_SET_ITEM(pieces, 0, s)(((PyListObject *)(pieces))->ob_item[0] = (s));
1085 | if (s == NULL((void *)0))
1086 | goto Done;
1087 |
1088 | s = PyUnicode_FromStringPyUnicodeUCS2_FromString("}");
1089 | if (s == NULL((void *)0))
1090 | goto Done;
1091 | temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1)(((PyListObject *)(pieces))->ob_item[(((PyVarObject*)(pieces ))->ob_size) - 1]);
1092 | PyUnicode_AppendAndDelPyUnicodeUCS2_AppendAndDel(&temp, s);
1093 | PyList_SET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1, temp)(((PyListObject *)(pieces))->ob_item[(((PyVarObject*)(pieces ))->ob_size) - 1] = (temp));
1094 | if (temp == NULL((void *)0))
1095 | goto Done;
1096 |
1097 | /* Paste them all together with ", " between. */
1098 | s = PyUnicode_FromStringPyUnicodeUCS2_FromString(", ");
1099 | if (s == NULL((void *)0))
1100 | goto Done;
1101 | result = PyUnicode_JoinPyUnicodeUCS2_Join(s, pieces);
1102 | Py_DECREF(s)do { if (_Py_RefTotal-- , --((PyObject*)(s))->ob_refcnt != 0) { if (((PyObject*)s)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1102, (PyObject *)(s)); } else _Py_Dealloc ((PyObject *)(s)); } while (0);
1103 |
1104 | Done:
1105 | Py_XDECREF(pieces)do { if ((pieces) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(pieces))->ob_refcnt != 0) { if (((PyObject *)pieces)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/dictobject.c" , 1105, (PyObject *)(pieces)); } else _Py_Dealloc((PyObject * )(pieces)); } while (0); } while (0);
1106 | Py_XDECREF(colon)do { if ((colon) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(colon))->ob_refcnt != 0) { if (((PyObject *)colon)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/dictobject.c" , 1106, (PyObject *)(colon)); } else _Py_Dealloc((PyObject *) (colon)); } while (0); } while (0);
1107 | Py_ReprLeave((PyObject *)mp);
1108 | return result;
1109 | }
1110 |
1111 | static Py_ssize_t
1112 | dict_length(PyDictObject *mp)
1113 | {
1114 | return mp->ma_used;
1115 | }
1116 |
1117 | static PyObject *
1118 | dict_subscript(PyDictObject *mp, register PyObject *key)
1119 | {
1120 | PyObject *v;
1121 | Py_hash_t hash;
1122 | PyDictEntry *ep;
1123 | assert(mp->ma_table != NULL)(__builtin_expect(!(mp->ma_table != ((void *)0)), 0) ? __assert_rtn (__func__, "Objects/dictobject.c", 1123, "mp->ma_table != NULL" ) : (void)0);
1124 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type) ||
1125 | (hash = ((PyUnicodeObject *) key)->hash) == -1) {
1126 | hash = PyObject_Hash(key);
1127 | if (hash == -1)
1128 | return NULL((void *)0);
1129 | }
1130 | ep = (mp->ma_lookup)(mp, key, hash);
1131 | if (ep == NULL((void *)0))
1132 | return NULL((void *)0);
1133 | v = ep->me_value;
1134 | if (v == NULL((void *)0)) {
1135 | if (!PyDict_CheckExact(mp)((((PyObject*)(mp))->ob_type) == &PyDict_Type)) {
1136 | /* Look up __missing__ method if we're a subclass. */
1137 | PyObject *missing, *res;
1138 | static PyObject *missing_str = NULL((void *)0);
1139 | missing = _PyObject_LookupSpecial((PyObject *)mp,
1140 | "__missing__",
1141 | &missing_str);
1142 | if (missing != NULL((void *)0)) {
1143 | res = PyObject_CallFunctionObjArgs(missing,
1144 | key, NULL((void *)0));
1145 | Py_DECREF(missing)do { if (_Py_RefTotal-- , --((PyObject*)(missing))->ob_refcnt != 0) { if (((PyObject*)missing)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1145, (PyObject *)(missing)); } else _Py_Dealloc((PyObject *)(missing)); } while (0);
1146 | return res;
1147 | }
1148 | else if (PyErr_Occurred())
1149 | return NULL((void *)0);
1150 | }
1151 | set_key_error(key);
1152 | return NULL((void *)0);
1153 | }
1154 | else
1155 | Py_INCREF(v)( _Py_RefTotal++ , ((PyObject*)(v))->ob_refcnt++);
1156 | return v;
1157 | }
1158 |
1159 | static int
1160 | dict_ass_sub(PyDictObject *mp, PyObject *v, PyObject *w)
1161 | {
1162 | if (w == NULL((void *)0))
1163 | return PyDict_DelItem((PyObject *)mp, v);
1164 | else
1165 | return PyDict_SetItem((PyObject *)mp, v, w);
1166 | }
1167 |
1168 | static PyMappingMethods dict_as_mapping = {
1169 | (lenfunc)dict_length, /*mp_length*/
1170 | (binaryfunc)dict_subscript, /*mp_subscript*/
1171 | (objobjargproc)dict_ass_sub, /*mp_ass_subscript*/
1172 | };
1173 |
1174 | static PyObject *
1175 | dict_keys(register PyDictObject *mp)
1176 | {
1177 | register PyObject *v;
1178 | register Py_ssize_t i, j;
1179 | PyDictEntry *ep;
1180 | Py_ssize_t mask, n;
1181 |
1182 | again:
1183 | n = mp->ma_used;
1184 | v = PyList_New(n);
1185 | if (v == NULL((void *)0))
1186 | return NULL((void *)0);
1187 | if (n != mp->ma_used) {
1188 | /* Durnit. The allocations caused the dict to resize.
1189 | * Just start over, this shouldn't normally happen.
1190 | */
1191 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1191, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1192 | goto again;
1193 | }
1194 | ep = mp->ma_table;
1195 | mask = mp->ma_mask;
1196 | for (i = 0, j = 0; i <= mask; i++) {
1197 | if (ep[i].me_value != NULL((void *)0)) {
1198 | PyObject *key = ep[i].me_key;
1199 | Py_INCREF(key)( _Py_RefTotal++ , ((PyObject*)(key))->ob_refcnt++);
1200 | PyList_SET_ITEM(v, j, key)(((PyListObject *)(v))->ob_item[j] = (key));
1201 | j++;
1202 | }
1203 | }
1204 | assert(j == n)(__builtin_expect(!(j == n), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 1204, "j == n") : (void)0);
1205 | return v;
1206 | }
1207 |
1208 | static PyObject *
1209 | dict_values(register PyDictObject *mp)
1210 | {
1211 | register PyObject *v;
1212 | register Py_ssize_t i, j;
1213 | PyDictEntry *ep;
1214 | Py_ssize_t mask, n;
1215 |
1216 | again:
1217 | n = mp->ma_used;
1218 | v = PyList_New(n);
1219 | if (v == NULL((void *)0))
1220 | return NULL((void *)0);
1221 | if (n != mp->ma_used) {
1222 | /* Durnit. The allocations caused the dict to resize.
1223 | * Just start over, this shouldn't normally happen.
1224 | */
1225 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1225, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1226 | goto again;
1227 | }
1228 | ep = mp->ma_table;
1229 | mask = mp->ma_mask;
1230 | for (i = 0, j = 0; i <= mask; i++) {
1231 | if (ep[i].me_value != NULL((void *)0)) {
1232 | PyObject *value = ep[i].me_value;
1233 | Py_INCREF(value)( _Py_RefTotal++ , ((PyObject*)(value))->ob_refcnt++);
1234 | PyList_SET_ITEM(v, j, value)(((PyListObject *)(v))->ob_item[j] = (value));
1235 | j++;
1236 | }
1237 | }
1238 | assert(j == n)(__builtin_expect(!(j == n), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 1238, "j == n") : (void)0);
1239 | return v;
1240 | }
1241 |
1242 | static PyObject *
1243 | dict_items(register PyDictObject *mp)
1244 | {
1245 | register PyObject *v;
1246 | register Py_ssize_t i, j, n;
1247 | Py_ssize_t mask;
1248 | PyObject *item, *key, *value;
1249 | PyDictEntry *ep;
1250 |
1251 | /* Preallocate the list of tuples, to avoid allocations during
1252 | * the loop over the items, which could trigger GC, which
1253 | * could resize the dict. :-(
1254 | */
1255 | again:
1256 | n = mp->ma_used;
1257 | v = PyList_New(n);
1258 | if (v == NULL((void *)0))
1259 | return NULL((void *)0);
1260 | for (i = 0; i < n; i++) {
1261 | item = PyTuple_New(2);
1262 | if (item == NULL((void *)0)) {
1263 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1263, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1264 | return NULL((void *)0);
1265 | }
1266 | PyList_SET_ITEM(v, i, item)(((PyListObject *)(v))->ob_item[i] = (item));
1267 | }
1268 | if (n != mp->ma_used) {
1269 | /* Durnit. The allocations caused the dict to resize.
1270 | * Just start over, this shouldn't normally happen.
1271 | */
1272 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1272, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1273 | goto again;
1274 | }
1275 | /* Nothing we do below makes any function calls. */
1276 | ep = mp->ma_table;
1277 | mask = mp->ma_mask;
1278 | for (i = 0, j = 0; i <= mask; i++) {
1279 | if ((value=ep[i].me_value) != NULL((void *)0)) {
1280 | key = ep[i].me_key;
1281 | item = PyList_GET_ITEM(v, j)(((PyListObject *)(v))->ob_item[j]);
1282 | Py_INCREF(key)( _Py_RefTotal++ , ((PyObject*)(key))->ob_refcnt++);
1283 | PyTuple_SET_ITEM(item, 0, key)(((PyTupleObject *)(item))->ob_item[0] = key);
1284 | Py_INCREF(value)( _Py_RefTotal++ , ((PyObject*)(value))->ob_refcnt++);
1285 | PyTuple_SET_ITEM(item, 1, value)(((PyTupleObject *)(item))->ob_item[1] = value);
1286 | j++;
1287 | }
1288 | }
1289 | assert(j == n)(__builtin_expect(!(j == n), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 1289, "j == n") : (void)0);
1290 | return v;
1291 | }
1292 |
1293 | static PyObject *
1294 | dict_fromkeys(PyObject *cls, PyObject *args)
1295 | {
1296 | PyObject *seq;
1297 | PyObject *value = Py_None(&_Py_NoneStruct);
1298 | PyObject *it; /* iter(seq) */
1299 | PyObject *key;
1300 | PyObject *d;
1301 | int status;
1302 |
1303 | if (!PyArg_UnpackTuple(args, "fromkeys", 1, 2, &seq, &value))
1304 | return NULL((void *)0);
1305 |
1306 | d = PyObject_CallObject(cls, NULL((void *)0));
1307 | if (d == NULL((void *)0))
1308 | return NULL((void *)0);
1309 |
1310 | if (PyDict_CheckExact(d)((((PyObject*)(d))->ob_type) == &PyDict_Type) && PyDict_CheckExact(seq)((((PyObject*)(seq))->ob_type) == &PyDict_Type)) {
1311 | PyDictObject *mp = (PyDictObject *)d;
1312 | PyObject *oldvalue;
1313 | Py_ssize_t pos = 0;
1314 | PyObject *key;
1315 | Py_hash_t hash;
1316 |
1317 | if (dictresize(mp, Py_SIZE(seq)(((PyVarObject*)(seq))->ob_size)))
1318 | return NULL((void *)0);
1319 |
1320 | while (_PyDict_Next(seq, &pos, &key, &oldvalue, &hash)) {
1321 | Py_INCREF(key)( _Py_RefTotal++ , ((PyObject*)(key))->ob_refcnt++);
1322 | Py_INCREF(value)( _Py_RefTotal++ , ((PyObject*)(value))->ob_refcnt++);
1323 | if (insertdict(mp, key, hash, value))
1324 | return NULL((void *)0);
1325 | }
1326 | return d;
1327 | }
1328 |
1329 | if (PyDict_CheckExact(d)((((PyObject*)(d))->ob_type) == &PyDict_Type) && PyAnySet_CheckExact(seq)((((PyObject*)(seq))->ob_type) == &PySet_Type || (((PyObject *)(seq))->ob_type) == &PyFrozenSet_Type)) {
1330 | PyDictObject *mp = (PyDictObject *)d;
1331 | Py_ssize_t pos = 0;
1332 | PyObject *key;
1333 | Py_hash_t hash;
1334 |
1335 | if (dictresize(mp, PySet_GET_SIZE(seq)(((PySetObject *)(seq))->used)))
1336 | return NULL((void *)0);
1337 |
1338 | while (_PySet_NextEntry(seq, &pos, &key, &hash)) {
1339 | Py_INCREF(key)( _Py_RefTotal++ , ((PyObject*)(key))->ob_refcnt++);
1340 | Py_INCREF(value)( _Py_RefTotal++ , ((PyObject*)(value))->ob_refcnt++);
1341 | if (insertdict(mp, key, hash, value))
1342 | return NULL((void *)0);
1343 | }
1344 | return d;
1345 | }
1346 |
1347 | it = PyObject_GetIter(seq);
1348 | if (it == NULL((void *)0)){
1349 | Py_DECREF(d)do { if (_Py_RefTotal-- , --((PyObject*)(d))->ob_refcnt != 0) { if (((PyObject*)d)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1349, (PyObject *)(d)); } else _Py_Dealloc ((PyObject *)(d)); } while (0);
1350 | return NULL((void *)0);
1351 | }
1352 |
1353 | if (PyDict_CheckExact(d)((((PyObject*)(d))->ob_type) == &PyDict_Type)) {
1354 | while ((key = PyIter_Next(it)) != NULL((void *)0)) {
1355 | status = PyDict_SetItem(d, key, value);
1356 | Py_DECREF(key)do { if (_Py_RefTotal-- , --((PyObject*)(key))->ob_refcnt != 0) { if (((PyObject*)key)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1356, (PyObject *)(key)); } else _Py_Dealloc ((PyObject *)(key)); } while (0);
1357 | if (status < 0)
1358 | goto Fail;
1359 | }
1360 | } else {
1361 | while ((key = PyIter_Next(it)) != NULL((void *)0)) {
1362 | status = PyObject_SetItem(d, key, value);
1363 | Py_DECREF(key)do { if (_Py_RefTotal-- , --((PyObject*)(key))->ob_refcnt != 0) { if (((PyObject*)key)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1363, (PyObject *)(key)); } else _Py_Dealloc ((PyObject *)(key)); } while (0);
1364 | if (status < 0)
1365 | goto Fail;
1366 | }
1367 | }
1368 |
1369 | if (PyErr_Occurred())
1370 | goto Fail;
1371 | Py_DECREF(it)do { if (_Py_RefTotal-- , --((PyObject*)(it))->ob_refcnt != 0) { if (((PyObject*)it)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1371, (PyObject *)(it)); } else _Py_Dealloc ((PyObject *)(it)); } while (0);
1372 | return d;
1373 |
1374 | Fail:
1375 | Py_DECREF(it)do { if (_Py_RefTotal-- , --((PyObject*)(it))->ob_refcnt != 0) { if (((PyObject*)it)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1375, (PyObject *)(it)); } else _Py_Dealloc ((PyObject *)(it)); } while (0);
1376 | Py_DECREF(d)do { if (_Py_RefTotal-- , --((PyObject*)(d))->ob_refcnt != 0) { if (((PyObject*)d)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1376, (PyObject *)(d)); } else _Py_Dealloc ((PyObject *)(d)); } while (0);
1377 | return NULL((void *)0);
1378 | }
1379 |
1380 | static int
1381 | dict_update_common(PyObject *self, PyObject *args, PyObject *kwds, char *methname)
1382 | {
1383 | PyObject *arg = NULL((void *)0);
1384 | int result = 0;
1385 |
1386 | if (!PyArg_UnpackTuple(args, methname, 0, 1, &arg))
1387 | result = -1;
1388 |
1389 | else if (arg != NULL((void *)0)) {
1390 | if (PyObject_HasAttrString(arg, "keys"))
1391 | result = PyDict_Merge(self, arg, 1);
1392 | else
1393 | result = PyDict_MergeFromSeq2(self, arg, 1);
1394 | }
1395 | if (result == 0 && kwds != NULL((void *)0)) {
1396 | if (PyArg_ValidateKeywordArguments(kwds))
1397 | result = PyDict_Merge(self, kwds, 1);
1398 | else
1399 | result = -1;
1400 | }
1401 | return result;
1402 | }
1403 |
1404 | static PyObject *
1405 | dict_update(PyObject *self, PyObject *args, PyObject *kwds)
1406 | {
1407 | if (dict_update_common(self, args, kwds, "update") != -1)
1408 | Py_RETURN_NONEreturn ( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)) )->ob_refcnt++), (&_Py_NoneStruct);
1409 | return NULL((void *)0);
1410 | }
1411 |
1412 | /* Update unconditionally replaces existing items.
1413 | Merge has a 3rd argument 'override'; if set, it acts like Update,
1414 | otherwise it leaves existing items unchanged.
1415 |
1416 | PyDict_{Update,Merge} update/merge from a mapping object.
1417 |
1418 | PyDict_MergeFromSeq2 updates/merges from any iterable object
1419 | producing iterable objects of length 2.
1420 | */
1421 |
1422 | int
1423 | PyDict_MergeFromSeq2(PyObject *d, PyObject *seq2, int override)
1424 | {
1425 | PyObject *it; /* iter(seq2) */
1426 | Py_ssize_t i; /* index into seq2 of current element */
1427 | PyObject *item; /* seq2[i] */
1428 | PyObject *fast; /* item as a 2-tuple or 2-list */
1429 |
1430 | assert(d != NULL)(__builtin_expect(!(d != ((void *)0)), 0) ? __assert_rtn(__func__ , "Objects/dictobject.c", 1430, "d != NULL") : (void)0);
1431 | assert(PyDict_Check(d))(__builtin_expect(!(((((((PyObject*)(d))->ob_type))->tp_flags & ((1L<<29))) != 0)), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 1431, "PyDict_Check(d)") : (void)0);
1432 | assert(seq2 != NULL)(__builtin_expect(!(seq2 != ((void *)0)), 0) ? __assert_rtn(__func__ , "Objects/dictobject.c", 1432, "seq2 != NULL") : (void)0);
1433 |
1434 | it = PyObject_GetIter(seq2);
1435 | if (it == NULL((void *)0))
1436 | return -1;
1437 |
1438 | for (i = 0; ; ++i) {
1439 | PyObject *key, *value;
1440 | Py_ssize_t n;
1441 |
1442 | fast = NULL((void *)0);
1443 | item = PyIter_Next(it);
1444 | if (item == NULL((void *)0)) {
1445 | if (PyErr_Occurred())
1446 | goto Fail;
1447 | break;
1448 | }
1449 |
1450 | /* Convert item to sequence, and verify length 2. */
1451 | fast = PySequence_Fast(item, "");
1452 | if (fast == NULL((void *)0)) {
1453 | if (PyErr_ExceptionMatches(PyExc_TypeError))
1454 | PyErr_Format(PyExc_TypeError,
1455 | "cannot convert dictionary update "
1456 | "sequence element #%zd to a sequence",
1457 | i);
1458 | goto Fail;
1459 | }
1460 | n = PySequence_Fast_GET_SIZE(fast)(((((((PyObject*)(fast))->ob_type))->tp_flags & ((1L <<25))) != 0) ? (((PyVarObject*)(fast))->ob_size) : ( ((PyVarObject*)(fast))->ob_size));
1461 | if (n != 2) {
1462 | PyErr_Format(PyExc_ValueError,
1463 | "dictionary update sequence element #%zd "
1464 | "has length %zd; 2 is required",
1465 | i, n);
1466 | goto Fail;
1467 | }
1468 |
1469 | /* Update/merge with this (key, value) pair. */
1470 | key = PySequence_Fast_GET_ITEM(fast, 0)(((((((PyObject*)(fast))->ob_type))->tp_flags & ((1L <<25))) != 0) ? (((PyListObject *)(fast))->ob_item[0 ]) : (((PyTupleObject *)(fast))->ob_item[0]));
1471 | value = PySequence_Fast_GET_ITEM(fast, 1)(((((((PyObject*)(fast))->ob_type))->tp_flags & ((1L <<25))) != 0) ? (((PyListObject *)(fast))->ob_item[1 ]) : (((PyTupleObject *)(fast))->ob_item[1]));
1472 | if (override || PyDict_GetItem(d, key) == NULL((void *)0)) {
1473 | int status = PyDict_SetItem(d, key, value);
1474 | if (status < 0)
1475 | goto Fail;
1476 | }
1477 | Py_DECREF(fast)do { if (_Py_RefTotal-- , --((PyObject*)(fast))->ob_refcnt != 0) { if (((PyObject*)fast)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1477, (PyObject *)(fast)); } else _Py_Dealloc ((PyObject *)(fast)); } while (0);
1478 | Py_DECREF(item)do { if (_Py_RefTotal-- , --((PyObject*)(item))->ob_refcnt != 0) { if (((PyObject*)item)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1478, (PyObject *)(item)); } else _Py_Dealloc ((PyObject *)(item)); } while (0);
1479 | }
1480 |
1481 | i = 0;
1482 | goto Return;
1483 | Fail:
1484 | Py_XDECREF(item)do { if ((item) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(item))->ob_refcnt != 0) { if (((PyObject *)item)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/dictobject.c" , 1484, (PyObject *)(item)); } else _Py_Dealloc((PyObject *)( item)); } while (0); } while (0);
1485 | Py_XDECREF(fast)do { if ((fast) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(fast))->ob_refcnt != 0) { if (((PyObject *)fast)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/dictobject.c" , 1485, (PyObject *)(fast)); } else _Py_Dealloc((PyObject *)( fast)); } while (0); } while (0);
1486 | i = -1;
1487 | Return:
1488 | Py_DECREF(it)do { if (_Py_RefTotal-- , --((PyObject*)(it))->ob_refcnt != 0) { if (((PyObject*)it)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1488, (PyObject *)(it)); } else _Py_Dealloc ((PyObject *)(it)); } while (0);
1489 | return Py_SAFE_DOWNCAST(i, Py_ssize_t, int)((__builtin_expect(!((Py_ssize_t)(int)(i) == (i)), 0) ? __assert_rtn (__func__, "Objects/dictobject.c", 1489, "(Py_ssize_t)(int)(i) == (i)" ) : (void)0), (int)(i));
1490 | }
1491 |
1492 | int
1493 | PyDict_Update(PyObject *a, PyObject *b)
1494 | {
1495 | return PyDict_Merge(a, b, 1);
1496 | }
1497 |
1498 | int
1499 | PyDict_Merge(PyObject *a, PyObject *b, int override)
1500 | {
1501 | register PyDictObject *mp, *other;
1502 | register Py_ssize_t i;
1503 | PyDictEntry *entry;
1504 |
1505 | /* We accept for the argument either a concrete dictionary object,
1506 | * or an abstract "mapping" object. For the former, we can do
1507 | * things quite efficiently. For the latter, we only require that
1508 | * PyMapping_Keys() and PyObject_GetItem() be supported.
1509 | */
1510 | if (a == NULL((void *)0) || !PyDict_Check(a)((((((PyObject*)(a))->ob_type))->tp_flags & ((1L<< 29))) != 0) || b == NULL((void *)0)) {
1511 | PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/dictobject.c", 1511);
1512 | return -1;
1513 | }
1514 | mp = (PyDictObject*)a;
1515 | if (PyDict_Check(b)((((((PyObject*)(b))->ob_type))->tp_flags & ((1L<< 29))) != 0)) {
1516 | other = (PyDictObject*)b;
1517 | if (other == mp || other->ma_used == 0)
1518 | /* a.update(a) or a.update({}); nothing to do */
1519 | return 0;
1520 | if (mp->ma_used == 0)
1521 | /* Since the target dict is empty, PyDict_GetItem()
1522 | * always returns NULL. Setting override to 1
1523 | * skips the unnecessary test.
1524 | */
1525 | override = 1;
1526 | /* Do one big resize at the start, rather than
1527 | * incrementally resizing as we insert new items. Expect
1528 | * that there will be no (or few) overlapping keys.
1529 | */
1530 | if ((mp->ma_fill + other->ma_used)*3 >= (mp->ma_mask+1)*2) {
1531 | if (dictresize(mp, (mp->ma_used + other->ma_used)*2) != 0)
1532 | return -1;
1533 | }
1534 | for (i = 0; i <= other->ma_mask; i++) {
1535 | entry = &other->ma_table[i];
1536 | if (entry->me_value != NULL((void *)0) &&
1537 | (override ||
1538 | PyDict_GetItem(a, entry->me_key) == NULL((void *)0))) {
1539 | Py_INCREF(entry->me_key)( _Py_RefTotal++ , ((PyObject*)(entry->me_key))->ob_refcnt ++);
1540 | Py_INCREF(entry->me_value)( _Py_RefTotal++ , ((PyObject*)(entry->me_value))->ob_refcnt ++);
1541 | if (insertdict(mp, entry->me_key,
1542 | entry->me_hash,
1543 | entry->me_value) != 0)
1544 | return -1;
1545 | }
1546 | }
1547 | }
1548 | else {
1549 | /* Do it the generic, slower way */
1550 | PyObject *keys = PyMapping_Keys(b);
1551 | PyObject *iter;
1552 | PyObject *key, *value;
1553 | int status;
1554 |
1555 | if (keys == NULL((void *)0))
1556 | /* Docstring says this is equivalent to E.keys() so
1557 | * if E doesn't have a .keys() method we want
1558 | * AttributeError to percolate up. Might as well
1559 | * do the same for any other error.
1560 | */
1561 | return -1;
1562 |
1563 | iter = PyObject_GetIter(keys);
1564 | Py_DECREF(keys)do { if (_Py_RefTotal-- , --((PyObject*)(keys))->ob_refcnt != 0) { if (((PyObject*)keys)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1564, (PyObject *)(keys)); } else _Py_Dealloc ((PyObject *)(keys)); } while (0);
1565 | if (iter == NULL((void *)0))
1566 | return -1;
1567 |
1568 | for (key = PyIter_Next(iter); key; key = PyIter_Next(iter)) {
1569 | if (!override && PyDict_GetItem(a, key) != NULL((void *)0)) {
1570 | Py_DECREF(key)do { if (_Py_RefTotal-- , --((PyObject*)(key))->ob_refcnt != 0) { if (((PyObject*)key)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1570, (PyObject *)(key)); } else _Py_Dealloc ((PyObject *)(key)); } while (0);
1571 | continue;
1572 | }
1573 | value = PyObject_GetItem(b, key);
1574 | if (value == NULL((void *)0)) {
1575 | Py_DECREF(iter)do { if (_Py_RefTotal-- , --((PyObject*)(iter))->ob_refcnt != 0) { if (((PyObject*)iter)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1575, (PyObject *)(iter)); } else _Py_Dealloc ((PyObject *)(iter)); } while (0);
1576 | Py_DECREF(key)do { if (_Py_RefTotal-- , --((PyObject*)(key))->ob_refcnt != 0) { if (((PyObject*)key)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1576, (PyObject *)(key)); } else _Py_Dealloc ((PyObject *)(key)); } while (0);
1577 | return -1;
1578 | }
1579 | status = PyDict_SetItem(a, key, value);
1580 | Py_DECREF(key)do { if (_Py_RefTotal-- , --((PyObject*)(key))->ob_refcnt != 0) { if (((PyObject*)key)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1580, (PyObject *)(key)); } else _Py_Dealloc ((PyObject *)(key)); } while (0);
1581 | Py_DECREF(value)do { if (_Py_RefTotal-- , --((PyObject*)(value))->ob_refcnt != 0) { if (((PyObject*)value)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1581, (PyObject *)(value)); } else _Py_Dealloc ((PyObject *)(value)); } while (0);
1582 | if (status < 0) {
1583 | Py_DECREF(iter)do { if (_Py_RefTotal-- , --((PyObject*)(iter))->ob_refcnt != 0) { if (((PyObject*)iter)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1583, (PyObject *)(iter)); } else _Py_Dealloc ((PyObject *)(iter)); } while (0);
1584 | return -1;
1585 | }
1586 | }
1587 | Py_DECREF(iter)do { if (_Py_RefTotal-- , --((PyObject*)(iter))->ob_refcnt != 0) { if (((PyObject*)iter)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1587, (PyObject *)(iter)); } else _Py_Dealloc ((PyObject *)(iter)); } while (0);
1588 | if (PyErr_Occurred())
1589 | /* Iterator completed, via error */
1590 | return -1;
1591 | }
1592 | return 0;
1593 | }
1594 |
1595 | static PyObject *
1596 | dict_copy(register PyDictObject *mp)
1597 | {
1598 | return PyDict_Copy((PyObject*)mp);
1599 | }
1600 |
1601 | PyObject *
1602 | PyDict_Copy(PyObject *o)
1603 | {
1604 | PyObject *copy;
1605 |
1606 | if (o == NULL((void *)0) || !PyDict_Check(o)((((((PyObject*)(o))->ob_type))->tp_flags & ((1L<< 29))) != 0)) {
1607 | PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/dictobject.c", 1607);
1608 | return NULL((void *)0);
1609 | }
1610 | copy = PyDict_New();
1611 | if (copy == NULL((void *)0))
1612 | return NULL((void *)0);
1613 | if (PyDict_Merge(copy, o, 1) == 0)
1614 | return copy;
1615 | Py_DECREF(copy)do { if (_Py_RefTotal-- , --((PyObject*)(copy))->ob_refcnt != 0) { if (((PyObject*)copy)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1615, (PyObject *)(copy)); } else _Py_Dealloc ((PyObject *)(copy)); } while (0);
1616 | return NULL((void *)0);
1617 | }
1618 |
1619 | Py_ssize_t
1620 | PyDict_Size(PyObject *mp)
1621 | {
1622 | if (mp == NULL((void *)0) || !PyDict_Check(mp)((((((PyObject*)(mp))->ob_type))->tp_flags & ((1L<< 29))) != 0)) {
1623 | PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/dictobject.c", 1623);
1624 | return -1;
1625 | }
1626 | return ((PyDictObject *)mp)->ma_used;
1627 | }
1628 |
1629 | PyObject *
1630 | PyDict_Keys(PyObject *mp)
1631 | {
1632 | if (mp == NULL((void *)0) || !PyDict_Check(mp)((((((PyObject*)(mp))->ob_type))->tp_flags & ((1L<< 29))) != 0)) {
1633 | PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/dictobject.c", 1633);
1634 | return NULL((void *)0);
1635 | }
1636 | return dict_keys((PyDictObject *)mp);
1637 | }
1638 |
1639 | PyObject *
1640 | PyDict_Values(PyObject *mp)
1641 | {
1642 | if (mp == NULL((void *)0) || !PyDict_Check(mp)((((((PyObject*)(mp))->ob_type))->tp_flags & ((1L<< 29))) != 0)) {
1643 | PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/dictobject.c", 1643);
1644 | return NULL((void *)0);
1645 | }
1646 | return dict_values((PyDictObject *)mp);
1647 | }
1648 |
1649 | PyObject *
1650 | PyDict_Items(PyObject *mp)
1651 | {
1652 | if (mp == NULL((void *)0) || !PyDict_Check(mp)((((((PyObject*)(mp))->ob_type))->tp_flags & ((1L<< 29))) != 0)) {
1653 | PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/dictobject.c", 1653);
1654 | return NULL((void *)0);
1655 | }
1656 | return dict_items((PyDictObject *)mp);
1657 | }
1658 |
1659 | /* Return 1 if dicts equal, 0 if not, -1 if error.
1660 | * Gets out as soon as any difference is detected.
1661 | * Uses only Py_EQ comparison.
1662 | */
1663 | static int
1664 | dict_equal(PyDictObject *a, PyDictObject *b)
1665 | {
1666 | Py_ssize_t i;
1667 |
1668 | if (a->ma_used != b->ma_used)
1669 | /* can't be equal if # of entries differ */
1670 | return 0;
1671 |
1672 | /* Same # of entries -- check all of 'em. Exit early on any diff. */
1673 | for (i = 0; i <= a->ma_mask; i++) {
1674 | PyObject *aval = a->ma_table[i].me_value;
1675 | if (aval != NULL((void *)0)) {
1676 | int cmp;
1677 | PyObject *bval;
1678 | PyObject *key = a->ma_table[i].me_key;
1679 | /* temporarily bump aval's refcount to ensure it stays
1680 | alive until we're done with it */
1681 | Py_INCREF(aval)( _Py_RefTotal++ , ((PyObject*)(aval))->ob_refcnt++);
1682 | /* ditto for key */
1683 | Py_INCREF(key)( _Py_RefTotal++ , ((PyObject*)(key))->ob_refcnt++);
1684 | bval = PyDict_GetItemWithError((PyObject *)b, key);
1685 | Py_DECREF(key)do { if (_Py_RefTotal-- , --((PyObject*)(key))->ob_refcnt != 0) { if (((PyObject*)key)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1685, (PyObject *)(key)); } else _Py_Dealloc ((PyObject *)(key)); } while (0);
1686 | if (bval == NULL((void *)0)) {
1687 | Py_DECREF(aval)do { if (_Py_RefTotal-- , --((PyObject*)(aval))->ob_refcnt != 0) { if (((PyObject*)aval)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1687, (PyObject *)(aval)); } else _Py_Dealloc ((PyObject *)(aval)); } while (0);
1688 | if (PyErr_Occurred())
1689 | return -1;
1690 | return 0;
1691 | }
1692 | cmp = PyObject_RichCompareBool(aval, bval, Py_EQ2);
1693 | Py_DECREF(aval)do { if (_Py_RefTotal-- , --((PyObject*)(aval))->ob_refcnt != 0) { if (((PyObject*)aval)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1693, (PyObject *)(aval)); } else _Py_Dealloc ((PyObject *)(aval)); } while (0);
1694 | if (cmp <= 0) /* error or not equal */
1695 | return cmp;
1696 | }
1697 | }
1698 | return 1;
1699 | }
1700 |
1701 | static PyObject *
1702 | dict_richcompare(PyObject *v, PyObject *w, int op)
1703 | {
1704 | int cmp;
1705 | PyObject *res;
1706 |
1707 | if (!PyDict_Check(v)((((((PyObject*)(v))->ob_type))->tp_flags & ((1L<< 29))) != 0) || !PyDict_Check(w)((((((PyObject*)(w))->ob_type))->tp_flags & ((1L<< 29))) != 0)) {
1708 | res = Py_NotImplemented(&_Py_NotImplementedStruct);
1709 | }
1710 | else if (op == Py_EQ2 || op == Py_NE3) {
1711 | cmp = dict_equal((PyDictObject *)v, (PyDictObject *)w);
1712 | if (cmp < 0)
1713 | return NULL((void *)0);
1714 | res = (cmp == (op == Py_EQ2)) ? Py_True((PyObject *) &_Py_TrueStruct) : Py_False((PyObject *) &_Py_FalseStruct);
1715 | }
1716 | else
1717 | res = Py_NotImplemented(&_Py_NotImplementedStruct);
1718 | Py_INCREF(res)( _Py_RefTotal++ , ((PyObject*)(res))->ob_refcnt++);
1719 | return res;
1720 | }
1721 |
1722 | static PyObject *
1723 | dict_contains(register PyDictObject *mp, PyObject *key)
1724 | {
1725 | Py_hash_t hash;
1726 | PyDictEntry *ep;
1727 |
1728 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type) ||
1729 | (hash = ((PyUnicodeObject *) key)->hash) == -1) {
1730 | hash = PyObject_Hash(key);
1731 | if (hash == -1)
1732 | return NULL((void *)0);
1733 | }
1734 | ep = (mp->ma_lookup)(mp, key, hash);
1735 | if (ep == NULL((void *)0))
1736 | return NULL((void *)0);
1737 | return PyBool_FromLong(ep->me_value != NULL((void *)0));
1738 | }
1739 |
1740 | static PyObject *
1741 | dict_get(register PyDictObject *mp, PyObject *args)
1742 | {
1743 | PyObject *key;
1744 | PyObject *failobj = Py_None(&_Py_NoneStruct);
1745 | PyObject *val = NULL((void *)0);
1746 | Py_hash_t hash;
1747 | PyDictEntry *ep;
1748 |
1749 | if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &failobj))
1750 | return NULL((void *)0);
1751 |
1752 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type) ||
1753 | (hash = ((PyUnicodeObject *) key)->hash) == -1) {
1754 | hash = PyObject_Hash(key);
1755 | if (hash == -1)
1756 | return NULL((void *)0);
1757 | }
1758 | ep = (mp->ma_lookup)(mp, key, hash);
1759 | if (ep == NULL((void *)0))
1760 | return NULL((void *)0);
1761 | val = ep->me_value;
1762 | if (val == NULL((void *)0))
1763 | val = failobj;
1764 | Py_INCREF(val)( _Py_RefTotal++ , ((PyObject*)(val))->ob_refcnt++);
1765 | return val;
1766 | }
1767 |
1768 |
1769 | static PyObject *
1770 | dict_setdefault(register PyDictObject *mp, PyObject *args)
1771 | {
1772 | PyObject *key;
1773 | PyObject *failobj = Py_None(&_Py_NoneStruct);
1774 | PyObject *val = NULL((void *)0);
1775 | Py_hash_t hash;
1776 | PyDictEntry *ep;
1777 |
1778 | if (!PyArg_UnpackTuple(args, "setdefault", 1, 2, &key, &failobj))
1779 | return NULL((void *)0);
1780 |
1781 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type) ||
1782 | (hash = ((PyUnicodeObject *) key)->hash) == -1) {
1783 | hash = PyObject_Hash(key);
1784 | if (hash == -1)
1785 | return NULL((void *)0);
1786 | }
1787 | ep = (mp->ma_lookup)(mp, key, hash);
1788 | if (ep == NULL((void *)0))
1789 | return NULL((void *)0);
1790 | val = ep->me_value;
1791 | if (val == NULL((void *)0)) {
1792 | val = failobj;
1793 | if (PyDict_SetItem((PyObject*)mp, key, failobj))
1794 | val = NULL((void *)0);
1795 | }
1796 | Py_XINCREF(val)do { if ((val) == ((void *)0)) ; else ( _Py_RefTotal++ , ((PyObject *)(val))->ob_refcnt++); } while (0);
1797 | return val;
1798 | }
1799 |
1800 |
1801 | static PyObject *
1802 | dict_clear(register PyDictObject *mp)
1803 | {
1804 | PyDict_Clear((PyObject *)mp);
1805 | Py_RETURN_NONEreturn ( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)) )->ob_refcnt++), (&_Py_NoneStruct);
1806 | }
1807 |
1808 | static PyObject *
1809 | dict_pop(PyDictObject *mp, PyObject *args)
1810 | {
1811 | Py_hash_t hash;
1812 | PyDictEntry *ep;
1813 | PyObject *old_value, *old_key;
1814 | PyObject *key, *deflt = NULL((void *)0);
1815 |
1816 | if(!PyArg_UnpackTuple(args, "pop", 1, 2, &key, &deflt))
1817 | return NULL((void *)0);
1818 | if (mp->ma_used == 0) {
1819 | if (deflt) {
1820 | Py_INCREF(deflt)( _Py_RefTotal++ , ((PyObject*)(deflt))->ob_refcnt++);
1821 | return deflt;
1822 | }
1823 | set_key_error(key);
1824 | return NULL((void *)0);
1825 | }
1826 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type) ||
1827 | (hash = ((PyUnicodeObject *) key)->hash) == -1) {
1828 | hash = PyObject_Hash(key);
1829 | if (hash == -1)
1830 | return NULL((void *)0);
1831 | }
1832 | ep = (mp->ma_lookup)(mp, key, hash);
1833 | if (ep == NULL((void *)0))
1834 | return NULL((void *)0);
1835 | if (ep->me_value == NULL((void *)0)) {
1836 | if (deflt) {
1837 | Py_INCREF(deflt)( _Py_RefTotal++ , ((PyObject*)(deflt))->ob_refcnt++);
1838 | return deflt;
1839 | }
1840 | set_key_error(key);
1841 | return NULL((void *)0);
1842 | }
1843 | old_key = ep->me_key;
1844 | Py_INCREF(dummy)( _Py_RefTotal++ , ((PyObject*)(dummy))->ob_refcnt++);
1845 | ep->me_key = dummy;
1846 | old_value = ep->me_value;
1847 | ep->me_value = NULL((void *)0);
1848 | mp->ma_used--;
1849 | Py_DECREF(old_key)do { if (_Py_RefTotal-- , --((PyObject*)(old_key))->ob_refcnt != 0) { if (((PyObject*)old_key)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1849, (PyObject *)(old_key)); } else _Py_Dealloc((PyObject *)(old_key)); } while (0);
1850 | return old_value;
1851 | }
1852 |
1853 | static PyObject *
1854 | dict_popitem(PyDictObject *mp)
1855 | {
1856 | Py_hash_t i = 0;
1857 | PyDictEntry *ep;
1858 | PyObject *res;
1859 |
1860 | /* Allocate the result tuple before checking the size. Believe it
1861 | * or not, this allocation could trigger a garbage collection which
1862 | * could empty the dict, so if we checked the size first and that
1863 | * happened, the result would be an infinite loop (searching for an
1864 | * entry that no longer exists). Note that the usual popitem()
1865 | * idiom is "while d: k, v = d.popitem()". so needing to throw the
1866 | * tuple away if the dict *is* empty isn't a significant
1867 | * inefficiency -- possible, but unlikely in practice.
1868 | */
1869 | res = PyTuple_New(2);
1870 | if (res == NULL((void *)0))
1871 | return NULL((void *)0);
1872 | if (mp->ma_used == 0) {
1873 | Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt != 0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 1873, (PyObject *)(res)); } else _Py_Dealloc ((PyObject *)(res)); } while (0);
1874 | PyErr_SetString(PyExc_KeyError,
1875 | "popitem(): dictionary is empty");
1876 | return NULL((void *)0);
1877 | }
1878 | /* Set ep to "the first" dict entry with a value. We abuse the hash
1879 | * field of slot 0 to hold a search finger:
1880 | * If slot 0 has a value, use slot 0.
1881 | * Else slot 0 is being used to hold a search finger,
1882 | * and we use its hash value as the first index to look.
1883 | */
1884 | ep = &mp->ma_table[0];
1885 | if (ep->me_value == NULL((void *)0)) {
1886 | i = ep->me_hash;
1887 | /* The hash field may be a real hash value, or it may be a
1888 | * legit search finger, or it may be a once-legit search
1889 | * finger that's out of bounds now because it wrapped around
1890 | * or the table shrunk -- simply make sure it's in bounds now.
1891 | */
1892 | if (i > mp->ma_mask || i < 1)
1893 | i = 1; /* skip slot 0 */
1894 | while ((ep = &mp->ma_table[i])->me_value == NULL((void *)0)) {
1895 | i++;
1896 | if (i > mp->ma_mask)
1897 | i = 1;
1898 | }
1899 | }
1900 | PyTuple_SET_ITEM(res, 0, ep->me_key)(((PyTupleObject *)(res))->ob_item[0] = ep->me_key);
1901 | PyTuple_SET_ITEM(res, 1, ep->me_value)(((PyTupleObject *)(res))->ob_item[1] = ep->me_value);
1902 | Py_INCREF(dummy)( _Py_RefTotal++ , ((PyObject*)(dummy))->ob_refcnt++);
1903 | ep->me_key = dummy;
1904 | ep->me_value = NULL((void *)0);
1905 | mp->ma_used--;
1906 | assert(mp->ma_table[0].me_value == NULL)(__builtin_expect(!(mp->ma_table[0].me_value == ((void *)0 )), 0) ? __assert_rtn(__func__, "Objects/dictobject.c", 1906, "mp->ma_table[0].me_value == NULL") : (void)0);
1907 | mp->ma_table[0].me_hash = i + 1; /* next place to start */
1908 | return res;
1909 | }
1910 |
1911 | static int
1912 | dict_traverse(PyObject *op, visitproc visit, void *arg)
1913 | {
1914 | Py_ssize_t i = 0;
1915 | PyObject *pk;
1916 | PyObject *pv;
1917 |
1918 | while (PyDict_Next(op, &i, &pk, &pv)) {
1919 | Py_VISIT(pk)do { if (pk) { int vret = visit((PyObject *)(pk), arg); if (vret ) return vret; } } while (0);
1920 | Py_VISIT(pv)do { if (pv) { int vret = visit((PyObject *)(pv), arg); if (vret ) return vret; } } while (0);
1921 | }
1922 | return 0;
1923 | }
1924 |
1925 | static int
1926 | dict_tp_clear(PyObject *op)
1927 | {
1928 | PyDict_Clear(op);
1929 | return 0;
1930 | }
1931 |
1932 | static PyObject *dictiter_new(PyDictObject *, PyTypeObject *);
1933 |
1934 | static PyObject *
1935 | dict_sizeof(PyDictObject *mp)
1936 | {
1937 | Py_ssize_t res;
1938 |
1939 | res = sizeof(PyDictObject);
1940 | if (mp->ma_table != mp->ma_smalltable)
1941 | res = res + (mp->ma_mask + 1) * sizeof(PyDictEntry);
1942 | return PyLong_FromSsize_t(res);
1943 | }
1944 |
1945 | PyDoc_STRVAR(contains__doc__,static char contains__doc__[] = "D.__contains__(k) -> True if D has a key k, else False"
1946 | "D.__contains__(k) -> True if D has a key k, else False")static char contains__doc__[] = "D.__contains__(k) -> True if D has a key k, else False";
1947 |
1948 | PyDoc_STRVAR(getitem__doc__, "x.__getitem__(y) <==> x[y]")static char getitem__doc__[] = "x.__getitem__(y) <==> x[y]";
1949 |
1950 | PyDoc_STRVAR(sizeof__doc__,static char sizeof__doc__[] = "D.__sizeof__() -> size of D in memory, in bytes"
1951 | "D.__sizeof__() -> size of D in memory, in bytes")static char sizeof__doc__[] = "D.__sizeof__() -> size of D in memory, in bytes";
1952 |
1953 | PyDoc_STRVAR(get__doc__,static char get__doc__[] = "D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None."
1954 | "D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.")static char get__doc__[] = "D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.";
1955 |
1956 | PyDoc_STRVAR(setdefault_doc__,static char setdefault_doc__[] = "D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D"
1957 | "D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D")static char setdefault_doc__[] = "D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D";
1958 |
1959 | PyDoc_STRVAR(pop__doc__,static char pop__doc__[] = "D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\nIf key is not found, d is returned if given, otherwise KeyError is raised"
1960 | "D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n\static char pop__doc__[] = "D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\nIf key is not found, d is returned if given, otherwise KeyError is raised"
1961 | If key is not found, d is returned if given, otherwise KeyError is raised")static char pop__doc__[] = "D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\nIf key is not found, d is returned if given, otherwise KeyError is raised";
1962 |
1963 | PyDoc_STRVAR(popitem__doc__,static char popitem__doc__[] = "D.popitem() -> (k, v), remove and return some (key, value) pair as a\n2-tuple; but raise KeyError if D is empty."
1964 | "D.popitem() -> (k, v), remove and return some (key, value) pair as a\n\static char popitem__doc__[] = "D.popitem() -> (k, v), remove and return some (key, value) pair as a\n2-tuple; but raise KeyError if D is empty."
1965 | 2-tuple; but raise KeyError if D is empty.")static char popitem__doc__[] = "D.popitem() -> (k, v), remove and return some (key, value) pair as a\n2-tuple; but raise KeyError if D is empty.";
1966 |
1967 | PyDoc_STRVAR(update__doc__,static char update__doc__[] = "D.update(E, **F) -> None. Update D from dict/iterable E and F.\n" "If E has a .keys() method, does: for k in E: D[k] = E[k]\nIf E lacks .keys() method, does: for (k, v) in E: D[k] = v\nIn either case, this is followed by: for k in F: D[k] = F[k]"
1968 | "D.update(E, **F) -> None. Update D from dict/iterable E and F.\n"static char update__doc__[] = "D.update(E, **F) -> None. Update D from dict/iterable E and F.\n" "If E has a .keys() method, does: for k in E: D[k] = E[k]\nIf E lacks .keys() method, does: for (k, v) in E: D[k] = v\nIn either case, this is followed by: for k in F: D[k] = F[k]"
1969 | "If E has a .keys() method, does: for k in E: D[k] = E[k]\n\static char update__doc__[] = "D.update(E, **F) -> None. Update D from dict/iterable E and F.\n" "If E has a .keys() method, does: for k in E: D[k] = E[k]\nIf E lacks .keys() method, does: for (k, v) in E: D[k] = v\nIn either case, this is followed by: for k in F: D[k] = F[k]"
1970 | If E lacks .keys() method, does: for (k, v) in E: D[k] = v\n\static char update__doc__[] = "D.update(E, **F) -> None. Update D from dict/iterable E and F.\n" "If E has a .keys() method, does: for k in E: D[k] = E[k]\nIf E lacks .keys() method, does: for (k, v) in E: D[k] = v\nIn either case, this is followed by: for k in F: D[k] = F[k]"
1971 | In either case, this is followed by: for k in F: D[k] = F[k]")static char update__doc__[] = "D.update(E, **F) -> None. Update D from dict/iterable E and F.\n" "If E has a .keys() method, does: for k in E: D[k] = E[k]\nIf E lacks .keys() method, does: for (k, v) in E: D[k] = v\nIn either case, this is followed by: for k in F: D[k] = F[k]";
1972 |
1973 | PyDoc_STRVAR(fromkeys__doc__,static char fromkeys__doc__[] = "dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.\nv defaults to None."
1974 | "dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.\n\static char fromkeys__doc__[] = "dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.\nv defaults to None."
1975 | v defaults to None.")static char fromkeys__doc__[] = "dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.\nv defaults to None.";
1976 |
1977 | PyDoc_STRVAR(clear__doc__,static char clear__doc__[] = "D.clear() -> None. Remove all items from D."
1978 | "D.clear() -> None. Remove all items from D.")static char clear__doc__[] = "D.clear() -> None. Remove all items from D.";
1979 |
1980 | PyDoc_STRVAR(copy__doc__,static char copy__doc__[] = "D.copy() -> a shallow copy of D"
1981 | "D.copy() -> a shallow copy of D")static char copy__doc__[] = "D.copy() -> a shallow copy of D";
1982 |
1983 | /* Forward */
1984 | static PyObject *dictkeys_new(PyObject *);
1985 | static PyObject *dictitems_new(PyObject *);
1986 | static PyObject *dictvalues_new(PyObject *);
1987 |
1988 | PyDoc_STRVAR(keys__doc__,static char keys__doc__[] = "D.keys() -> a set-like object providing a view on D's keys"
1989 | "D.keys() -> a set-like object providing a view on D's keys")static char keys__doc__[] = "D.keys() -> a set-like object providing a view on D's keys";
1990 | PyDoc_STRVAR(items__doc__,static char items__doc__[] = "D.items() -> a set-like object providing a view on D's items"
1991 | "D.items() -> a set-like object providing a view on D's items")static char items__doc__[] = "D.items() -> a set-like object providing a view on D's items";
1992 | PyDoc_STRVAR(values__doc__,static char values__doc__[] = "D.values() -> an object providing a view on D's values"
1993 | "D.values() -> an object providing a view on D's values")static char values__doc__[] = "D.values() -> an object providing a view on D's values";
1994 |
1995 | static PyMethodDef mapp_methods[] = {
1996 | {"__contains__",(PyCFunction)dict_contains, METH_O0x0008 | METH_COEXIST0x0040,
1997 | contains__doc__},
1998 | {"__getitem__", (PyCFunction)dict_subscript, METH_O0x0008 | METH_COEXIST0x0040,
1999 | getitem__doc__},
2000 | {"__sizeof__", (PyCFunction)dict_sizeof, METH_NOARGS0x0004,
2001 | sizeof__doc__},
2002 | {"get", (PyCFunction)dict_get, METH_VARARGS0x0001,
2003 | get__doc__},
2004 | {"setdefault", (PyCFunction)dict_setdefault, METH_VARARGS0x0001,
2005 | setdefault_doc__},
2006 | {"pop", (PyCFunction)dict_pop, METH_VARARGS0x0001,
2007 | pop__doc__},
2008 | {"popitem", (PyCFunction)dict_popitem, METH_NOARGS0x0004,
2009 | popitem__doc__},
2010 | {"keys", (PyCFunction)dictkeys_new, METH_NOARGS0x0004,
2011 | keys__doc__},
2012 | {"items", (PyCFunction)dictitems_new, METH_NOARGS0x0004,
2013 | items__doc__},
2014 | {"values", (PyCFunction)dictvalues_new, METH_NOARGS0x0004,
2015 | values__doc__},
2016 | {"update", (PyCFunction)dict_update, METH_VARARGS0x0001 | METH_KEYWORDS0x0002,
2017 | update__doc__},
2018 | {"fromkeys", (PyCFunction)dict_fromkeys, METH_VARARGS0x0001 | METH_CLASS0x0010,
2019 | fromkeys__doc__},
2020 | {"clear", (PyCFunction)dict_clear, METH_NOARGS0x0004,
2021 | clear__doc__},
2022 | {"copy", (PyCFunction)dict_copy, METH_NOARGS0x0004,
2023 | copy__doc__},
2024 | {NULL((void *)0), NULL((void *)0)} /* sentinel */
2025 | };
2026 |
2027 | /* Return 1 if `key` is in dict `op`, 0 if not, and -1 on error. */
2028 | int
2029 | PyDict_Contains(PyObject *op, PyObject *key)
2030 | {
2031 | Py_hash_t hash;
2032 | PyDictObject *mp = (PyDictObject *)op;
2033 | PyDictEntry *ep;
2034 |
2035 | if (!PyUnicode_CheckExact(key)((((PyObject*)(key))->ob_type) == &PyUnicode_Type) ||
2036 | (hash = ((PyUnicodeObject *) key)->hash) == -1) {
2037 | hash = PyObject_Hash(key);
2038 | if (hash == -1)
2039 | return -1;
2040 | }
2041 | ep = (mp->ma_lookup)(mp, key, hash);
2042 | return ep == NULL((void *)0) ? -1 : (ep->me_value != NULL((void *)0));
2043 | }
2044 |
2045 | /* Internal version of PyDict_Contains used when the hash value is already known */
2046 | int
2047 | _PyDict_Contains(PyObject *op, PyObject *key, Py_hash_t hash)
2048 | {
2049 | PyDictObject *mp = (PyDictObject *)op;
2050 | PyDictEntry *ep;
2051 |
2052 | ep = (mp->ma_lookup)(mp, key, hash);
2053 | return ep == NULL((void *)0) ? -1 : (ep->me_value != NULL((void *)0));
2054 | }
2055 |
2056 | /* Hack to implement "key in dict" */
2057 | static PySequenceMethods dict_as_sequence = {
2058 | 0, /* sq_length */
2059 | 0, /* sq_concat */
2060 | 0, /* sq_repeat */
2061 | 0, /* sq_item */
2062 | 0, /* sq_slice */
2063 | 0, /* sq_ass_item */
2064 | 0, /* sq_ass_slice */
2065 | PyDict_Contains, /* sq_contains */
2066 | 0, /* sq_inplace_concat */
2067 | 0, /* sq_inplace_repeat */
2068 | };
2069 |
2070 | static PyObject *
2071 | dict_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2072 | {
2073 | PyObject *self;
2074 |
2075 | assert(type != NULL && type->tp_alloc != NULL)(__builtin_expect(!(type != ((void *)0) && type->tp_alloc != ((void *)0)), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 2075, "type != NULL && type->tp_alloc != NULL") : (void)0);
2076 | self = type->tp_alloc(type, 0);
2077 | if (self != NULL((void *)0)) {
2078 | PyDictObject *d = (PyDictObject *)self;
2079 | /* It's guaranteed that tp->alloc zeroed out the struct. */
2080 | assert(d->ma_table == NULL && d->ma_fill == 0 && d->ma_used == 0)(__builtin_expect(!(d->ma_table == ((void *)0) && d ->ma_fill == 0 && d->ma_used == 0), 0) ? __assert_rtn (__func__, "Objects/dictobject.c", 2080, "d->ma_table == NULL && d->ma_fill == 0 && d->ma_used == 0" ) : (void)0);
2081 | INIT_NONZERO_DICT_SLOTS(d)do { (d)->ma_table = (d)->ma_smalltable; (d)->ma_mask = 8 - 1; } while(0);
2082 | d->ma_lookup = lookdict_unicode;
2083 | /* The object has been implicitely tracked by tp_alloc */
2084 | if (type == &PyDict_Type)
2085 | _PyObject_GC_UNTRACK(d)do { PyGC_Head *g = ((PyGC_Head *)(d)-1); (__builtin_expect(! (g->gc.gc_refs != (-2)), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 2085, "g->gc.gc_refs != _PyGC_REFS_UNTRACKED") : (void)0 ); g->gc.gc_refs = (-2); g->gc.gc_prev->gc.gc_next = g->gc.gc_next; g->gc.gc_next->gc.gc_prev = g->gc .gc_prev; g->gc.gc_next = ((void *)0); } while (0);;
2086 | #ifdef SHOW_CONVERSION_COUNTS
2087 | ++created;
2088 | #endif
2089 | #ifdef SHOW_TRACK_COUNT
2090 | if (_PyObject_GC_IS_TRACKED(d)((((PyGC_Head *)(d)-1))->gc.gc_refs != (-2)))
2091 | count_tracked++;
2092 | else
2093 | count_untracked++;
2094 | #endif
2095 | }
2096 | return self;
2097 | }
2098 |
2099 | static int
2100 | dict_init(PyObject *self, PyObject *args, PyObject *kwds)
2101 | {
2102 | return dict_update_common(self, args, kwds, "dict");
2103 | }
2104 |
2105 | static PyObject *
2106 | dict_iter(PyDictObject *dict)
2107 | {
2108 | return dictiter_new(dict, &PyDictIterKey_Type);
2109 | }
2110 |
2111 | PyDoc_STRVAR(dictionary_doc,static char dictionary_doc[] = "dict() -> new empty dictionary\n" "dict(mapping) -> new dictionary initialized from a mapping object's\n" " (key, value) pairs\n""dict(iterable) -> new dictionary initialized as if via:\n" " d = {}\n"" for k, v in iterable:\n"" d[k] = v\n" "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" " in the keyword argument list. For example: dict(one=1, two=2)"
2112 | "dict() -> new empty dictionary\n"static char dictionary_doc[] = "dict() -> new empty dictionary\n" "dict(mapping) -> new dictionary initialized from a mapping object's\n" " (key, value) pairs\n""dict(iterable) -> new dictionary initialized as if via:\n" " d = {}\n"" for k, v in iterable:\n"" d[k] = v\n" "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" " in the keyword argument list. For example: dict(one=1, two=2)"
2113 | "dict(mapping) -> new dictionary initialized from a mapping object's\n"static char dictionary_doc[] = "dict() -> new empty dictionary\n" "dict(mapping) -> new dictionary initialized from a mapping object's\n" " (key, value) pairs\n""dict(iterable) -> new dictionary initialized as if via:\n" " d = {}\n"" for k, v in iterable:\n"" d[k] = v\n" "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" " in the keyword argument list. For example: dict(one=1, two=2)"
2114 | " (key, value) pairs\n"static char dictionary_doc[] = "dict() -> new empty dictionary\n" "dict(mapping) -> new dictionary initialized from a mapping object's\n" " (key, value) pairs\n""dict(iterable) -> new dictionary initialized as if via:\n" " d = {}\n"" for k, v in iterable:\n"" d[k] = v\n" "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" " in the keyword argument list. For example: dict(one=1, two=2)"
2115 | "dict(iterable) -> new dictionary initialized as if via:\n"static char dictionary_doc[] = "dict() -> new empty dictionary\n" "dict(mapping) -> new dictionary initialized from a mapping object's\n" " (key, value) pairs\n""dict(iterable) -> new dictionary initialized as if via:\n" " d = {}\n"" for k, v in iterable:\n"" d[k] = v\n" "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" " in the keyword argument list. For example: dict(one=1, two=2)"
2116 | " d = {}\n"static char dictionary_doc[] = "dict() -> new empty dictionary\n" "dict(mapping) -> new dictionary initialized from a mapping object's\n" " (key, value) pairs\n""dict(iterable) -> new dictionary initialized as if via:\n" " d = {}\n"" for k, v in iterable:\n"" d[k] = v\n" "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" " in the keyword argument list. For example: dict(one=1, two=2)"
2117 | " for k, v in iterable:\n"static char dictionary_doc[] = "dict() -> new empty dictionary\n" "dict(mapping) -> new dictionary initialized from a mapping object's\n" " (key, value) pairs\n""dict(iterable) -> new dictionary initialized as if via:\n" " d = {}\n"" for k, v in iterable:\n"" d[k] = v\n" "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" " in the keyword argument list. For example: dict(one=1, two=2)"
2118 | " d[k] = v\n"static char dictionary_doc[] = "dict() -> new empty dictionary\n" "dict(mapping) -> new dictionary initialized from a mapping object's\n" " (key, value) pairs\n""dict(iterable) -> new dictionary initialized as if via:\n" " d = {}\n"" for k, v in iterable:\n"" d[k] = v\n" "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" " in the keyword argument list. For example: dict(one=1, two=2)"
2119 | "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n"static char dictionary_doc[] = "dict() -> new empty dictionary\n" "dict(mapping) -> new dictionary initialized from a mapping object's\n" " (key, value) pairs\n""dict(iterable) -> new dictionary initialized as if via:\n" " d = {}\n"" for k, v in iterable:\n"" d[k] = v\n" "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" " in the keyword argument list. For example: dict(one=1, two=2)"
2120 | " in the keyword argument list. For example: dict(one=1, two=2)")static char dictionary_doc[] = "dict() -> new empty dictionary\n" "dict(mapping) -> new dictionary initialized from a mapping object's\n" " (key, value) pairs\n""dict(iterable) -> new dictionary initialized as if via:\n" " d = {}\n"" for k, v in iterable:\n"" d[k] = v\n" "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" " in the keyword argument list. For example: dict(one=1, two=2)";
2121 |
2122 | PyTypeObject PyDict_Type = {
2123 | PyVarObject_HEAD_INIT(&PyType_Type, 0){ { 0, 0, 1, &PyType_Type }, 0 },
2124 | "dict",
2125 | sizeof(PyDictObject),
2126 | 0,
2127 | (destructor)dict_dealloc, /* tp_dealloc */
2128 | 0, /* tp_print */
2129 | 0, /* tp_getattr */
2130 | 0, /* tp_setattr */
2131 | 0, /* tp_reserved */
2132 | (reprfunc)dict_repr, /* tp_repr */
2133 | 0, /* tp_as_number */
2134 | &dict_as_sequence, /* tp_as_sequence */
2135 | &dict_as_mapping, /* tp_as_mapping */
2136 | PyObject_HashNotImplemented, /* tp_hash */
2137 | 0, /* tp_call */
2138 | 0, /* tp_str */
2139 | PyObject_GenericGetAttr, /* tp_getattro */
2140 | 0, /* tp_setattro */
2141 | 0, /* tp_as_buffer */
2142 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_HAVE_GC(1L<<14) |
2143 | Py_TPFLAGS_BASETYPE(1L<<10) | Py_TPFLAGS_DICT_SUBCLASS(1L<<29), /* tp_flags */
2144 | dictionary_doc, /* tp_doc */
2145 | dict_traverse, /* tp_traverse */
2146 | dict_tp_clear, /* tp_clear */
2147 | dict_richcompare, /* tp_richcompare */
2148 | 0, /* tp_weaklistoffset */
2149 | (getiterfunc)dict_iter, /* tp_iter */
2150 | 0, /* tp_iternext */
2151 | mapp_methods, /* tp_methods */
2152 | 0, /* tp_members */
2153 | 0, /* tp_getset */
2154 | 0, /* tp_base */
2155 | 0, /* tp_dict */
2156 | 0, /* tp_descr_get */
2157 | 0, /* tp_descr_set */
2158 | 0, /* tp_dictoffset */
2159 | dict_init, /* tp_init */
2160 | PyType_GenericAlloc, /* tp_alloc */
2161 | dict_new, /* tp_new */
2162 | PyObject_GC_Del, /* tp_free */
2163 | };
2164 |
2165 | /* For backward compatibility with old dictionary interface */
2166 |
2167 | PyObject *
2168 | PyDict_GetItemString(PyObject *v, const char *key)
2169 | {
2170 | PyObject *kv, *rv;
2171 | kv = PyUnicode_FromStringPyUnicodeUCS2_FromString(key);
2172 | if (kv == NULL((void *)0))
2173 | return NULL((void *)0);
2174 | rv = PyDict_GetItem(v, kv);
2175 | Py_DECREF(kv)do { if (_Py_RefTotal-- , --((PyObject*)(kv))->ob_refcnt != 0) { if (((PyObject*)kv)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2175, (PyObject *)(kv)); } else _Py_Dealloc ((PyObject *)(kv)); } while (0);
2176 | return rv;
2177 | }
2178 |
2179 | int
2180 | PyDict_SetItemString(PyObject *v, const char *key, PyObject *item)
2181 | {
2182 | PyObject *kv;
2183 | int err;
2184 | kv = PyUnicode_FromStringPyUnicodeUCS2_FromString(key);
2185 | if (kv == NULL((void *)0))
2186 | return -1;
2187 | PyUnicode_InternInPlace(&kv); /* XXX Should we really? */
2188 | err = PyDict_SetItem(v, kv, item);
2189 | Py_DECREF(kv)do { if (_Py_RefTotal-- , --((PyObject*)(kv))->ob_refcnt != 0) { if (((PyObject*)kv)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2189, (PyObject *)(kv)); } else _Py_Dealloc ((PyObject *)(kv)); } while (0);
2190 | return err;
2191 | }
2192 |
2193 | int
2194 | PyDict_DelItemString(PyObject *v, const char *key)
2195 | {
2196 | PyObject *kv;
2197 | int err;
2198 | kv = PyUnicode_FromStringPyUnicodeUCS2_FromString(key);
2199 | if (kv == NULL((void *)0))
2200 | return -1;
2201 | err = PyDict_DelItem(v, kv);
2202 | Py_DECREF(kv)do { if (_Py_RefTotal-- , --((PyObject*)(kv))->ob_refcnt != 0) { if (((PyObject*)kv)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2202, (PyObject *)(kv)); } else _Py_Dealloc ((PyObject *)(kv)); } while (0);
2203 | return err;
2204 | }
2205 |
2206 | /* Dictionary iterator types */
2207 |
2208 | typedef struct {
2209 | PyObject_HEADPyObject ob_base;
2210 | PyDictObject *di_dict; /* Set to NULL when iterator is exhausted */
2211 | Py_ssize_t di_used;
2212 | Py_ssize_t di_pos;
2213 | PyObject* di_result; /* reusable result tuple for iteritems */
2214 | Py_ssize_t len;
2215 | } dictiterobject;
2216 |
2217 | static PyObject *
2218 | dictiter_new(PyDictObject *dict, PyTypeObject *itertype)
2219 | {
2220 | dictiterobject *di;
2221 | di = PyObject_GC_New(dictiterobject, itertype)( (dictiterobject *) _PyObject_GC_New(itertype) );
2222 | if (di == NULL((void *)0))
2223 | return NULL((void *)0);
2224 | Py_INCREF(dict)( _Py_RefTotal++ , ((PyObject*)(dict))->ob_refcnt++);
2225 | di->di_dict = dict;
2226 | di->di_used = dict->ma_used;
2227 | di->di_pos = 0;
2228 | di->len = dict->ma_used;
2229 | if (itertype == &PyDictIterItem_Type) {
2230 | di->di_result = PyTuple_Pack(2, Py_None(&_Py_NoneStruct), Py_None(&_Py_NoneStruct));
2231 | if (di->di_result == NULL((void *)0)) {
2232 | Py_DECREF(di)do { if (_Py_RefTotal-- , --((PyObject*)(di))->ob_refcnt != 0) { if (((PyObject*)di)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2232, (PyObject *)(di)); } else _Py_Dealloc ((PyObject *)(di)); } while (0);
2233 | return NULL((void *)0);
2234 | }
2235 | }
2236 | else
2237 | di->di_result = NULL((void *)0);
2238 | _PyObject_GC_TRACK(di)do { PyGC_Head *g = ((PyGC_Head *)(di)-1); if (g->gc.gc_refs != (-2)) Py_FatalError("GC object already tracked"); g->gc .gc_refs = (-3); g->gc.gc_next = _PyGC_generation0; g-> gc.gc_prev = _PyGC_generation0->gc.gc_prev; g->gc.gc_prev ->gc.gc_next = g; _PyGC_generation0->gc.gc_prev = g; } while (0);;
2239 | return (PyObject *)di;
2240 | }
2241 |
2242 | static void
2243 | dictiter_dealloc(dictiterobject *di)
2244 | {
2245 | Py_XDECREF(di->di_dict)do { if ((di->di_dict) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(di->di_dict))->ob_refcnt != 0) { if (((PyObject*)di->di_dict)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2245, (PyObject *)(di->di_dict)); } else _Py_Dealloc((PyObject *)(di->di_dict)); } while (0 ); } while (0);
2246 | Py_XDECREF(di->di_result)do { if ((di->di_result) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(di->di_result))->ob_refcnt != 0) { if (((PyObject*)di->di_result)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2246, (PyObject *)(di->di_result) ); } else _Py_Dealloc((PyObject *)(di->di_result)); } while (0); } while (0);
2247 | PyObject_GC_Del(di);
2248 | }
2249 |
2250 | static int
2251 | dictiter_traverse(dictiterobject *di, visitproc visit, void *arg)
2252 | {
2253 | Py_VISIT(di->di_dict)do { if (di->di_dict) { int vret = visit((PyObject *)(di-> di_dict), arg); if (vret) return vret; } } while (0);
2254 | Py_VISIT(di->di_result)do { if (di->di_result) { int vret = visit((PyObject *)(di ->di_result), arg); if (vret) return vret; } } while (0);
2255 | return 0;
2256 | }
2257 |
2258 | static PyObject *
2259 | dictiter_len(dictiterobject *di)
2260 | {
2261 | Py_ssize_t len = 0;
2262 | if (di->di_dict != NULL((void *)0) && di->di_used == di->di_dict->ma_used)
2263 | len = di->len;
2264 | return PyLong_FromSize_t(len);
2265 | }
2266 |
2267 | PyDoc_STRVAR(length_hint_doc,static char length_hint_doc[] = "Private method returning an estimate of len(list(it))."
2268 | "Private method returning an estimate of len(list(it)).")static char length_hint_doc[] = "Private method returning an estimate of len(list(it)).";
2269 |
2270 | static PyMethodDef dictiter_methods[] = {
2271 | {"__length_hint__", (PyCFunction)dictiter_len, METH_NOARGS0x0004,
2272 | length_hint_doc},
2273 | {NULL((void *)0), NULL((void *)0)} /* sentinel */
2274 | };
2275 |
2276 | static PyObject *dictiter_iternextkey(dictiterobject *di)
2277 | {
2278 | PyObject *key;
2279 | register Py_ssize_t i, mask;
2280 | register PyDictEntry *ep;
2281 | PyDictObject *d = di->di_dict;
2282 |
2283 | if (d == NULL((void *)0))
2284 | return NULL((void *)0);
2285 | assert (PyDict_Check(d))(__builtin_expect(!(((((((PyObject*)(d))->ob_type))->tp_flags & ((1L<<29))) != 0)), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 2285, "PyDict_Check(d)") : (void)0);
2286 |
2287 | if (di->di_used != d->ma_used) {
2288 | PyErr_SetString(PyExc_RuntimeError,
2289 | "dictionary changed size during iteration");
2290 | di->di_used = -1; /* Make this state sticky */
2291 | return NULL((void *)0);
2292 | }
2293 |
2294 | i = di->di_pos;
2295 | if (i < 0)
2296 | goto fail;
2297 | ep = d->ma_table;
2298 | mask = d->ma_mask;
2299 | while (i <= mask && ep[i].me_value == NULL((void *)0))
2300 | i++;
2301 | di->di_pos = i+1;
2302 | if (i > mask)
2303 | goto fail;
2304 | di->len--;
2305 | key = ep[i].me_key;
2306 | Py_INCREF(key)( _Py_RefTotal++ , ((PyObject*)(key))->ob_refcnt++);
2307 | return key;
2308 |
2309 | fail:
2310 | Py_DECREF(d)do { if (_Py_RefTotal-- , --((PyObject*)(d))->ob_refcnt != 0) { if (((PyObject*)d)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2310, (PyObject *)(d)); } else _Py_Dealloc ((PyObject *)(d)); } while (0);
2311 | di->di_dict = NULL((void *)0);
2312 | return NULL((void *)0);
2313 | }
2314 |
2315 | PyTypeObject PyDictIterKey_Type = {
2316 | PyVarObject_HEAD_INIT(&PyType_Type, 0){ { 0, 0, 1, &PyType_Type }, 0 },
2317 | "dict_keyiterator", /* tp_name */
2318 | sizeof(dictiterobject), /* tp_basicsize */
2319 | 0, /* tp_itemsize */
2320 | /* methods */
2321 | (destructor)dictiter_dealloc, /* tp_dealloc */
2322 | 0, /* tp_print */
2323 | 0, /* tp_getattr */
2324 | 0, /* tp_setattr */
2325 | 0, /* tp_reserved */
2326 | 0, /* tp_repr */
2327 | 0, /* tp_as_number */
2328 | 0, /* tp_as_sequence */
2329 | 0, /* tp_as_mapping */
2330 | 0, /* tp_hash */
2331 | 0, /* tp_call */
2332 | 0, /* tp_str */
2333 | PyObject_GenericGetAttr, /* tp_getattro */
2334 | 0, /* tp_setattro */
2335 | 0, /* tp_as_buffer */
2336 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_HAVE_GC(1L<<14),/* tp_flags */
2337 | 0, /* tp_doc */
2338 | (traverseproc)dictiter_traverse, /* tp_traverse */
2339 | 0, /* tp_clear */
2340 | 0, /* tp_richcompare */
2341 | 0, /* tp_weaklistoffset */
2342 | PyObject_SelfIter, /* tp_iter */
2343 | (iternextfunc)dictiter_iternextkey, /* tp_iternext */
2344 | dictiter_methods, /* tp_methods */
2345 | 0,
2346 | };
2347 |
2348 | static PyObject *dictiter_iternextvalue(dictiterobject *di)
2349 | {
2350 | PyObject *value;
2351 | register Py_ssize_t i, mask;
2352 | register PyDictEntry *ep;
2353 | PyDictObject *d = di->di_dict;
2354 |
2355 | if (d == NULL((void *)0))
2356 | return NULL((void *)0);
2357 | assert (PyDict_Check(d))(__builtin_expect(!(((((((PyObject*)(d))->ob_type))->tp_flags & ((1L<<29))) != 0)), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 2357, "PyDict_Check(d)") : (void)0);
2358 |
2359 | if (di->di_used != d->ma_used) {
2360 | PyErr_SetString(PyExc_RuntimeError,
2361 | "dictionary changed size during iteration");
2362 | di->di_used = -1; /* Make this state sticky */
2363 | return NULL((void *)0);
2364 | }
2365 |
2366 | i = di->di_pos;
2367 | mask = d->ma_mask;
2368 | if (i < 0 || i > mask)
2369 | goto fail;
2370 | ep = d->ma_table;
2371 | while ((value=ep[i].me_value) == NULL((void *)0)) {
2372 | i++;
2373 | if (i > mask)
2374 | goto fail;
2375 | }
2376 | di->di_pos = i+1;
2377 | di->len--;
2378 | Py_INCREF(value)( _Py_RefTotal++ , ((PyObject*)(value))->ob_refcnt++);
2379 | return value;
2380 |
2381 | fail:
2382 | Py_DECREF(d)do { if (_Py_RefTotal-- , --((PyObject*)(d))->ob_refcnt != 0) { if (((PyObject*)d)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2382, (PyObject *)(d)); } else _Py_Dealloc ((PyObject *)(d)); } while (0);
2383 | di->di_dict = NULL((void *)0);
2384 | return NULL((void *)0);
2385 | }
2386 |
2387 | PyTypeObject PyDictIterValue_Type = {
2388 | PyVarObject_HEAD_INIT(&PyType_Type, 0){ { 0, 0, 1, &PyType_Type }, 0 },
2389 | "dict_valueiterator", /* tp_name */
2390 | sizeof(dictiterobject), /* tp_basicsize */
2391 | 0, /* tp_itemsize */
2392 | /* methods */
2393 | (destructor)dictiter_dealloc, /* tp_dealloc */
2394 | 0, /* tp_print */
2395 | 0, /* tp_getattr */
2396 | 0, /* tp_setattr */
2397 | 0, /* tp_reserved */
2398 | 0, /* tp_repr */
2399 | 0, /* tp_as_number */
2400 | 0, /* tp_as_sequence */
2401 | 0, /* tp_as_mapping */
2402 | 0, /* tp_hash */
2403 | 0, /* tp_call */
2404 | 0, /* tp_str */
2405 | PyObject_GenericGetAttr, /* tp_getattro */
2406 | 0, /* tp_setattro */
2407 | 0, /* tp_as_buffer */
2408 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_HAVE_GC(1L<<14),/* tp_flags */
2409 | 0, /* tp_doc */
2410 | (traverseproc)dictiter_traverse, /* tp_traverse */
2411 | 0, /* tp_clear */
2412 | 0, /* tp_richcompare */
2413 | 0, /* tp_weaklistoffset */
2414 | PyObject_SelfIter, /* tp_iter */
2415 | (iternextfunc)dictiter_iternextvalue, /* tp_iternext */
2416 | dictiter_methods, /* tp_methods */
2417 | 0,
2418 | };
2419 |
2420 | static PyObject *dictiter_iternextitem(dictiterobject *di)
2421 | {
2422 | PyObject *key, *value, *result = di->di_result;
2423 | register Py_ssize_t i, mask;
2424 | register PyDictEntry *ep;
2425 | PyDictObject *d = di->di_dict;
2426 |
2427 | if (d == NULL((void *)0))
2428 | return NULL((void *)0);
2429 | assert (PyDict_Check(d))(__builtin_expect(!(((((((PyObject*)(d))->ob_type))->tp_flags & ((1L<<29))) != 0)), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 2429, "PyDict_Check(d)") : (void)0);
2430 |
2431 | if (di->di_used != d->ma_used) {
2432 | PyErr_SetString(PyExc_RuntimeError,
2433 | "dictionary changed size during iteration");
2434 | di->di_used = -1; /* Make this state sticky */
2435 | return NULL((void *)0);
2436 | }
2437 |
2438 | i = di->di_pos;
2439 | if (i < 0)
2440 | goto fail;
2441 | ep = d->ma_table;
2442 | mask = d->ma_mask;
2443 | while (i <= mask && ep[i].me_value == NULL((void *)0))
2444 | i++;
2445 | di->di_pos = i+1;
2446 | if (i > mask)
2447 | goto fail;
2448 |
2449 | if (result->ob_refcnt == 1) {
2450 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++);
2451 | Py_DECREF(PyTuple_GET_ITEM(result, 0))do { if (_Py_RefTotal-- , --((PyObject*)((((PyTupleObject *)( result))->ob_item[0])))->ob_refcnt != 0) { if (((PyObject *)(((PyTupleObject *)(result))->ob_item[0]))->ob_refcnt < 0) _Py_NegativeRefcount("Objects/dictobject.c", 2451, ( PyObject *)((((PyTupleObject *)(result))->ob_item[0]))); } else _Py_Dealloc((PyObject *)((((PyTupleObject *)(result))-> ob_item[0]))); } while (0);
2452 | Py_DECREF(PyTuple_GET_ITEM(result, 1))do { if (_Py_RefTotal-- , --((PyObject*)((((PyTupleObject *)( result))->ob_item[1])))->ob_refcnt != 0) { if (((PyObject *)(((PyTupleObject *)(result))->ob_item[1]))->ob_refcnt < 0) _Py_NegativeRefcount("Objects/dictobject.c", 2452, ( PyObject *)((((PyTupleObject *)(result))->ob_item[1]))); } else _Py_Dealloc((PyObject *)((((PyTupleObject *)(result))-> ob_item[1]))); } while (0);
2453 | } else {
2454 | result = PyTuple_New(2);
2455 | if (result == NULL((void *)0))
2456 | return NULL((void *)0);
2457 | }
2458 | di->len--;
2459 | key = ep[i].me_key;
2460 | value = ep[i].me_value;
2461 | Py_INCREF(key)( _Py_RefTotal++ , ((PyObject*)(key))->ob_refcnt++);
2462 | Py_INCREF(value)( _Py_RefTotal++ , ((PyObject*)(value))->ob_refcnt++);
2463 | PyTuple_SET_ITEM(result, 0, key)(((PyTupleObject *)(result))->ob_item[0] = key);
2464 | PyTuple_SET_ITEM(result, 1, value)(((PyTupleObject *)(result))->ob_item[1] = value);
2465 | return result;
2466 |
2467 | fail:
2468 | Py_DECREF(d)do { if (_Py_RefTotal-- , --((PyObject*)(d))->ob_refcnt != 0) { if (((PyObject*)d)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2468, (PyObject *)(d)); } else _Py_Dealloc ((PyObject *)(d)); } while (0);
2469 | di->di_dict = NULL((void *)0);
2470 | return NULL((void *)0);
2471 | }
2472 |
2473 | PyTypeObject PyDictIterItem_Type = {
2474 | PyVarObject_HEAD_INIT(&PyType_Type, 0){ { 0, 0, 1, &PyType_Type }, 0 },
2475 | "dict_itemiterator", /* tp_name */
2476 | sizeof(dictiterobject), /* tp_basicsize */
2477 | 0, /* tp_itemsize */
2478 | /* methods */
2479 | (destructor)dictiter_dealloc, /* tp_dealloc */
2480 | 0, /* tp_print */
2481 | 0, /* tp_getattr */
2482 | 0, /* tp_setattr */
2483 | 0, /* tp_reserved */
2484 | 0, /* tp_repr */
2485 | 0, /* tp_as_number */
2486 | 0, /* tp_as_sequence */
2487 | 0, /* tp_as_mapping */
2488 | 0, /* tp_hash */
2489 | 0, /* tp_call */
2490 | 0, /* tp_str */
2491 | PyObject_GenericGetAttr, /* tp_getattro */
2492 | 0, /* tp_setattro */
2493 | 0, /* tp_as_buffer */
2494 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_HAVE_GC(1L<<14),/* tp_flags */
2495 | 0, /* tp_doc */
2496 | (traverseproc)dictiter_traverse, /* tp_traverse */
2497 | 0, /* tp_clear */
2498 | 0, /* tp_richcompare */
2499 | 0, /* tp_weaklistoffset */
2500 | PyObject_SelfIter, /* tp_iter */
2501 | (iternextfunc)dictiter_iternextitem, /* tp_iternext */
2502 | dictiter_methods, /* tp_methods */
2503 | 0,
2504 | };
2505 |
2506 |
2507 | /***********************************************/
2508 | /* View objects for keys(), items(), values(). */
2509 | /***********************************************/
2510 |
2511 | /* The instance lay-out is the same for all three; but the type differs. */
2512 |
2513 | typedef struct {
2514 | PyObject_HEADPyObject ob_base;
2515 | PyDictObject *dv_dict;
2516 | } dictviewobject;
2517 |
2518 |
2519 | static void
2520 | dictview_dealloc(dictviewobject *dv)
2521 | {
2522 | Py_XDECREF(dv->dv_dict)do { if ((dv->dv_dict) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(dv->dv_dict))->ob_refcnt != 0) { if (((PyObject*)dv->dv_dict)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2522, (PyObject *)(dv->dv_dict)); } else _Py_Dealloc((PyObject *)(dv->dv_dict)); } while (0 ); } while (0);
2523 | PyObject_GC_Del(dv);
2524 | }
2525 |
2526 | static int
2527 | dictview_traverse(dictviewobject *dv, visitproc visit, void *arg)
2528 | {
2529 | Py_VISIT(dv->dv_dict)do { if (dv->dv_dict) { int vret = visit((PyObject *)(dv-> dv_dict), arg); if (vret) return vret; } } while (0);
2530 | return 0;
2531 | }
2532 |
2533 | static Py_ssize_t
2534 | dictview_len(dictviewobject *dv)
2535 | {
2536 | Py_ssize_t len = 0;
2537 | if (dv->dv_dict != NULL((void *)0))
2538 | len = dv->dv_dict->ma_used;
2539 | return len;
2540 | }
2541 |
2542 | static PyObject *
2543 | dictview_new(PyObject *dict, PyTypeObject *type)
2544 | {
2545 | dictviewobject *dv;
2546 | if (dict == NULL((void *)0)) {
2547 | PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/dictobject.c", 2547);
2548 | return NULL((void *)0);
2549 | }
2550 | if (!PyDict_Check(dict)((((((PyObject*)(dict))->ob_type))->tp_flags & ((1L <<29))) != 0)) {
2551 | /* XXX Get rid of this restriction later */
2552 | PyErr_Format(PyExc_TypeError,
2553 | "%s() requires a dict argument, not '%s'",
2554 | type->tp_name, dict->ob_type->tp_name);
2555 | return NULL((void *)0);
2556 | }
2557 | dv = PyObject_GC_New(dictviewobject, type)( (dictviewobject *) _PyObject_GC_New(type) );
2558 | if (dv == NULL((void *)0))
2559 | return NULL((void *)0);
2560 | Py_INCREF(dict)( _Py_RefTotal++ , ((PyObject*)(dict))->ob_refcnt++);
2561 | dv->dv_dict = (PyDictObject *)dict;
2562 | _PyObject_GC_TRACK(dv)do { PyGC_Head *g = ((PyGC_Head *)(dv)-1); if (g->gc.gc_refs != (-2)) Py_FatalError("GC object already tracked"); g->gc .gc_refs = (-3); g->gc.gc_next = _PyGC_generation0; g-> gc.gc_prev = _PyGC_generation0->gc.gc_prev; g->gc.gc_prev ->gc.gc_next = g; _PyGC_generation0->gc.gc_prev = g; } while (0);;
2563 | return (PyObject *)dv;
2564 | }
2565 |
2566 | /* TODO(guido): The views objects are not complete:
2567 |
2568 | * support more set operations
2569 | * support arbitrary mappings?
2570 | - either these should be static or exported in dictobject.h
2571 | - if public then they should probably be in builtins
2572 | */
2573 |
2574 | /* Return 1 if self is a subset of other, iterating over self;
2575 | 0 if not; -1 if an error occurred. */
2576 | static int
2577 | all_contained_in(PyObject *self, PyObject *other)
2578 | {
2579 | PyObject *iter = PyObject_GetIter(self);
2580 | int ok = 1;
2581 |
2582 | if (iter == NULL((void *)0))
2583 | return -1;
2584 | for (;;) {
2585 | PyObject *next = PyIter_Next(iter);
2586 | if (next == NULL((void *)0)) {
2587 | if (PyErr_Occurred())
2588 | ok = -1;
2589 | break;
2590 | }
2591 | ok = PySequence_Contains(other, next);
2592 | Py_DECREF(next)do { if (_Py_RefTotal-- , --((PyObject*)(next))->ob_refcnt != 0) { if (((PyObject*)next)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2592, (PyObject *)(next)); } else _Py_Dealloc ((PyObject *)(next)); } while (0);
2593 | if (ok <= 0)
2594 | break;
2595 | }
2596 | Py_DECREF(iter)do { if (_Py_RefTotal-- , --((PyObject*)(iter))->ob_refcnt != 0) { if (((PyObject*)iter)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2596, (PyObject *)(iter)); } else _Py_Dealloc ((PyObject *)(iter)); } while (0);
2597 | return ok;
2598 | }
2599 |
2600 | static PyObject *
2601 | dictview_richcompare(PyObject *self, PyObject *other, int op)
2602 | {
2603 | Py_ssize_t len_self, len_other;
2604 | int ok;
2605 | PyObject *result;
2606 |
2607 | assert(self != NULL)(__builtin_expect(!(self != ((void *)0)), 0) ? __assert_rtn(__func__ , "Objects/dictobject.c", 2607, "self != NULL") : (void)0);
2608 | assert(PyDictViewSet_Check(self))(__builtin_expect(!((((((PyObject*)(self))->ob_type) == & PyDictKeys_Type) || ((((PyObject*)(self))->ob_type) == & PyDictItems_Type))), 0) ? __assert_rtn(__func__, "Objects/dictobject.c" , 2608, "PyDictViewSet_Check(self)") : (void)0);
2609 | assert(other != NULL)(__builtin_expect(!(other != ((void *)0)), 0) ? __assert_rtn( __func__, "Objects/dictobject.c", 2609, "other != NULL") : (void )0);
2610 |
2611 | if (!PyAnySet_Check(other)((((PyObject*)(other))->ob_type) == &PySet_Type || ((( PyObject*)(other))->ob_type) == &PyFrozenSet_Type || PyType_IsSubtype ((((PyObject*)(other))->ob_type), &PySet_Type) || PyType_IsSubtype ((((PyObject*)(other))->ob_type), &PyFrozenSet_Type)) && !PyDictViewSet_Check(other)(((((PyObject*)(other))->ob_type) == &PyDictKeys_Type) || ((((PyObject*)(other))->ob_type) == &PyDictItems_Type ))) {
2612 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++);
2613 | return Py_NotImplemented(&_Py_NotImplementedStruct);
2614 | }
2615 |
2616 | len_self = PyObject_Size(self);
2617 | if (len_self < 0)
2618 | return NULL((void *)0);
2619 | len_other = PyObject_Size(other);
2620 | if (len_other < 0)
2621 | return NULL((void *)0);
2622 |
2623 | ok = 0;
2624 | switch(op) {
2625 |
2626 | case Py_NE3:
2627 | case Py_EQ2:
2628 | if (len_self == len_other)
2629 | ok = all_contained_in(self, other);
2630 | if (op == Py_NE3 && ok >= 0)
2631 | ok = !ok;
2632 | break;
2633 |
2634 | case Py_LT0:
2635 | if (len_self < len_other)
2636 | ok = all_contained_in(self, other);
2637 | break;
2638 |
2639 | case Py_LE1:
2640 | if (len_self <= len_other)
2641 | ok = all_contained_in(self, other);
2642 | break;
2643 |
2644 | case Py_GT4:
2645 | if (len_self > len_other)
2646 | ok = all_contained_in(other, self);
2647 | break;
2648 |
2649 | case Py_GE5:
2650 | if (len_self >= len_other)
2651 | ok = all_contained_in(other, self);
2652 | break;
2653 |
2654 | }
2655 | if (ok < 0)
2656 | return NULL((void *)0);
2657 | result = ok ? Py_True((PyObject *) &_Py_TrueStruct) : Py_False((PyObject *) &_Py_FalseStruct);
2658 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++);
2659 | return result;
2660 | }
2661 |
2662 | static PyObject *
2663 | dictview_repr(dictviewobject *dv)
2664 | {
2665 | PyObject *seq;
2666 | PyObject *result;
2667 |
2668 | seq = PySequence_List((PyObject *)dv);
2669 | if (seq == NULL((void *)0))
2670 | return NULL((void *)0);
2671 |
2672 | result = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s(%R)", Py_TYPE(dv)(((PyObject*)(dv))->ob_type)->tp_name, seq);
2673 | Py_DECREF(seq)do { if (_Py_RefTotal-- , --((PyObject*)(seq))->ob_refcnt != 0) { if (((PyObject*)seq)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2673, (PyObject *)(seq)); } else _Py_Dealloc ((PyObject *)(seq)); } while (0);
2674 | return result;
2675 | }
2676 |
2677 | /*** dict_keys ***/
2678 |
2679 | static PyObject *
2680 | dictkeys_iter(dictviewobject *dv)
2681 | {
2682 | if (dv->dv_dict == NULL((void *)0)) {
2683 | Py_RETURN_NONEreturn ( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)) )->ob_refcnt++), (&_Py_NoneStruct);
2684 | }
2685 | return dictiter_new(dv->dv_dict, &PyDictIterKey_Type);
2686 | }
2687 |
2688 | static int
2689 | dictkeys_contains(dictviewobject *dv, PyObject *obj)
2690 | {
2691 | if (dv->dv_dict == NULL((void *)0))
2692 | return 0;
2693 | return PyDict_Contains((PyObject *)dv->dv_dict, obj);
2694 | }
2695 |
2696 | static PySequenceMethods dictkeys_as_sequence = {
2697 | (lenfunc)dictview_len, /* sq_length */
2698 | 0, /* sq_concat */
2699 | 0, /* sq_repeat */
2700 | 0, /* sq_item */
2701 | 0, /* sq_slice */
2702 | 0, /* sq_ass_item */
2703 | 0, /* sq_ass_slice */
2704 | (objobjproc)dictkeys_contains, /* sq_contains */
2705 | };
2706 |
2707 | static PyObject*
2708 | dictviews_sub(PyObject* self, PyObject *other)
2709 | {
2710 | PyObject *result = PySet_New(self);
2711 | PyObject *tmp;
2712 | if (result == NULL((void *)0))
2713 | return NULL((void *)0);
2714 |
2715 | tmp = PyObject_CallMethod(result, "difference_update", "O", other);
2716 | if (tmp == NULL((void *)0)) {
2717 | Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt != 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2717, (PyObject *)(result)); } else _Py_Dealloc ((PyObject *)(result)); } while (0);
2718 | return NULL((void *)0);
2719 | }
2720 |
2721 | Py_DECREF(tmp)do { if (_Py_RefTotal-- , --((PyObject*)(tmp))->ob_refcnt != 0) { if (((PyObject*)tmp)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2721, (PyObject *)(tmp)); } else _Py_Dealloc ((PyObject *)(tmp)); } while (0);
2722 | return result;
2723 | }
2724 |
2725 | static PyObject*
2726 | dictviews_and(PyObject* self, PyObject *other)
2727 | {
2728 | PyObject *result = PySet_New(self);
2729 | PyObject *tmp;
2730 | if (result == NULL((void *)0))
2731 | return NULL((void *)0);
2732 |
2733 | tmp = PyObject_CallMethod(result, "intersection_update", "O", other);
2734 | if (tmp == NULL((void *)0)) {
2735 | Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt != 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2735, (PyObject *)(result)); } else _Py_Dealloc ((PyObject *)(result)); } while (0);
2736 | return NULL((void *)0);
2737 | }
2738 |
2739 | Py_DECREF(tmp)do { if (_Py_RefTotal-- , --((PyObject*)(tmp))->ob_refcnt != 0) { if (((PyObject*)tmp)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2739, (PyObject *)(tmp)); } else _Py_Dealloc ((PyObject *)(tmp)); } while (0);
2740 | return result;
2741 | }
2742 |
2743 | static PyObject*
2744 | dictviews_or(PyObject* self, PyObject *other)
2745 | {
2746 | PyObject *result = PySet_New(self);
2747 | PyObject *tmp;
2748 | if (result == NULL((void *)0))
2749 | return NULL((void *)0);
2750 |
2751 | tmp = PyObject_CallMethod(result, "update", "O", other);
2752 | if (tmp == NULL((void *)0)) {
2753 | Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt != 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2753, (PyObject *)(result)); } else _Py_Dealloc ((PyObject *)(result)); } while (0);
2754 | return NULL((void *)0);
2755 | }
2756 |
2757 | Py_DECREF(tmp)do { if (_Py_RefTotal-- , --((PyObject*)(tmp))->ob_refcnt != 0) { if (((PyObject*)tmp)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2757, (PyObject *)(tmp)); } else _Py_Dealloc ((PyObject *)(tmp)); } while (0);
2758 | return result;
2759 | }
2760 |
2761 | static PyObject*
2762 | dictviews_xor(PyObject* self, PyObject *other)
2763 | {
2764 | PyObject *result = PySet_New(self);
2765 | PyObject *tmp;
2766 | if (result == NULL((void *)0))
2767 | return NULL((void *)0);
2768 |
2769 | tmp = PyObject_CallMethod(result, "symmetric_difference_update", "O",
2770 | other);
2771 | if (tmp == NULL((void *)0)) {
2772 | Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt != 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2772, (PyObject *)(result)); } else _Py_Dealloc ((PyObject *)(result)); } while (0);
2773 | return NULL((void *)0);
2774 | }
2775 |
2776 | Py_DECREF(tmp)do { if (_Py_RefTotal-- , --((PyObject*)(tmp))->ob_refcnt != 0) { if (((PyObject*)tmp)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2776, (PyObject *)(tmp)); } else _Py_Dealloc ((PyObject *)(tmp)); } while (0);
2777 | return result;
2778 | }
2779 |
2780 | static PyNumberMethods dictviews_as_number = {
2781 | 0, /*nb_add*/
2782 | (binaryfunc)dictviews_sub, /*nb_subtract*/
2783 | 0, /*nb_multiply*/
2784 | 0, /*nb_remainder*/
2785 | 0, /*nb_divmod*/
2786 | 0, /*nb_power*/
2787 | 0, /*nb_negative*/
2788 | 0, /*nb_positive*/
2789 | 0, /*nb_absolute*/
2790 | 0, /*nb_bool*/
2791 | 0, /*nb_invert*/
2792 | 0, /*nb_lshift*/
2793 | 0, /*nb_rshift*/
2794 | (binaryfunc)dictviews_and, /*nb_and*/
2795 | (binaryfunc)dictviews_xor, /*nb_xor*/
2796 | (binaryfunc)dictviews_or, /*nb_or*/
2797 | };
2798 |
2799 | static PyObject*
2800 | dictviews_isdisjoint(PyObject *self, PyObject *other)
2801 | {
2802 | PyObject *it;
2803 | PyObject *item = NULL((void *)0);
2804 |
2805 | if (self == other) {
2806 | if (dictview_len((dictviewobject *)self) == 0)
2807 | Py_RETURN_TRUEreturn ( _Py_RefTotal++ , ((PyObject*)(((PyObject *) &_Py_TrueStruct )))->ob_refcnt++), ((PyObject *) &_Py_TrueStruct);
2808 | else
2809 | Py_RETURN_FALSEreturn ( _Py_RefTotal++ , ((PyObject*)(((PyObject *) &_Py_FalseStruct )))->ob_refcnt++), ((PyObject *) &_Py_FalseStruct);
2810 | }
2811 |
2812 | /* Iterate over the shorter object (only if other is a set,
2813 | * because PySequence_Contains may be expensive otherwise): */
2814 | if (PyAnySet_Check(other)((((PyObject*)(other))->ob_type) == &PySet_Type || ((( PyObject*)(other))->ob_type) == &PyFrozenSet_Type || PyType_IsSubtype ((((PyObject*)(other))->ob_type), &PySet_Type) || PyType_IsSubtype ((((PyObject*)(other))->ob_type), &PyFrozenSet_Type)) || PyDictViewSet_Check(other)(((((PyObject*)(other))->ob_type) == &PyDictKeys_Type) || ((((PyObject*)(other))->ob_type) == &PyDictItems_Type ))) {
2815 | Py_ssize_t len_self = dictview_len((dictviewobject *)self);
2816 | Py_ssize_t len_other = PyObject_Size(other);
2817 | if (len_other == -1)
2818 | return NULL((void *)0);
2819 |
2820 | if ((len_other > len_self)) {
2821 | PyObject *tmp = other;
2822 | other = self;
2823 | self = tmp;
2824 | }
2825 | }
2826 |
2827 | it = PyObject_GetIter(other);
2828 | if (it == NULL((void *)0))
2829 | return NULL((void *)0);
2830 |
2831 | while ((item = PyIter_Next(it)) != NULL((void *)0)) {
2832 | int contains = PySequence_Contains(self, item);
2833 | Py_DECREF(item)do { if (_Py_RefTotal-- , --((PyObject*)(item))->ob_refcnt != 0) { if (((PyObject*)item)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2833, (PyObject *)(item)); } else _Py_Dealloc ((PyObject *)(item)); } while (0);
2834 | if (contains == -1) {
2835 | Py_DECREF(it)do { if (_Py_RefTotal-- , --((PyObject*)(it))->ob_refcnt != 0) { if (((PyObject*)it)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2835, (PyObject *)(it)); } else _Py_Dealloc ((PyObject *)(it)); } while (0);
2836 | return NULL((void *)0);
2837 | }
2838 |
2839 | if (contains) {
2840 | Py_DECREF(it)do { if (_Py_RefTotal-- , --((PyObject*)(it))->ob_refcnt != 0) { if (((PyObject*)it)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2840, (PyObject *)(it)); } else _Py_Dealloc ((PyObject *)(it)); } while (0);
2841 | Py_RETURN_FALSEreturn ( _Py_RefTotal++ , ((PyObject*)(((PyObject *) &_Py_FalseStruct )))->ob_refcnt++), ((PyObject *) &_Py_FalseStruct);
2842 | }
2843 | }
2844 | Py_DECREF(it)do { if (_Py_RefTotal-- , --((PyObject*)(it))->ob_refcnt != 0) { if (((PyObject*)it)->ob_refcnt < 0) _Py_NegativeRefcount ("Objects/dictobject.c", 2844, (PyObject *)(it)); } else _Py_Dealloc ((PyObject *)(it)); } while (0);
2845 | if (PyErr_Occurred())
2846 | return NULL((void *)0); /* PyIter_Next raised an exception. */
2847 | Py_RETURN_TRUEreturn ( _Py_RefTotal++ , ((PyObject*)(((PyObject *) &_Py_TrueStruct )))->ob_refcnt++), ((PyObject *) &_Py_TrueStruct);
2848 | }
2849 |
2850 | PyDoc_STRVAR(isdisjoint_doc,static char isdisjoint_doc[] = "Return True if the view and the given iterable have a null intersection."
2851 | "Return True if the view and the given iterable have a null intersection.")static char isdisjoint_doc[] = "Return True if the view and the given iterable have a null intersection.";
2852 |
2853 | static PyMethodDef dictkeys_methods[] = {
2854 | {"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O0x0008,
2855 | isdisjoint_doc},
2856 | {NULL((void *)0), NULL((void *)0)} /* sentinel */
2857 | };
2858 |
2859 | PyTypeObject PyDictKeys_Type = {
2860 | PyVarObject_HEAD_INIT(&PyType_Type, 0){ { 0, 0, 1, &PyType_Type }, 0 },
2861 | "dict_keys", /* tp_name */
2862 | sizeof(dictviewobject), /* tp_basicsize */
2863 | 0, /* tp_itemsize */
2864 | /* methods */
2865 | (destructor)dictview_dealloc, /* tp_dealloc */
2866 | 0, /* tp_print */
2867 | 0, /* tp_getattr */
2868 | 0, /* tp_setattr */
2869 | 0, /* tp_reserved */
2870 | (reprfunc)dictview_repr, /* tp_repr */
2871 | &dictviews_as_number, /* tp_as_number */
2872 | &dictkeys_as_sequence, /* tp_as_sequence */
2873 | 0, /* tp_as_mapping */
2874 | 0, /* tp_hash */
2875 | 0, /* tp_call */
2876 | 0, /* tp_str */
2877 | PyObject_GenericGetAttr, /* tp_getattro */
2878 | 0, /* tp_setattro */
2879 | 0, /* tp_as_buffer */
2880 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_HAVE_GC(1L<<14),/* tp_flags */
2881 | 0, /* tp_doc */
2882 | (traverseproc)dictview_traverse, /* tp_traverse */
2883 | 0, /* tp_clear */
2884 | dictview_richcompare, /* tp_richcompare */
2885 | 0, /* tp_weaklistoffset */
2886 | (getiterfunc)dictkeys_iter, /* tp_iter */
2887 | 0, /* tp_iternext */
2888 | dictkeys_methods, /* tp_methods */
2889 | 0,
2890 | };
2891 |
2892 | static PyObject *
2893 | dictkeys_new(PyObject *dict)
2894 | {
2895 | return dictview_new(dict, &PyDictKeys_Type);
2896 | }
2897 |
2898 | /*** dict_items ***/
2899 |
2900 | static PyObject *
2901 | dictitems_iter(dictviewobject *dv)
2902 | {
2903 | if (dv->dv_dict == NULL((void *)0)) {
2904 | Py_RETURN_NONEreturn ( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)) )->ob_refcnt++), (&_Py_NoneStruct);
2905 | }
2906 | return dictiter_new(dv->dv_dict, &PyDictIterItem_Type);
2907 | }
2908 |
2909 | static int
2910 | dictitems_contains(dictviewobject *dv, PyObject *obj)
2911 | {
2912 | PyObject *key, *value, *found;
2913 | if (dv->dv_dict == NULL((void *)0))
2914 | return 0;
2915 | if (!PyTuple_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<< 26))) != 0) || PyTuple_GET_SIZE(obj)(((PyVarObject*)(obj))->ob_size) != 2)
2916 | return 0;
2917 | key = PyTuple_GET_ITEM(obj, 0)(((PyTupleObject *)(obj))->ob_item[0]);
2918 | value = PyTuple_GET_ITEM(obj, 1)(((PyTupleObject *)(obj))->ob_item[1]);
2919 | found = PyDict_GetItem((PyObject *)dv->dv_dict, key);
2920 | if (found == NULL((void *)0)) {
2921 | if (PyErr_Occurred())
2922 | return -1;
2923 | return 0;
2924 | }
2925 | return PyObject_RichCompareBool(value, found, Py_EQ2);
2926 | }
2927 |
2928 | static PySequenceMethods dictitems_as_sequence = {
2929 | (lenfunc)dictview_len, /* sq_length */
2930 | 0, /* sq_concat */
2931 | 0, /* sq_repeat */
2932 | 0, /* sq_item */
2933 | 0, /* sq_slice */
2934 | 0, /* sq_ass_item */
2935 | 0, /* sq_ass_slice */
2936 | (objobjproc)dictitems_contains, /* sq_contains */
2937 | };
2938 |
2939 | static PyMethodDef dictitems_methods[] = {
2940 | {"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O0x0008,
2941 | isdisjoint_doc},
2942 | {NULL((void *)0), NULL((void *)0)} /* sentinel */
2943 | };
2944 |
2945 | PyTypeObject PyDictItems_Type = {
2946 | PyVarObject_HEAD_INIT(&PyType_Type, 0){ { 0, 0, 1, &PyType_Type }, 0 },
2947 | "dict_items", /* tp_name */
2948 | sizeof(dictviewobject), /* tp_basicsize */
2949 | 0, /* tp_itemsize */
2950 | /* methods */
2951 | (destructor)dictview_dealloc, /* tp_dealloc */
2952 | 0, /* tp_print */
2953 | 0, /* tp_getattr */
2954 | 0, /* tp_setattr */
2955 | 0, /* tp_reserved */
2956 | (reprfunc)dictview_repr, /* tp_repr */
2957 | &dictviews_as_number, /* tp_as_number */
2958 | &dictitems_as_sequence, /* tp_as_sequence */
2959 | 0, /* tp_as_mapping */
2960 | 0, /* tp_hash */
2961 | 0, /* tp_call */
2962 | 0, /* tp_str */
2963 | PyObject_GenericGetAttr, /* tp_getattro */
2964 | 0, /* tp_setattro */
2965 | 0, /* tp_as_buffer */
2966 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_HAVE_GC(1L<<14),/* tp_flags */
2967 | 0, /* tp_doc */
2968 | (traverseproc)dictview_traverse, /* tp_traverse */
2969 | 0, /* tp_clear */
2970 | dictview_richcompare, /* tp_richcompare */
2971 | 0, /* tp_weaklistoffset */
2972 | (getiterfunc)dictitems_iter, /* tp_iter */
2973 | 0, /* tp_iternext */
2974 | dictitems_methods, /* tp_methods */
2975 | 0,
2976 | };
2977 |
2978 | static PyObject *
2979 | dictitems_new(PyObject *dict)
2980 | {
2981 | return dictview_new(dict, &PyDictItems_Type);
2982 | }
2983 |
2984 | /*** dict_values ***/
2985 |
2986 | static PyObject *
2987 | dictvalues_iter(dictviewobject *dv)
2988 | {
2989 | if (dv->dv_dict == NULL((void *)0)) {
2990 | Py_RETURN_NONEreturn ( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)) )->ob_refcnt++), (&_Py_NoneStruct);
2991 | }
2992 | return dictiter_new(dv->dv_dict, &PyDictIterValue_Type);
2993 | }
2994 |
2995 | static PySequenceMethods dictvalues_as_sequence = {
2996 | (lenfunc)dictview_len, /* sq_length */
2997 | 0, /* sq_concat */
2998 | 0, /* sq_repeat */
2999 | 0, /* sq_item */
3000 | 0, /* sq_slice */
3001 | 0, /* sq_ass_item */
3002 | 0, /* sq_ass_slice */
3003 | (objobjproc)0, /* sq_contains */
3004 | };
3005 |
3006 | static PyMethodDef dictvalues_methods[] = {
3007 | {NULL((void *)0), NULL((void *)0)} /* sentinel */
3008 | };
3009 |
3010 | PyTypeObject PyDictValues_Type = {
3011 | PyVarObject_HEAD_INIT(&PyType_Type, 0){ { 0, 0, 1, &PyType_Type }, 0 },
3012 | "dict_values", /* tp_name */
3013 | sizeof(dictviewobject), /* tp_basicsize */
3014 | 0, /* tp_itemsize */
3015 | /* methods */
3016 | (destructor)dictview_dealloc, /* tp_dealloc */
3017 | 0, /* tp_print */
3018 | 0, /* tp_getattr */
3019 | 0, /* tp_setattr */
3020 | 0, /* tp_reserved */
3021 | (reprfunc)dictview_repr, /* tp_repr */
3022 | 0, /* tp_as_number */
3023 | &dictvalues_as_sequence, /* tp_as_sequence */
3024 | 0, /* tp_as_mapping */
3025 | 0, /* tp_hash */
3026 | 0, /* tp_call */
3027 | 0, /* tp_str */
3028 | PyObject_GenericGetAttr, /* tp_getattro */
3029 | 0, /* tp_setattro */
3030 | 0, /* tp_as_buffer */
3031 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_HAVE_GC(1L<<14),/* tp_flags */
3032 | 0, /* tp_doc */
3033 | (traverseproc)dictview_traverse, /* tp_traverse */
3034 | 0, /* tp_clear */
3035 | 0, /* tp_richcompare */
3036 | 0, /* tp_weaklistoffset */
3037 | (getiterfunc)dictvalues_iter, /* tp_iter */
3038 | 0, /* tp_iternext */
3039 | dictvalues_methods, /* tp_methods */
3040 | 0,
3041 | };
3042 |
3043 | static PyObject *
3044 | dictvalues_new(PyObject *dict)
3045 | {
3046 | return dictview_new(dict, &PyDictValues_Type);
3047 | }