← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/xml_serializer.py

  • Committer: Martin Packman
  • Author(s): John Arbash Meinel
  • Date: 2011-09-30 16:29:17 UTC
  • mto: (6015.33.7 2.4)
  • mto: This revision was merged to the branch mainline in revision 6192.
  • Revision ID: martin.packman@canonical.com-20110930162917-zilsfmiuxzsky4so
https://launchpad.net/bugs/856731
Return early to avoid malloc(0) in create_delta_index_from_delta

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/xml_serializer.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
22
22
# importing this module is fairly slow because it has to load several
23
23
# ElementTree bits
24
24
 
 
25
import re
 
26
 
25
27
from bzrlib.serializer import Serializer
26
 
from bzrlib.trace import mutter, warning
 
28
from bzrlib.trace import mutter
27
29
 
28
30
try:
29
31
    try:
31
33
        from xml.etree.cElementTree import (ElementTree, SubElement, Element,
32
34
            XMLTreeBuilder, fromstring, tostring)
33
35
        import xml.etree as elementtree
 
36
        # Also import ElementTree module so monkey-patching below always works
 
37
        import xml.etree.ElementTree
34
38
    except ImportError:
35
39
        from cElementTree import (ElementTree, SubElement, Element,
36
40
                                  XMLTreeBuilder, fromstring, tostring)
55
59
    squashes_xml_invalid_characters = True
56
60
 
57
61
    def read_inventory_from_string(self, xml_string, revision_id=None,
58
 
                                   entry_cache=None):
 
62
                                   entry_cache=None, return_from_cache=False):
59
63
        """Read xml_string into an inventory object.
60
64
 
61
65
        :param xml_string: The xml to read.
69
73
        :param entry_cache: An optional cache of InventoryEntry objects. If
70
74
            supplied we will look up entries via (file_id, revision_id) which
71
75
            should map to a valid InventoryEntry (File/Directory/etc) object.
 
76
        :param return_from_cache: Return entries directly from the cache,
 
77
            rather than copying them first. This is only safe if the caller
 
78
            promises not to mutate the returned inventory entries, but it can
 
79
            make some operations significantly faster.
72
80
        """
73
81
        try:
74
82
            return self._unpack_inventory(fromstring(xml_string), revision_id,
75
 
                                          entry_cache=entry_cache)
 
83
                                          entry_cache=entry_cache,
 
84
                                          return_from_cache=return_from_cache)
76
85
        except ParseError, e:
77
86
            raise errors.UnexpectedInventoryFormat(e)
78
87
 
79
88
    def read_inventory(self, f, revision_id=None):
80
89
        try:
81
 
            return self._unpack_inventory(self._read_element(f),
82
 
                revision_id=None)
 
90
            try:
 
91
                return self._unpack_inventory(self._read_element(f),
 
92
                    revision_id=None)
 
93
            finally:
 
94
                f.close()
83
95
        except ParseError, e:
84
96
            raise errors.UnexpectedInventoryFormat(e)
85
97
 
103
115
        return ElementTree().parse(f)
104
116
 
105
117
 
106
 
# performance tuning for elementree's serialiser. This should be
107
 
# sent upstream - RBC 20060523.
108
 
# the functions here are patched into elementtree at runtime.
109
 
import re
110
 
escape_re = re.compile("[&'\"<>]")
111
 
escape_map = {
112
 
    "&":'&amp;',
113
 
    "'":"&apos;", # FIXME: overkill
114
 
    "\"":"&quot;",
115
 
    "<":"&lt;",
116
 
    ">":"&gt;",
117
 
    }
118
 
def _escape_replace(match, map=escape_map):
119
 
    return map[match.group()]
120
 
 
121
 
def _escape_attrib(text, encoding=None, replace=None):
122
 
    # escape attribute value
123
 
    try:
124
 
        if encoding:
125
 
            try:
126
 
                text = elementtree.ElementTree._encode(text, encoding)
127
 
            except UnicodeError:
128
 
                return elementtree.ElementTree._encode_entity(text)
129
 
        if replace is None:
130
 
            return escape_re.sub(_escape_replace, text)
131
 
        else:
132
 
            text = replace(text, "&", "&amp;")
133
 
            text = replace(text, "'", "&apos;") # FIXME: overkill
134
 
            text = replace(text, "\"", "&quot;")
135
 
            text = replace(text, "<", "&lt;")
136
 
            text = replace(text, ">", "&gt;")
137
 
            return text
138
 
    except (TypeError, AttributeError):
139
 
        elementtree.ElementTree._raise_serialization_error(text)
140
 
 
141
 
elementtree.ElementTree._escape_attrib = _escape_attrib
142
 
 
143
 
escape_cdata_re = re.compile("[&<>]")
144
 
escape_cdata_map = {
145
 
    "&":'&amp;',
146
 
    "<":"&lt;",
147
 
    ">":"&gt;",
148
 
    }
149
 
def _escape_cdata_replace(match, map=escape_cdata_map):
150
 
    return map[match.group()]
151
 
 
152
 
def _escape_cdata(text, encoding=None, replace=None):
153
 
    # escape character data
154
 
    try:
155
 
        if encoding:
156
 
            try:
157
 
                text = elementtree.ElementTree._encode(text, encoding)
158
 
            except UnicodeError:
159
 
                return elementtree.ElementTree._encode_entity(text)
160
 
        if replace is None:
161
 
            return escape_cdata_re.sub(_escape_cdata_replace, text)
162
 
        else:
163
 
            text = replace(text, "&", "&amp;")
164
 
            text = replace(text, "<", "&lt;")
165
 
            text = replace(text, ">", "&gt;")
166
 
            return text
167
 
    except (TypeError, AttributeError):
168
 
        elementtree.ElementTree._raise_serialization_error(text)
169
 
 
170
 
elementtree.ElementTree._escape_cdata = _escape_cdata
171
 
 
172
 
 
173
118
def escape_invalid_chars(message):
174
119
    """Escape the XML-invalid characters in a commit message.
175
120