1. 18 Apr, 2001 18 commits
  2. 17 Apr, 2001 1 commit
  3. 16 Apr, 2001 19 commits
  4. 15 Apr, 2001 2 commits
    • Guido van Rossum's avatar
      Tentative fix for a problem that Tim discovered at the last moment, · 19556298
      Guido van Rossum authored
      and reported to python-dev: because we were calling dict_resize() in
      PyDict_Next(), and because GC's dict_traverse() uses PyDict_Next(),
      and because PyTuple_New() can cause GC, and because dict_items() calls
      PyTuple_New(), it was possible for dict_items() to have the dict
      resized right under its nose.
      
      The solution is convoluted, and touches several places: keys(),
      values(), items(), popitem(), PyDict_Next(), and PyDict_SetItem().
      
      There are two parts to it. First, we no longer call dict_resize() in
      PyDict_Next(), which seems to solve the immediate problem.  But then
      PyDict_SetItem() must have a different policy about when *it* calls
      dict_resize(), because we want to guarantee (e.g. for an algorithm
      that Jeremy uses in the compiler) that you can loop over a dict using
      PyDict_Next() and make changes to the dict as long as those changes
      are only value replacements for existing keys using PyDict_SetItem().
      This is done by resizing *after* the insertion instead of before, and
      by remembering the size before we insert the item, and if the size is
      still the same, we don't bother to even check if we might need to
      resize.  An additional detail is that if the dict starts out empty, we
      must still resize it before the insertion.
      
      That was the first part. :-)
      
      The second part is to make keys(), values(), items(), and popitem()
      safe against side effects on the dict caused by allocations, under the
      assumption that if the GC can cause arbitrary Python code to run, it
      can cause other threads to run, and it's not inconceivable that our
      dict could be resized -- it would be insane to write code that relies
      on this, but not all code is sane.
      
      Now, I have this nagging feeling that the loops in lookdict probably
      are blissfully assuming that doing a simple key comparison does not
      change the dict's size.  This is not necessarily true (the keys could
      be class instances after all).  But that's a battle for another day.
      19556298
    • Guido van Rossum's avatar
      SF bug reporters. · 1a27901e
      Guido van Rossum authored
      1a27901e