Rewrite PackData.resolve_object to iterate rather than recurse.

Delta chains can get long, and recursion doesn't buy us much here.

dulwich/pack.py

@@ -1061,33 +1061,48 @@ class PackData(object):
 
         :return: Tuple with object type and contents.
         """
-        if type not in DELTA_TYPES:
+        # Walk down the delta chain, building a stack of deltas to reach
-            return type, obj
+        # the requested object.
-
+        base_offset = offset
-        if get_ref is None:
+        base_type = type
-            get_ref = self.get_ref
+        base_obj = obj
-        if type == OFS_DELTA:
+        delta_stack = []
-            (delta_offset, delta) = obj
+        while base_type in DELTA_TYPES:
-            # TODO: clean up asserts and replace with nicer error messages
+            prev_offset = base_offset
-            assert isinstance(offset, int) or isinstance(offset, long)
+            if get_ref is None:
-            assert isinstance(delta_offset, int) or isinstance(offset, long)
+                get_ref = self.get_ref
-            base_offset = offset-delta_offset
+            if base_type == OFS_DELTA:
-            type, base_obj = self.get_object_at(base_offset)
+                (delta_offset, delta) = base_obj
-            assert isinstance(type, int)
+                # TODO: clean up asserts and replace with nicer error messages
-        elif type == REF_DELTA:
+                assert (
-            (basename, delta) = obj
+                    isinstance(base_offset, int)
-            assert isinstance(basename, bytes) and len(basename) == 20
+                    or isinstance(base_offset, long))
-            base_offset, type, base_obj = get_ref(basename)
+                assert (
-            assert isinstance(type, int)
+                    isinstance(delta_offset, int)
-        type, base_chunks = self.resolve_object(base_offset, type, base_obj)
+                    or isinstance(base_offset, long))
-        chunks = apply_delta(base_chunks, delta)
+                base_offset = base_offset - delta_offset
-        # TODO(dborowitz): This can result in poor performance if large base
+                base_type, base_obj = self.get_object_at(base_offset)
-        # objects are separated from deltas in the pack. We should reorganize
+                assert isinstance(base_type, int)
-        # so that we apply deltas to all objects in a chain one after the other
+            elif base_type == REF_DELTA:
-        # to optimize cache performance.
+                (basename, delta) = base_obj
-        if offset is not None:
+                assert isinstance(basename, bytes) and len(basename) == 20
-            self._offset_cache[offset] = type, chunks
+                base_offset, base_type, base_obj = get_ref(basename)
-        return type, chunks
+                assert isinstance(base_type, int)
+            delta_stack.append((prev_offset, base_type, delta))
+
+        # Now grab the base object (mustn't be a delta) and apply the
+        # deltas all the way up the stack.
+        chunks = base_obj
+        for prev_offset, delta_type, delta in reversed(delta_stack):
+            chunks = apply_delta(chunks, delta)
+            # TODO(dborowitz): This can result in poor performance if
+            # large base objects are separated from deltas in the pack.
+            # We should reorganize so that we apply deltas to all
+            # objects in a chain one after the other to optimize cache
+            # performance.
+            if prev_offset is not None:
+                self._offset_cache[prev_offset] = base_type, chunks
+        return base_type, chunks
 
     def iterobjects(self, progress=None, compute_crc32=True):
         self._file.seek(self._header_size)