274 lines
8.6 KiB
Python
274 lines
8.6 KiB
Python
"""
|
|
Implementation of JSONDecoder
|
|
"""
|
|
import re
|
|
|
|
from django.utils.simplejson.scanner import Scanner, pattern
|
|
|
|
FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL
|
|
|
|
def _floatconstants():
|
|
import struct
|
|
import sys
|
|
_BYTES = '7FF80000000000007FF0000000000000'.decode('hex')
|
|
if sys.byteorder != 'big':
|
|
_BYTES = _BYTES[:8][::-1] + _BYTES[8:][::-1]
|
|
nan, inf = struct.unpack('dd', _BYTES)
|
|
return nan, inf, -inf
|
|
|
|
NaN, PosInf, NegInf = _floatconstants()
|
|
|
|
def linecol(doc, pos):
|
|
lineno = doc.count('\n', 0, pos) + 1
|
|
if lineno == 1:
|
|
colno = pos
|
|
else:
|
|
colno = pos - doc.rindex('\n', 0, pos)
|
|
return lineno, colno
|
|
|
|
def errmsg(msg, doc, pos, end=None):
|
|
lineno, colno = linecol(doc, pos)
|
|
if end is None:
|
|
return '%s: line %d column %d (char %d)' % (msg, lineno, colno, pos)
|
|
endlineno, endcolno = linecol(doc, end)
|
|
return '%s: line %d column %d - line %d column %d (char %d - %d)' % (
|
|
msg, lineno, colno, endlineno, endcolno, pos, end)
|
|
|
|
_CONSTANTS = {
|
|
'-Infinity': NegInf,
|
|
'Infinity': PosInf,
|
|
'NaN': NaN,
|
|
'true': True,
|
|
'false': False,
|
|
'null': None,
|
|
}
|
|
|
|
def JSONConstant(match, context, c=_CONSTANTS):
|
|
return c[match.group(0)], None
|
|
pattern('(-?Infinity|NaN|true|false|null)')(JSONConstant)
|
|
|
|
def JSONNumber(match, context):
|
|
match = JSONNumber.regex.match(match.string, *match.span())
|
|
integer, frac, exp = match.groups()
|
|
if frac or exp:
|
|
res = float(integer + (frac or '') + (exp or ''))
|
|
else:
|
|
res = int(integer)
|
|
return res, None
|
|
pattern(r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?')(JSONNumber)
|
|
|
|
STRINGCHUNK = re.compile(r'(.*?)(["\\])', FLAGS)
|
|
BACKSLASH = {
|
|
'"': u'"', '\\': u'\\', '/': u'/',
|
|
'b': u'\b', 'f': u'\f', 'n': u'\n', 'r': u'\r', 't': u'\t',
|
|
}
|
|
|
|
DEFAULT_ENCODING = "utf-8"
|
|
|
|
def scanstring(s, end, encoding=None, _b=BACKSLASH, _m=STRINGCHUNK.match):
|
|
if encoding is None:
|
|
encoding = DEFAULT_ENCODING
|
|
chunks = []
|
|
_append = chunks.append
|
|
begin = end - 1
|
|
while 1:
|
|
chunk = _m(s, end)
|
|
if chunk is None:
|
|
raise ValueError(
|
|
errmsg("Unterminated string starting at", s, begin))
|
|
end = chunk.end()
|
|
content, terminator = chunk.groups()
|
|
if content:
|
|
if not isinstance(content, unicode):
|
|
content = unicode(content, encoding)
|
|
_append(content)
|
|
if terminator == '"':
|
|
break
|
|
try:
|
|
esc = s[end]
|
|
except IndexError:
|
|
raise ValueError(
|
|
errmsg("Unterminated string starting at", s, begin))
|
|
if esc != 'u':
|
|
try:
|
|
m = _b[esc]
|
|
except KeyError:
|
|
raise ValueError(
|
|
errmsg("Invalid \\escape: %r" % (esc,), s, end))
|
|
end += 1
|
|
else:
|
|
esc = s[end + 1:end + 5]
|
|
try:
|
|
m = unichr(int(esc, 16))
|
|
if len(esc) != 4 or not esc.isalnum():
|
|
raise ValueError
|
|
except ValueError:
|
|
raise ValueError(errmsg("Invalid \\uXXXX escape", s, end))
|
|
end += 5
|
|
_append(m)
|
|
return u''.join(chunks), end
|
|
|
|
def JSONString(match, context):
|
|
encoding = getattr(context, 'encoding', None)
|
|
return scanstring(match.string, match.end(), encoding)
|
|
pattern(r'"')(JSONString)
|
|
|
|
WHITESPACE = re.compile(r'\s*', FLAGS)
|
|
|
|
def JSONObject(match, context, _w=WHITESPACE.match):
|
|
pairs = {}
|
|
s = match.string
|
|
end = _w(s, match.end()).end()
|
|
nextchar = s[end:end + 1]
|
|
# trivial empty object
|
|
if nextchar == '}':
|
|
return pairs, end + 1
|
|
if nextchar != '"':
|
|
raise ValueError(errmsg("Expecting property name", s, end))
|
|
end += 1
|
|
encoding = getattr(context, 'encoding', None)
|
|
iterscan = JSONScanner.iterscan
|
|
while True:
|
|
key, end = scanstring(s, end, encoding)
|
|
end = _w(s, end).end()
|
|
if s[end:end + 1] != ':':
|
|
raise ValueError(errmsg("Expecting : delimiter", s, end))
|
|
end = _w(s, end + 1).end()
|
|
try:
|
|
value, end = iterscan(s, idx=end, context=context).next()
|
|
except StopIteration:
|
|
raise ValueError(errmsg("Expecting object", s, end))
|
|
pairs[key] = value
|
|
end = _w(s, end).end()
|
|
nextchar = s[end:end + 1]
|
|
end += 1
|
|
if nextchar == '}':
|
|
break
|
|
if nextchar != ',':
|
|
raise ValueError(errmsg("Expecting , delimiter", s, end - 1))
|
|
end = _w(s, end).end()
|
|
nextchar = s[end:end + 1]
|
|
end += 1
|
|
if nextchar != '"':
|
|
raise ValueError(errmsg("Expecting property name", s, end - 1))
|
|
object_hook = getattr(context, 'object_hook', None)
|
|
if object_hook is not None:
|
|
pairs = object_hook(pairs)
|
|
return pairs, end
|
|
pattern(r'{')(JSONObject)
|
|
|
|
def JSONArray(match, context, _w=WHITESPACE.match):
|
|
values = []
|
|
s = match.string
|
|
end = _w(s, match.end()).end()
|
|
# look-ahead for trivial empty array
|
|
nextchar = s[end:end + 1]
|
|
if nextchar == ']':
|
|
return values, end + 1
|
|
iterscan = JSONScanner.iterscan
|
|
while True:
|
|
try:
|
|
value, end = iterscan(s, idx=end, context=context).next()
|
|
except StopIteration:
|
|
raise ValueError(errmsg("Expecting object", s, end))
|
|
values.append(value)
|
|
end = _w(s, end).end()
|
|
nextchar = s[end:end + 1]
|
|
end += 1
|
|
if nextchar == ']':
|
|
break
|
|
if nextchar != ',':
|
|
raise ValueError(errmsg("Expecting , delimiter", s, end))
|
|
end = _w(s, end).end()
|
|
return values, end
|
|
pattern(r'\[')(JSONArray)
|
|
|
|
ANYTHING = [
|
|
JSONObject,
|
|
JSONArray,
|
|
JSONString,
|
|
JSONConstant,
|
|
JSONNumber,
|
|
]
|
|
|
|
JSONScanner = Scanner(ANYTHING)
|
|
|
|
class JSONDecoder(object):
|
|
"""
|
|
Simple JSON <http://json.org> decoder
|
|
|
|
Performs the following translations in decoding:
|
|
|
|
+---------------+-------------------+
|
|
| JSON | Python |
|
|
+===============+===================+
|
|
| object | dict |
|
|
+---------------+-------------------+
|
|
| array | list |
|
|
+---------------+-------------------+
|
|
| string | unicode |
|
|
+---------------+-------------------+
|
|
| number (int) | int, long |
|
|
+---------------+-------------------+
|
|
| number (real) | float |
|
|
+---------------+-------------------+
|
|
| true | True |
|
|
+---------------+-------------------+
|
|
| false | False |
|
|
+---------------+-------------------+
|
|
| null | None |
|
|
+---------------+-------------------+
|
|
|
|
It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
|
|
their corresponding ``float`` values, which is outside the JSON spec.
|
|
"""
|
|
|
|
_scanner = Scanner(ANYTHING)
|
|
__all__ = ['__init__', 'decode', 'raw_decode']
|
|
|
|
def __init__(self, encoding=None, object_hook=None):
|
|
"""
|
|
``encoding`` determines the encoding used to interpret any ``str``
|
|
objects decoded by this instance (utf-8 by default). It has no
|
|
effect when decoding ``unicode`` objects.
|
|
|
|
Note that currently only encodings that are a superset of ASCII work,
|
|
strings of other encodings should be passed in as ``unicode``.
|
|
|
|
``object_hook``, if specified, will be called with the result
|
|
of every JSON object decoded and its return value will be used in
|
|
place of the given ``dict``. This can be used to provide custom
|
|
deserializations (e.g. to support JSON-RPC class hinting).
|
|
"""
|
|
self.encoding = encoding
|
|
self.object_hook = object_hook
|
|
|
|
def decode(self, s, _w=WHITESPACE.match):
|
|
"""
|
|
Return the Python representation of ``s`` (a ``str`` or ``unicode``
|
|
instance containing a JSON document)
|
|
"""
|
|
obj, end = self.raw_decode(s, idx=_w(s, 0).end())
|
|
end = _w(s, end).end()
|
|
if end != len(s):
|
|
raise ValueError(errmsg("Extra data", s, end, len(s)))
|
|
return obj
|
|
|
|
def raw_decode(self, s, **kw):
|
|
"""
|
|
Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning
|
|
with a JSON document) and return a 2-tuple of the Python
|
|
representation and the index in ``s`` where the document ended.
|
|
|
|
This can be used to decode a JSON document from a string that may
|
|
have extraneous data at the end.
|
|
"""
|
|
kw.setdefault('context', self)
|
|
try:
|
|
obj, end = self._scanner.iterscan(s, **kw).next()
|
|
except StopIteration:
|
|
raise ValueError("No JSON object could be decoded")
|
|
return obj, end
|
|
|
|
__all__ = ['JSONDecoder']
|