simplejson 4.1.1__tar.gz → 4.2.0__tar.gz

{simplejson-4.1.1 → simplejson-4.2.0}/CHANGES.txt

@@ -1,3 +1,38 @@
+Version 4.2.0 released 2026-10-02
+
+* Start building wheels for Python 3.15 and drop Python 3.8 support
+  via upgrade to cibuildwheel v4.2.0
+  https://github.com/simplejson/simplejson/pull/385
+* Build and test riscv64 Linux wheels on native RISE runners
+  https://github.com/simplejson/simplejson/pull/389
+* The C scanner now reports the same error message as the pure Python
+  decoder for an invalid first key in an object
+  https://github.com/simplejson/simplejson/pull/388
+* ``int_as_string_bitcount`` now supports thresholds of 64 bits and above
+  (including 128-bit integers) in both the C and pure Python encoders;
+  the C encoder previously rejected them
+  https://github.com/simplejson/simplejson/pull/387
+* Circular references introduced through ``for_json()`` or ``_asdict()``
+  now raise ``ValueError("Circular reference detected")`` instead of
+  recursing without bound
+  https://github.com/simplejson/simplejson/pull/390
+* CI now tests Python 3.15 (including free-threaded 3.15t), PyPy 3.12,
+  CPython 3.14.8 debug builds, and uses current GitHub Actions and
+  cibuildwheel v4.2.1
+  https://github.com/simplejson/simplejson/pull/386
+
+Version 4.1.2 released 2026-08-26
+
+* Fix control character error position when content precedes the control char
+  https://github.com/simplejson/simplejson/pull/379
+* Report the offending char, not the backslash, for invalid \X escapes
+  https://github.com/simplejson/simplejson/pull/380
+* Handle non-finite Decimals like floats in the encoder
+  https://github.com/simplejson/simplejson/pull/381
+* Parse failures due to trailing commas are now reported consistently
+  across implementations
+  https://github.com/simplejson/simplejson/pull/382
+
 Version 4.1.1 released 2026-04-24
 
 * The ``build_wheels_py27`` CI job now also builds Python 2.7 wheels

