Rename WebKitTools to Tools
[WebKit-https.git] / Tools / Scripts / webkitpy / thirdparty / simplejson / decoder.py
1 """
2 Implementation of JSONDecoder
3 """
4 import re
5
6 from scanner import Scanner, pattern
7
8 FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL
9
10 def _floatconstants():
11     import struct
12     import sys
13     _BYTES = '7FF80000000000007FF0000000000000'.decode('hex')
14     if sys.byteorder != 'big':
15         _BYTES = _BYTES[:8][::-1] + _BYTES[8:][::-1]
16     nan, inf = struct.unpack('dd', _BYTES)
17     return nan, inf, -inf
18
19 NaN, PosInf, NegInf = _floatconstants()
20
21 def linecol(doc, pos):
22     lineno = doc.count('\n', 0, pos) + 1
23     if lineno == 1:
24         colno = pos
25     else:
26         colno = pos - doc.rindex('\n', 0, pos)
27     return lineno, colno
28
29 def errmsg(msg, doc, pos, end=None):
30     lineno, colno = linecol(doc, pos)
31     if end is None:
32         return '%s: line %d column %d (char %d)' % (msg, lineno, colno, pos)
33     endlineno, endcolno = linecol(doc, end)
34     return '%s: line %d column %d - line %d column %d (char %d - %d)' % (
35         msg, lineno, colno, endlineno, endcolno, pos, end)
36
37 _CONSTANTS = {
38     '-Infinity': NegInf,
39     'Infinity': PosInf,
40     'NaN': NaN,
41     'true': True,
42     'false': False,
43     'null': None,
44 }
45
46 def JSONConstant(match, context, c=_CONSTANTS):
47     return c[match.group(0)], None
48 pattern('(-?Infinity|NaN|true|false|null)')(JSONConstant)
49
50 def JSONNumber(match, context):
51     match = JSONNumber.regex.match(match.string, *match.span())
52     integer, frac, exp = match.groups()
53     if frac or exp:
54         res = float(integer + (frac or '') + (exp or ''))
55     else:
56         res = int(integer)
57     return res, None
58 pattern(r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?')(JSONNumber)
59
60 STRINGCHUNK = re.compile(r'(.*?)(["\\])', FLAGS)
61 BACKSLASH = {
62     '"': u'"', '\\': u'\\', '/': u'/',
63     'b': u'\b', 'f': u'\f', 'n': u'\n', 'r': u'\r', 't': u'\t',
64 }
65
66 DEFAULT_ENCODING = "utf-8"
67
68 def scanstring(s, end, encoding=None, _b=BACKSLASH, _m=STRINGCHUNK.match):
69     if encoding is None:
70         encoding = DEFAULT_ENCODING
71     chunks = []
72     _append = chunks.append
73     begin = end - 1
74     while 1:
75         chunk = _m(s, end)
76         if chunk is None:
77             raise ValueError(
78                 errmsg("Unterminated string starting at", s, begin))
79         end = chunk.end()
80         content, terminator = chunk.groups()
81         if content:
82             if not isinstance(content, unicode):
83                 content = unicode(content, encoding)
84             _append(content)
85         if terminator == '"':
86             break
87         try:
88             esc = s[end]
89         except IndexError:
90             raise ValueError(
91                 errmsg("Unterminated string starting at", s, begin))
92         if esc != 'u':
93             try:
94                 m = _b[esc]
95             except KeyError:
96                 raise ValueError(
97                     errmsg("Invalid \\escape: %r" % (esc,), s, end))
98             end += 1
99         else:
100             esc = s[end + 1:end + 5]
101             try:
102                 m = unichr(int(esc, 16))
103                 if len(esc) != 4 or not esc.isalnum():
104                     raise ValueError
105             except ValueError:
106                 raise ValueError(errmsg("Invalid \\uXXXX escape", s, end))
107             end += 5
108         _append(m)
109     return u''.join(chunks), end
110
111 def JSONString(match, context):
112     encoding = getattr(context, 'encoding', None)
113     return scanstring(match.string, match.end(), encoding)
114 pattern(r'"')(JSONString)
115
116 WHITESPACE = re.compile(r'\s*', FLAGS)
117
118 def JSONObject(match, context, _w=WHITESPACE.match):
119     pairs = {}
120     s = match.string
121     end = _w(s, match.end()).end()
122     nextchar = s[end:end + 1]
123     # trivial empty object
124     if nextchar == '}':
125         return pairs, end + 1
126     if nextchar != '"':
127         raise ValueError(errmsg("Expecting property name", s, end))
128     end += 1
129     encoding = getattr(context, 'encoding', None)
130     iterscan = JSONScanner.iterscan
131     while True:
132         key, end = scanstring(s, end, encoding)
133         end = _w(s, end).end()
134         if s[end:end + 1] != ':':
135             raise ValueError(errmsg("Expecting : delimiter", s, end))
136         end = _w(s, end + 1).end()
137         try:
138             value, end = iterscan(s, idx=end, context=context).next()
139         except StopIteration:
140             raise ValueError(errmsg("Expecting object", s, end))
141         pairs[key] = value
142         end = _w(s, end).end()
143         nextchar = s[end:end + 1]
144         end += 1
145         if nextchar == '}':
146             break
147         if nextchar != ',':
148             raise ValueError(errmsg("Expecting , delimiter", s, end - 1))
149         end = _w(s, end).end()
150         nextchar = s[end:end + 1]
151         end += 1
152         if nextchar != '"':
153             raise ValueError(errmsg("Expecting property name", s, end - 1))
154     object_hook = getattr(context, 'object_hook', None)
155     if object_hook is not None:
156         pairs = object_hook(pairs)
157     return pairs, end
158 pattern(r'{')(JSONObject)
159             
160 def JSONArray(match, context, _w=WHITESPACE.match):
161     values = []
162     s = match.string
163     end = _w(s, match.end()).end()
164     # look-ahead for trivial empty array
165     nextchar = s[end:end + 1]
166     if nextchar == ']':
167         return values, end + 1
168     iterscan = JSONScanner.iterscan
169     while True:
170         try:
171             value, end = iterscan(s, idx=end, context=context).next()
172         except StopIteration:
173             raise ValueError(errmsg("Expecting object", s, end))
174         values.append(value)
175         end = _w(s, end).end()
176         nextchar = s[end:end + 1]
177         end += 1
178         if nextchar == ']':
179             break
180         if nextchar != ',':
181             raise ValueError(errmsg("Expecting , delimiter", s, end))
182         end = _w(s, end).end()
183     return values, end
184 pattern(r'\[')(JSONArray)
185  
186 ANYTHING = [
187     JSONObject,
188     JSONArray,
189     JSONString,
190     JSONConstant,
191     JSONNumber,
192 ]
193
194 JSONScanner = Scanner(ANYTHING)
195
196 class JSONDecoder(object):
197     """
198     Simple JSON <http://json.org> decoder
199
200     Performs the following translations in decoding:
201     
202     +---------------+-------------------+
203     | JSON          | Python            |
204     +===============+===================+
205     | object        | dict              |
206     +---------------+-------------------+
207     | array         | list              |
208     +---------------+-------------------+
209     | string        | unicode           |
210     +---------------+-------------------+
211     | number (int)  | int, long         |
212     +---------------+-------------------+
213     | number (real) | float             |
214     +---------------+-------------------+
215     | true          | True              |
216     +---------------+-------------------+
217     | false         | False             |
218     +---------------+-------------------+
219     | null          | None              |
220     +---------------+-------------------+
221
222     It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
223     their corresponding ``float`` values, which is outside the JSON spec.
224     """
225
226     _scanner = Scanner(ANYTHING)
227     __all__ = ['__init__', 'decode', 'raw_decode']
228
229     def __init__(self, encoding=None, object_hook=None):
230         """
231         ``encoding`` determines the encoding used to interpret any ``str``
232         objects decoded by this instance (utf-8 by default).  It has no
233         effect when decoding ``unicode`` objects.
234         
235         Note that currently only encodings that are a superset of ASCII work,
236         strings of other encodings should be passed in as ``unicode``.
237
238         ``object_hook``, if specified, will be called with the result
239         of every JSON object decoded and its return value will be used in
240         place of the given ``dict``.  This can be used to provide custom
241         deserializations (e.g. to support JSON-RPC class hinting).
242         """
243         self.encoding = encoding
244         self.object_hook = object_hook
245
246     def decode(self, s, _w=WHITESPACE.match):
247         """
248         Return the Python representation of ``s`` (a ``str`` or ``unicode``
249         instance containing a JSON document)
250         """
251         obj, end = self.raw_decode(s, idx=_w(s, 0).end())
252         end = _w(s, end).end()
253         if end != len(s):
254             raise ValueError(errmsg("Extra data", s, end, len(s)))
255         return obj
256
257     def raw_decode(self, s, **kw):
258         """
259         Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning
260         with a JSON document) and return a 2-tuple of the Python
261         representation and the index in ``s`` where the document ended.
262
263         This can be used to decode a JSON document from a string that may
264         have extraneous data at the end.
265         """
266         kw.setdefault('context', self)
267         try:
268             obj, end = self._scanner.iterscan(s, **kw).next()
269         except StopIteration:
270             raise ValueError("No JSON object could be decoded")
271         return obj, end
272
273 __all__ = ['JSONDecoder']