Fix memory leak in ft2font/mathtext.

mdboom · mdboom · commit 37a7aa69b942 · 2011-03-10T11:04:39.000-05:00
diff --git a/lib/matplotlib/backends/backend_agg.py b/lib/matplotlib/backends/backend_agg.py
@@ -131,6 +131,9 @@ def draw_mathtext(self, gc, x, y, s, prop, angle):
         x = int(x) + ox
         y = int(y) - oy
         self._renderer.draw_text_image(font_image, x, y + 1, angle, gc)
+        # XXX: This is to work around a bug in Python 3 where it
+        # apparently leaks references to frames
+        del font_image
 
     def draw_text(self, gc, x, y, s, prop, angle, ismath):
         """
diff --git a/lib/matplotlib/mathtext.py b/lib/matplotlib/mathtext.py
@@ -212,13 +212,15 @@ def get_results(self, box, used_characters):
             (bbox[3] - bbox[1]) - orig_depth,
             (bbox[3] - bbox[1]) - orig_height)
         ship(-bbox[0], -bbox[1], box)
-        return (self.ox,
-                self.oy,
-                self.width,
-                self.height + self.depth,
-                self.depth,
-                self.image,
-                used_characters)
+        result = (self.ox,
+                  self.oy,
+                  self.width,
+                  self.height + self.depth,
+                  self.depth,
+                  self.image,
+                  used_characters)
+        self.image = None
+        return result
 
     def get_hinting_type(self):
         if rcParams['text.hinting']:
@@ -266,7 +268,6 @@ def render_rect_filled(self, x1, y1, x2, y2):
 
     def get_results(self, box, used_characters):
         ship(0, -self.depth, box)
-        #print self.depth
         return (self.width,
                 self.height + self.depth,
                 self.depth,
@@ -529,7 +530,9 @@ def get_results(self, box):
         Get the data needed by the backend to render the math
         expression.  The return value is backend-specific.
         """
-        return self.mathtext_backend.get_results(box, self.get_used_characters())
+        result = self.mathtext_backend.get_results(box, self.get_used_characters())
+        self.destroy()
+        return result
 
     def get_sized_alternatives_for_symbol(self, fontname, sym):
         """
@@ -2308,16 +2311,6 @@ def __init__(self):
             )
           ) + StringEnd()
 
-        self.clear()
-
-    def clear(self):
-        """
-        Clear any state before parsing.
-        """
-        self._expr = None
-        self._state_stack = None
-        self._em_width_cache = {}
-
     def parse(self, s, fonts_object, fontsize, dpi):
         """
         Parse expression *s* using the given *fonts_object* for
@@ -2326,15 +2319,18 @@ def parse(self, s, fonts_object, fontsize, dpi):
         Returns the parse tree of :class:`Node` instances.
         """
         self._state_stack = [self.State(fonts_object, 'default', 'rm', fontsize, dpi)]
+        self._em_width_cache = {}
         try:
-            self._expression.parseString(s)
+            result = self._expression.parseString(s)
         except ParseException as err:
             raise ValueError("\n".join([
                         "",
                         err.line,
                         " " * (err.column - 1) + "^",
                         str(err)]))
-        return self._expr
+        self._state_stack = None
+        self._em_width_cache = {}
+        return result[0]
 
     # The state of the parser is maintained in a stack.  Upon
     # entering and leaving a group { } or math/non-math, the stack
@@ -2391,8 +2387,7 @@ def push_state(self):
 
     def finish(self, s, loc, toks):
         #~ print "finish", toks
-        self._expr = Hlist(toks)
-        return [self._expr]
+        return [Hlist(toks)]
 
     def math(self, s, loc, toks):
         #~ print "math", toks
@@ -2920,12 +2915,16 @@ def parse(self, s, dpi = 72, prop = None):
         The results are cached, so multiple calls to :meth:`parse`
         with the same expression should be fast.
         """
+        # There is a bug in Python 3.x where it leaks frame references,
+        # and therefore can't handle this caching
         if prop is None:
             prop = FontProperties()
-        cacheKey = (s, dpi, hash(prop))
-        result = self._cache.get(cacheKey)
-        if result is not None:
-            return result
+
+        if sys.version_info[0] < 3:
+            cacheKey = (s, dpi, hash(prop))
+            result = self._cache.get(cacheKey)
+            if result is not None:
+                return result
 
         if self._output == 'ps' and rcParams['ps.useafm']:
             font_output = StandardPsFonts(prop)
@@ -2949,15 +2948,12 @@ def parse(self, s, dpi = 72, prop = None):
 
         box = self._parser.parse(s, font_output, fontsize, dpi)
         font_output.set_canvas_size(box.width, box.height, box.depth)
-        result = font_output.get_results(box)
-        self._cache[cacheKey] = result
-        # Free up the transient data structures
-        self._parser.clear()
-
-        # Fix cyclical references
-        font_output.destroy()
-
-        return result
+        if sys.version_info[0] >= 3:
+            return font_output.get_results(box)
+        else:
+            result = font_output.get_results(box)
+            self._cache[cacheKey] = result
+            return result
 
     def to_mask(self, texstr, dpi=120, fontsize=14):
         """