{simplejson-4.1.1/simplejson.egg-info → simplejson-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplejson
-Version: 4.1.1
+Version: 4.2.0
 Summary: Simple, fast, extensible JSON encoder/decoder for Python
 Home-page: https://github.com/simplejson/simplejson
 Author: Bob Ippolito
@@ -14,18 +14,18 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: GraalPy
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*, !=3.8.*
 License-File: LICENSE.txt
 Dynamic: author
 Dynamic: author-email
@@ -42,7 +42,7 @@ simplejson
 ----------
 
 simplejson is a simple, fast, complete, correct and extensible
-JSON <http://json.org> encoder and decoder for Python 3.8+
+JSON <http://json.org> encoder and decoder for Python 3.9+
 with legacy support for Python 2.7.  It is pure Python code
 with no dependencies, but includes an optional C extension
 for a serious speed boost.
@@ -53,7 +53,7 @@ https://simplejson.readthedocs.io/
 simplejson is the externally maintained development version of the
 json library included with Python (since 2.6). This version is tested
 with Python 3.14 (including free-threaded builds) and maintains
-backwards compatibility with Python 3.8+. A legacy Python 2.7 wheel
+backwards compatibility with Python 3.9+. A legacy Python 2.7 wheel
 is also published.
 
 The encoder can be specialized to provide serialization in any kind of

{simplejson-4.1.1 → simplejson-4.2.0}/README.rst

@@ -2,7 +2,7 @@ simplejson
 ----------
 
 simplejson is a simple, fast, complete, correct and extensible
-JSON <http://json.org> encoder and decoder for Python 3.8+
+JSON <http://json.org> encoder and decoder for Python 3.9+
 with legacy support for Python 2.7.  It is pure Python code
 with no dependencies, but includes an optional C extension
 for a serious speed boost.
@@ -13,7 +13,7 @@ https://simplejson.readthedocs.io/
 simplejson is the externally maintained development version of the
 json library included with Python (since 2.6). This version is tested
 with Python 3.14 (including free-threaded builds) and maintains
-backwards compatibility with Python 3.8+. A legacy Python 2.7 wheel
+backwards compatibility with Python 3.9+. A legacy Python 2.7 wheel
 is also published.
 
 The encoder can be specialized to provide serialization in any kind of

{simplejson-4.1.1 → simplejson-4.2.0}/conf.py

@@ -36,15 +36,15 @@ master_doc = 'index'
 
 # General substitutions.
 project = 'simplejson'
-copyright = '2025, Bob Ippolito'
+copyright = '2026, Bob Ippolito'
 
 # The default replacements for |version| and |release|, also used in various
 # other places throughout the built documents.
 #
 # The short X.Y version.
-version = '4.1'
+version = '4.2'
 # The full version, including alpha/beta/rc tags.
-release = '4.1.1'
+release = '4.2.0'
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:

{simplejson-4.1.1 → simplejson-4.2.0}/index.rst

@@ -21,7 +21,7 @@ for a serious speed boost.
 :mod:`simplejson` exposes an API familiar to users of the standard library
 :mod:`marshal` and :mod:`pickle` modules. It is the externally maintained
 version of the :mod:`json` library, but maintains
-compatibility with Python 3.8 through 3.14 (including free-threaded
+compatibility with Python 3.9 through 3.15 (including free-threaded
 builds) as well as legacy Python 2.7.
 
 Development of simplejson happens on Github:
@@ -310,6 +310,10 @@ Basic Usage
     :class:`int` ``2**n`` and higher or lower than ``-2**n`` will be encoded as strings. This is to
     avoid the rounding that happens in Javascript otherwise. Note that this
     option loses type information, so use with extreme caution.
+    Thresholds of 64 bits and above are supported by both encoders, including
+    128-bit integers. Very large thresholds do not allocate a power-of-two
+    boundary.
+
     See also *bigint_as_string* (which is equivalent to `int_as_string_bitcount=53`).
 
     .. note::

{simplejson-4.1.1 → simplejson-4.2.0}/setup.py

@@ -12,13 +12,13 @@ from distutils.errors import CCompilerError, DistutilsExecError, \
 
 IS_PYPY = hasattr(sys, 'pypy_translation_info')
 IS_GRAALPY = getattr(getattr(sys, "implementation", None), "name", None) == "graalpy"
-VERSION = '4.1.1'
+VERSION = '4.2.0'
 DESCRIPTION = "Simple, fast, extensible JSON encoder/decoder for Python"
 
 with open('README.rst', 'r') as f:
     LONG_DESCRIPTION = f.read()
 
-PYTHON_REQUIRES = '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*'
+PYTHON_REQUIRES = '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*, !=3.8.*'
 
 CLASSIFIERS = [
     'Development Status :: 5 - Production/Stable',
@@ -28,13 +28,13 @@ CLASSIFIERS = [
     'Programming Language :: Python :: 2',
     'Programming Language :: Python :: 2.7',
     'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3.8',
     'Programming Language :: Python :: 3.9',
     'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
     'Programming Language :: Python :: 3.13',
     'Programming Language :: Python :: 3.14',
+    'Programming Language :: Python :: 3.15',
     'Programming Language :: Python :: Implementation :: CPython',
     'Programming Language :: Python :: Implementation :: GraalPy',
     'Programming Language :: Python :: Implementation :: PyPy',

{simplejson-4.1.1 → simplejson-4.2.0}/simplejson/__init__.py

@@ -5,7 +5,7 @@ interchange format.
 :mod:`simplejson` exposes an API familiar to users of the standard library
 :mod:`marshal` and :mod:`pickle` modules. It is the externally maintained
 version of the :mod:`json` library contained in Python 2.6+, supporting
-Python 2.7 and Python 3.8+, and has significant performance advantages,
+Python 2.7 and Python 3.9+, and has significant performance advantages,
 even without using the optional C extension for speedups.
 
 Encoding basic Python object hierarchies::
@@ -118,7 +118,7 @@ Serializing multiple objects to JSON lines (newline-delimited JSON)::
 
 """
 from __future__ import absolute_import
-__version__ = '4.1.1'
+__version__ = '4.2.0'
 __all__ = [
     'dump', 'dumps', 'load', 'loads',
     'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',

{simplejson-4.1.1 → simplejson-4.2.0}/simplejson/_speedups.c

@@ -301,6 +301,7 @@ typedef struct _PyEncoderObject {
     int iterable_as_array;
     PyObject *max_long_size;
     PyObject *min_long_size;
+    PyObject *large_int_bitcount;
     PyObject *item_sort_key;
     PyObject *item_sort_kw;
     int for_json;
@@ -327,6 +328,7 @@ typedef struct _PyEncoderObject {
     X(item_sort_key)                  \
     X(max_long_size)                  \
     X(min_long_size)                  \
+    X(large_int_bitcount)             \
     X(Decimal)
 
 static PyMemberDef encoder_members[] = {
@@ -429,6 +431,8 @@ static PyObject *
 encoder_long_to_str(PyObject *obj);
 static PyObject *
 encoder_encode_float(PyEncoderObject *s, PyObject *obj);
+static PyObject *
+encoder_encode_decimal(PyEncoderObject *s, PyObject *obj);
 static int
 encoder_accumulate_newline_indent(PyEncoderObject *s, _speedups_state *state,
                                   JSON_Accu *rval, Py_ssize_t indent_level);
@@ -706,22 +710,46 @@ maybe_quote_bigint(PyEncoderObject* s, PyObject *encoded, PyObject *obj)
     int ge, le;
     PyObject *quoted;
 
-    /* int_as_string_bitcount is not set: fast path, return as-is. */
-    if (s->max_long_size == Py_None || s->min_long_size == Py_None)
-        return encoded;
-
-    ge = PyObject_RichCompareBool(obj, s->max_long_size, Py_GE);
-    if (ge < 0) {
-        Py_DECREF(encoded);
-        return NULL;
+    if (s->large_int_bitcount != NULL) {
+        size_t nbits;
+        PyObject *bits;
+        nbits = _PyLong_NumBits(obj);
+        if (nbits == (size_t)-1 && PyErr_Occurred()) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+        bits = PyLong_FromSize_t(nbits);
+        if (bits == NULL) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+        ge = PyObject_RichCompareBool(bits, s->large_int_bitcount, Py_GT);
+        Py_DECREF(bits);
+        if (ge < 0) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+        if (!ge)
+            return encoded;
     }
-    le = PyObject_RichCompareBool(obj, s->min_long_size, Py_LE);
-    if (le < 0) {
-        Py_DECREF(encoded);
-        return NULL;
+    else {
+        /* int_as_string_bitcount is not set: fast path, return as-is. */
+        if (s->max_long_size == Py_None || s->min_long_size == Py_None)
+            return encoded;
+
+        ge = PyObject_RichCompareBool(obj, s->max_long_size, Py_GE);
+        if (ge < 0) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+        le = PyObject_RichCompareBool(obj, s->min_long_size, Py_LE);
+        if (le < 0) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+        if (!(ge || le))
+            return encoded;
     }
-    if (!(ge || le))
-        return encoded;
 
 #if PY_MAJOR_VERSION >= 3
     quoted = PyUnicode_FromFormat("\"%U\"", encoded);
@@ -1062,7 +1090,7 @@ encoder_stringify_key(PyEncoderObject *s, PyObject *key)
         return encoder_long_to_str(key);
     }
     else if (s->use_decimal && PyObject_TypeCheck(key, (PyTypeObject *)s->Decimal)) {
-        return PyObject_Str(key);
+        return encoder_encode_decimal(s, key);
     }
     if (s->skipkeys) {
         Py_INCREF(Py_None);
@@ -1365,7 +1393,7 @@ scanstring_str(_speedups_state *state, PyObject *pystr, Py_ssize_t end,
                 default: c = 0;
             }
             if (c == 0) {
-                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 2);
+                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 1);
                 goto bail;
             }
         }
@@ -1564,7 +1592,7 @@ scanstring_unicode(_speedups_state *state, PyObject *pystr, Py_ssize_t end,
                 default: c = 0;
             }
             if (c == 0) {
-                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 2);
+                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 1);
                 goto bail;
             }
         }
@@ -1755,7 +1783,7 @@ scanstring_unicode(_speedups_state *state, PyObject *pystr, Py_ssize_t end,
                 default: c = 0;
             }
             if (c == 0) {
-                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 2);
+                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 1);
                 goto bail;
             }
         }
@@ -2651,10 +2679,11 @@ encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         goto bail;
     if (PyInt_Check(int_as_string_bitcount) || PyLong_Check(int_as_string_bitcount)) {
         static const unsigned long long_long_bitsize = sizeof(long long) * CHAR_BIT;
-        long int_as_string_bitcount_val = PyLong_AsLong(int_as_string_bitcount);
+        int overflow = 0;
+        long int_as_string_bitcount_val = PyLong_AsLongAndOverflow(int_as_string_bitcount, &overflow);
         if (int_as_string_bitcount_val == -1 && PyErr_Occurred())
             goto bail;
-        if (int_as_string_bitcount_val > 0 && int_as_string_bitcount_val < (long)long_long_bitsize) {
+        if (!overflow && int_as_string_bitcount_val > 0 && int_as_string_bitcount_val < (long)long_long_bitsize) {
             int n = (int)int_as_string_bitcount_val;
             /* Compute 2^n as unsigned (well-defined for n < 64) and
              * -(2^n) as signed without UB. Naive "-1LL << n" is a
@@ -2670,10 +2699,19 @@ encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
                 goto bail;
             }
         }
+        else if (overflow > 0 || int_as_string_bitcount_val > 0) {
+            /* Compare magnitudes without allocating a 2**n boundary. */
+            s->large_int_bitcount = PyNumber_Long(int_as_string_bitcount);
+            if (s->large_int_bitcount == NULL)
+                goto bail;
+            Py_INCREF(Py_None);
+            s->max_long_size = Py_None;
+            Py_INCREF(Py_None);
+            s->min_long_size = Py_None;
+        }
         else {
-            PyErr_Format(PyExc_TypeError,
-                         "int_as_string_bitcount (%ld) must be greater than 0 and less than the number of bits of a `long long` type (%lu bits)",
-                         int_as_string_bitcount_val, long_long_bitsize);
+            PyErr_SetString(PyExc_TypeError,
+                            "int_as_string_bitcount must be a positive integer");
             goto bail;
         }
     }
@@ -2785,33 +2823,38 @@ _encoded_const(_speedups_state *state, PyObject *obj)
     }
 }
 
+static PyObject *
+encoder_encode_nonfinite(PyEncoderObject *s, int sign)
+{
+    _speedups_state *state = get_speedups_state(s->module_ref);
+
+    if (!s->allow_or_ignore_nan) {
+        PyErr_SetString(PyExc_ValueError, "Out of range float values are not JSON compliant");
+        return NULL;
+    }
+    if (s->allow_or_ignore_nan & JSON_IGNORE_NAN) {
+        return _encoded_const(state, Py_None);
+    }
+    /* JSON_ALLOW_NAN is set */
+    if (sign > 0) {
+        Py_INCREF(state->JSON_Infinity);
+        return state->JSON_Infinity;
+    }
+    if (sign < 0) {
+        Py_INCREF(state->JSON_NegInfinity);
+        return state->JSON_NegInfinity;
+    }
+    Py_INCREF(state->JSON_NaN);
+    return state->JSON_NaN;
+}
+
 static PyObject *
 encoder_encode_float(PyEncoderObject *s, PyObject *obj)
 {
     /* Return the JSON representation of a PyFloat */
-    _speedups_state *state = get_speedups_state(s->module_ref);
     double i = PyFloat_AS_DOUBLE(obj);
     if (!Py_IS_FINITE(i)) {
-        if (!s->allow_or_ignore_nan) {
-            PyErr_SetString(PyExc_ValueError, "Out of range float values are not JSON compliant");
-            return NULL;
-        }
-        if (s->allow_or_ignore_nan & JSON_IGNORE_NAN) {
-            return _encoded_const(state, Py_None);
-        }
-        /* JSON_ALLOW_NAN is set */
-        else if (i > 0) {
-            Py_INCREF(state->JSON_Infinity);
-            return state->JSON_Infinity;
-        }
-        else if (i < 0) {
-            Py_INCREF(state->JSON_NegInfinity);
-            return state->JSON_NegInfinity;
-        }
-        else {
-            Py_INCREF(state->JSON_NaN);
-            return state->JSON_NaN;
-        }
+        return encoder_encode_nonfinite(s, i > 0 ? 1 : (i < 0 ? -1 : 0));
     }
     /* Use a better float format here? */
     if (PyFloat_CheckExact(obj)) {
@@ -2830,6 +2873,61 @@ encoder_encode_float(PyEncoderObject *s, PyObject *obj)
     }
 }
 
+static PyObject *
+encoder_encode_decimal(PyEncoderObject *s, PyObject *obj)
+{
+    /* Return the JSON representation of a Decimal. Finite Decimals are
+       stringified as-is (preserving precision and trailing zeros); non-finite
+       Decimals (NaN, sNaN, Infinity) are routed through the same
+       allow_nan/ignore_nan handling as floats so they never emit invalid
+       JSON. See https://github.com/simplejson/simplejson/issues/149
+
+       str(Decimal) carries a leading '-' sign at most (never '+'); a finite
+       value's first significant character is always a digit while a non-finite
+       value's is a letter ('N'/'s' for [s]NaN, 'I' for Infinity). So a single
+       str() plus a one/two character check distinguishes the two. */
+    PyObject *str = PyObject_Str(obj);
+    Py_ssize_t len;
+    int negative;
+    JSON_UNICHR c;
+#if PY_MAJOR_VERSION >= 3
+    int kind;
+    void *data;
+#else
+    const char *data;
+#endif
+    if (str == NULL)
+        return NULL;
+#if PY_MAJOR_VERSION >= 3
+    if (PyUnicode_READY(str)) {
+        Py_DECREF(str);
+        return NULL;
+    }
+    len = PyUnicode_GET_LENGTH(str);
+    kind = PyUnicode_KIND(str);
+    data = PyUnicode_DATA(str);
+    negative = (len > 0 && PyUnicode_READ(kind, data, 0) == '-');
+    c = (JSON_UNICHR)0;
+    if (len > (negative ? 1 : 0))
+        c = PyUnicode_READ(kind, data, negative ? 1 : 0);
+#else
+    len = PyString_GET_SIZE(str);
+    data = PyString_AS_STRING(str);
+    negative = (len > 0 && data[0] == '-');
+    c = (JSON_UNICHR)0;
+    if (len > (negative ? 1 : 0))
+        c = (unsigned char)data[negative ? 1 : 0];
+#endif
+    if (IS_DIGIT(c)) {
+        /* First significant character is a digit: finite Decimal, emit as-is. */
+        return str;
+    }
+    /* Non-finite Decimal; use the same allow_nan/ignore_nan path as floats
+       without creating a temporary float. */
+    Py_DECREF(str);
+    return encoder_encode_nonfinite(s, c == 'I' ? (negative ? -1 : 1) : 0);
+}
+
 static PyObject *
 encoder_encode_string(PyEncoderObject *s, PyObject *obj)
 {
@@ -2917,7 +3015,8 @@ encoder_markers_pop(PyEncoderObject *s, PyObject *ident)
 
 /* Helper for the for_json / _asdict paths in encoder_listencode_obj.
  * Steals the reference to `newobj` (returned by _call_json_method),
- * handles recursion-depth tracking, and dispatches to the right
+ * tracks the original object's circular-reference marker and recursion
+ * depth, and dispatches to the right
  * sub-encoder:
  *   - if as_dict is 0, encodes newobj as a generic JSON value via
  *     encoder_listencode_obj (for_json contract: return any JSON-
@@ -2928,14 +3027,20 @@ encoder_markers_pop(PyEncoderObject *s, PyObject *ident)
  * Cleans up on every exit path. */
 static int
 encoder_steal_encode(PyEncoderObject *s, JSON_Accu *rval,
-                     PyObject *newobj, Py_ssize_t indent_level,
+                     PyObject *obj, PyObject *newobj, Py_ssize_t indent_level,
                      int as_dict)
 {
     int rv;
+    PyObject *ident = NULL;
     if (newobj == NULL)
         return -1;
+    if (encoder_markers_push(s, obj, &ident)) {
+        Py_DECREF(newobj);
+        return -1;
+    }
     if (Py_EnterRecursiveCall(" while encoding a JSON object")) {
         Py_DECREF(newobj);
+        Py_XDECREF(ident);
         return -1;
     }
     if (as_dict) {
@@ -2952,6 +3057,12 @@ encoder_steal_encode(PyEncoderObject *s, JSON_Accu *rval,
     }
     Py_DECREF(newobj);
     Py_LeaveRecursiveCall();
+    if (rv == 0) {
+        if (encoder_markers_pop(s, ident) < 0)
+            rv = -1;
+    } else {
+        Py_XDECREF(ident);
+    }
     return rv;
 }
 
@@ -3059,12 +3170,39 @@ encoder_listencode_obj(PyEncoderObject *s, JSON_Accu *rval, PyObject *obj, Py_ss
             rv = _steal_accumulate(state, rval, cstr);
     }
     else if (PyInt_Check(obj) || PyLong_Check(obj)) {
-        PyObject *encoded = encoder_long_to_str(obj);
+        PyObject *integer, *encoded;
+        /* Large thresholds inspect the same normalized value we serialize. */
+        if (s->large_int_bitcount != NULL) {
+#if PY_MAJOR_VERSION < 3
+            /* Match int(value) in the Python encoder before widening for
+             * _PyLong_NumBits: long(value) would invoke __long__ instead. */
+            PyObject *normalized = PyNumber_Int(obj);
+            if (normalized == NULL)
+                return -1;
+            /* PyNumber_Int may retain a long subclass. Copy its payload
+             * instead of invoking a second conversion hook. */
+            if (PyInt_Check(normalized))
+                integer = PyLong_FromLong(PyInt_AS_LONG(normalized));
+            else
+                integer = PyLong_Type.tp_as_number->nb_long(normalized);
+            Py_DECREF(normalized);
+#else
+            integer = PyNumber_Long(obj);
+#endif
+        }
+        else {
+            integer = obj;
+            Py_INCREF(integer);
+        }
+        if (integer == NULL)
+            return -1;
+        encoded = encoder_long_to_str(integer);
         if (encoded != NULL) {
-            encoded = maybe_quote_bigint(s, encoded, obj);
+            encoded = maybe_quote_bigint(s, encoded, integer);
             if (encoded != NULL)
                 rv = _steal_accumulate(state, rval, encoded);
         }
+        Py_DECREF(integer);
     }
     else if (PyFloat_Check(obj)) {
         PyObject *encoded = encoder_encode_float(s, obj);
@@ -3072,10 +3210,10 @@ encoder_listencode_obj(PyEncoderObject *s, JSON_Accu *rval, PyObject *obj, Py_ss
             rv = _steal_accumulate(state, rval, encoded);
     }
     else if (s->for_json && _call_json_method(obj, state->JSON_attr_for_json, &newobj)) {
-        rv = encoder_steal_encode(s, rval, newobj, indent_level, /*as_dict=*/0);
+        rv = encoder_steal_encode(s, rval, obj, newobj, indent_level, /*as_dict=*/0);
     }
     else if (s->namedtuple_as_object && _call_json_method(obj, state->JSON_attr_asdict, &newobj)) {
-        rv = encoder_steal_encode(s, rval, newobj, indent_level, /*as_dict=*/1);
+        rv = encoder_steal_encode(s, rval, obj, newobj, indent_level, /*as_dict=*/1);
     }
     else if (PyList_Check(obj) || (s->tuple_as_array && PyTuple_Check(obj))) {
         if (Py_EnterRecursiveCall(" while encoding a JSON object"))
@@ -3090,7 +3228,7 @@ encoder_listencode_obj(PyEncoderObject *s, JSON_Accu *rval, PyObject *obj, Py_ss
         Py_LeaveRecursiveCall();
     }
     else if (s->use_decimal && PyObject_TypeCheck(obj, (PyTypeObject *)s->Decimal)) {
-        PyObject *encoded = PyObject_Str(obj);
+        PyObject *encoded = encoder_encode_decimal(s, obj);
         if (encoded != NULL)
             rv = _steal_accumulate(state, rval, encoded);
     }

{simplejson-4.1.1 → simplejson-4.2.0}/simplejson/_speedups_scan.h

@@ -204,12 +204,17 @@ JSON_SCAN_FN(_parse_object)(PyScannerObject *s, PyObject *pystr,
     /* only loop if the object is non-empty */
     if (idx <= end_idx && JSON_SCAN_READ(idx) != '}') {
         int trailing_delimiter = 0;
+        Py_ssize_t comma_idx = 0;
         while (idx <= end_idx) {
             trailing_delimiter = 0;
 
             /* read key */
             if (JSON_SCAN_READ(idx) != '"') {
-                raise_errmsg(state, ERR_OBJECT_PROPERTY, pystr, idx);
+                /* '}' is still legal where the first key would go. */
+                raise_errmsg(state,
+                             did_parse ? ERR_OBJECT_PROPERTY
+                                       : ERR_OBJECT_PROPERTY_FIRST,
+                             pystr, idx);
                 goto bail;
             }
             key = JSON_SCAN_SCANSTRING_CALL(idx + 1, &next_idx);
@@ -271,6 +276,7 @@ JSON_SCAN_FN(_parse_object)(PyScannerObject *s, PyObject *pystr,
                 raise_errmsg(state, ERR_OBJECT_DELIMITER, pystr, idx);
                 goto bail;
             }
+            comma_idx = idx;
             idx++;
 
             /* skip whitespace after , delimiter */
@@ -279,7 +285,7 @@ JSON_SCAN_FN(_parse_object)(PyScannerObject *s, PyObject *pystr,
 
             /* check for trailing comma before } */
             if (idx <= end_idx && JSON_SCAN_READ(idx) == '}') {
-                raise_errmsg(state, ERR_TRAILING_COMMA_OBJECT, pystr, idx);
+                raise_errmsg(state, ERR_TRAILING_COMMA_OBJECT, pystr, comma_idx);
                 goto bail;
             }
         }
@@ -351,6 +357,7 @@ JSON_SCAN_FN(_parse_array)(PyScannerObject *s, PyObject *pystr,
     /* only loop if the array is non-empty */
     if (idx <= end_idx && JSON_SCAN_READ(idx) != ']') {
         int trailing_delimiter = 0;
+        Py_ssize_t comma_idx = 0;
         while (idx <= end_idx) {
             trailing_delimiter = 0;
             /* read any JSON term and de-tuplefy the (rval, idx) */
@@ -377,6 +384,7 @@ JSON_SCAN_FN(_parse_array)(PyScannerObject *s, PyObject *pystr,
                 raise_errmsg(state, ERR_ARRAY_DELIMITER, pystr, idx);
                 goto bail;
             }
+            comma_idx = idx;
             idx++;
 
             /* skip whitespace after , */
@@ -385,7 +393,7 @@ JSON_SCAN_FN(_parse_array)(PyScannerObject *s, PyObject *pystr,
 
             /* check for trailing comma before ] */
             if (idx <= end_idx && JSON_SCAN_READ(idx) == ']') {
-                raise_errmsg(state, ERR_TRAILING_COMMA_ARRAY, pystr, idx);
+                raise_errmsg(state, ERR_TRAILING_COMMA_ARRAY, pystr, comma_idx);
                 goto bail;
             }
         }