Initial
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..635979d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,29 @@
+*.py[cdo]
+
+/env*/
+/build/
+/cython_debug/
+/dist/
+/*.egg-info/
+
+*.c
+*.cpp
+*.so
+*.o
+
+run.cgi
+
+*.swp*
+*.nfs*
+*~
+*.~*
+~*
+*.tmp
+*.old
+*.bak
+*.pid
+
+.*
+!.git*
+
+*.orig
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 0000000..f8a6e42
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,6 @@
+include pyjson5.pyx
+include pyjson5.cpp
+include Makefile
+include requires.txt
+recursive-include src **
+recursive-include docs **
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..c15adb7
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,27 @@
+all: sdist bdist_wheel docs
+
+.PHONY: all sdist bdist_wheel clean docs
+
+FILES := Makefile MANIFEST.in pyjson5.pyx README.rst setup.py \
+ src/native.hpp src/VERSION
+
+pyjson5.cpp: pyjson5.pyx $(wildcard src/*.pyx)
+ python -m cython -o $@ $<
+
+sdist: pyjson5.cpp ${FILES}
+ rm -f -- dist/pyjson5-*.tar.gz
+ python setup.py sdist
+
+bdist_wheel: pyjson5.cpp ${FILES} | sdist
+ rm -f -- dist/pyjson5-*.whl
+ python setup.py bdist_wheel
+
+docs: bdist_wheel $(wildcard docs/* docs/*/*)
+ pip install --force dist/pyjson5-*.whl
+ python -m sphinx -M html docs/ dist/
+
+clean:
+ [ ! -d build/ ] || rm -r -- build/
+ [ ! -d dist/ ] || rm -r -- dist/
+ [ ! -d pyjson5.egg-info/ ] || rm -r -- pyjson5.egg-info/
+ rm -f -- pyjson5.*.so python5.cpp
diff --git a/README.rst b/README.rst
new file mode 100644
index 0000000..6db15cd
--- /dev/null
+++ b/README.rst
@@ -0,0 +1,44 @@
+PyJSON5
+==========
+
+A JSON5 serializer and parser library for Python 3 written in
+`Cython <http://cython.org/>`_.
+
+
+Serializer
+----------
+
+The serializer returns ASCII data that can safely be used in an HTML template.
+Apostrophes, ampersands, greater-than, and less-then signs are encoded as
+unicode escaped sequences. E.g. this snippet is safe for any and all input:
+
+.. code:: html
+
+ "<a onclick='alert(" + encode(data) + ")'>show message</a>"
+
+Unless the input contains infinite or NaN values, the result will be valid
+`JSON <https://tools.ietf.org/html/rfc8259>`_ data.
+
+
+Parser
+------
+
+All valid `JSON5 1.0.0 <https://spec.json5.org/>`_ and
+`JSON <https://tools.ietf.org/html/rfc8259>`_ data can be read,
+unless the nesting level is absurdly high.
+
+Functions
+---------
+
+You can find the full documentation online at https://pyjson5.readthedocs.io/en/latest/.
+Or simply call ``help(pyjson5)``. :-)
+
+The library supplies load(s) and dump(s) functions, so you can use it as a
+drop-in replacement for Python's builtin ``json`` module, but you *should*
+use the functions ``encode_*()`` and ``decode_*()`` instead.
+
+Compatibility
+-------------
+
+At least CPython 3.4 is needed.
+Other interpreters such as Pypy and older CPython versions are not supported and will not be supported.
diff --git a/docs/conf.py b/docs/conf.py
new file mode 100644
index 0000000..a300ad9
--- /dev/null
+++ b/docs/conf.py
@@ -0,0 +1,238 @@
+# -*- coding: utf-8 -*-
+#
+# PyJSON5 documentation build configuration file, created by
+# sphinx-quickstart on Wed May 2 18:15:32 2018.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+sys.path.insert(0, os.path.abspath('..'))
+
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+ 'sphinx.ext.autodoc',
+ 'sphinx.ext.autosummary',
+ 'sphinx.ext.napoleon',
+ 'sphinx.ext.intersphinx',
+ 'sphinx.ext.inheritance_diagram',
+ 'sphinx_autodoc_typehints',
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'PyJSON5'
+copyright = u'2018, René Kijewski'
+author = u'René Kijewski'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = u'0.3.6'
+# The full version, including alpha/beta/rc tags.
+release = u'0.3.6'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+exclude_patterns = []
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages. See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'sphinx_rtd_theme'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further. For a list of options available for each theme, see the
+# documentation.
+
+html_theme_options = {
+ 'navigation_depth': -1,
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+#html_static_path = ['_static']
+
+# Custom sidebar templates, must be a dictionary that maps document names
+# to template names.
+#
+# This is required for the alabaster theme
+# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
+html_sidebars = {
+ '**': [
+ 'localtoc.html',
+ 'searchbox.html',
+ ]
+}
+
+
+# -- Options for HTMLHelp output ------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'PyJSON5doc'
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+ # The paper size ('letterpaper' or 'a4paper').
+ #
+ # 'papersize': 'letterpaper',
+
+ # The font size ('10pt', '11pt' or '12pt').
+ #
+ # 'pointsize': '10pt',
+
+ # Additional stuff for the LaTeX preamble.
+ #
+ # 'preamble': '',
+
+ # Latex figure (float) alignment
+ #
+ # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+# author, documentclass [howto, manual, or own class]).
+latex_documents = [
+ (master_doc, 'PyJSON5.tex', u'PyJSON5 Documentation',
+ u'René Kijewski', 'manual'),
+]
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+ (master_doc, 'pyjson5', u'PyJSON5 Documentation',
+ [author], 1)
+]
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+# dir menu entry, description, category)
+texinfo_documents = [
+ (master_doc, 'PyJSON5', u'PyJSON5 Documentation',
+ author, 'PyJSON5', 'One line description of project.',
+ 'Miscellaneous'),
+]
+
+
+display_toc = True
+autodoc_default_flags = ['members']
+autosummary_generate = True
+
+intersphinx_mapping = {
+ 'python': ('https://docs.python.org/3', None),
+}
+
+inheritance_graph_attrs = {
+ 'size': '"6.0, 8.0"',
+ 'fontsize': 32,
+ 'bgcolor': 'transparent',
+}
+inheritance_node_attrs = {
+ 'color': 'black',
+ 'fillcolor': 'white',
+ 'style': '"filled,solid"',
+}
+inheritance_edge_attrs = {
+ 'penwidth': 1.2,
+ 'arrowsize': 0.8,
+}
+
+
+###################################################################################################
+
+
+from sphinx.ext.autosummary import Autosummary
+from sphinx.ext.autosummary import get_documenter
+from sphinx.util.inspect import safe_getattr
+
+
+class AutoAutoSummary(Autosummary):
+ option_spec = {}
+
+ required_arguments = 1
+
+ @staticmethod
+ def get_members(obj):
+ for name in dir(obj):
+ try:
+ documenter = get_documenter(safe_getattr(obj, name), obj)
+ except AttributeError:
+ continue
+
+ if documenter.objtype in ('function',):
+ yield name
+
+ def run(self):
+ module = str(self.arguments[0])
+ try:
+ m = __import__(module, globals(), locals(), [])
+ self.content = sorted(
+ ('~%s.%s' % (module, member) for member in self.get_members(m)),
+ key=str.lower,
+ )
+ finally:
+ return super().run()
+
+
+def setup(app):
+ app.add_directive('autoautosummary', AutoAutoSummary)
diff --git a/docs/index.rst b/docs/index.rst
new file mode 100644
index 0000000..91472f0
--- /dev/null
+++ b/docs/index.rst
@@ -0,0 +1,21 @@
+.. currentmodule:: pyjson5
+
+.. automodule:: pyjson5
+ :members:
+ :inherited-members:
+
+
+ → :ref:`Glossary / Index <genindex>`
+
+ Function summary
+ ----------------
+
+ .. autoautosummary:: pyjson5
+
+ Class / exception summary
+ -------------------------
+
+ .. inheritance-diagram:: pyjson5
+
+ Full description
+ ----------------
diff --git a/pyjson5.pyx b/pyjson5.pyx
new file mode 100644
index 0000000..60407d5
--- /dev/null
+++ b/pyjson5.pyx
@@ -0,0 +1,30 @@
+# distutils: language = c++
+# cython: embedsignature = True
+
+include 'src/_imports.pyx'
+include 'src/_constants.pyx'
+
+include 'src/_exceptions.pyx'
+include 'src/_exceptions_decoder.pyx'
+include 'src/_exceptions_encoder.pyx'
+include 'src/_raise_decoder.pyx'
+include 'src/_raise_encoder.pyx'
+
+include 'src/_unicode.pyx'
+include 'src/_unicode_mc.pyx'
+include 'src/_unicode_mn.pyx'
+
+include 'src/_reader_ucs.pyx'
+include 'src/_reader_callback.pyx'
+include 'src/_readers.pyx'
+include 'src/_decoder.pyx'
+
+include 'src/_writers.pyx'
+include 'src/_writer_reallocatable.pyx'
+include 'src/_writer_callback.pyx'
+include 'src/_writer_noop.pyx'
+include 'src/_encoder_options.pyx'
+include 'src/_encoder.pyx'
+
+include 'src/_exports.pyx'
+include 'src/_legacy.pyx'
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..f665769
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,4 @@
+cython == 0.*, >= 0.28.2
+wheel == 0.*, >= 0.31.0
+sphinx_autodoc_typehints == 1.*, >= 1.3
+sphinx_rtd_theme == 0.*, >= 0.3.1
diff --git a/setup.py b/setup.py
new file mode 100755
index 0000000..ec9fe7e
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+
+from setuptools import setup, Extension
+from os.path import dirname, join, abspath
+
+
+def get_text(name):
+ root = abspath(dirname(__file__))
+ with open(join(root, 'src', name), 'rt') as f:
+ return eval(f.read().strip())
+
+
+extra_compile_args = [
+ '-std=c++14', '-O2', '-fPIC', '-ggdb1', '-pipe',
+ '-fomit-frame-pointer', '-fstack-protector-strong',
+]
+
+name = 'pyjson5'
+
+setup(
+ name=name,
+ version=get_text('VERSION'),
+ long_description=get_text('DESCRIPTION'),
+ description='JSON5 serializer and parser for Python 3 written in Cython.',
+ author='René Kijewski',
+ author_email='pypi.org@k6i.de',
+ maintainer='René Kijewski',
+ maintainer_email='pypi.org@k6i.de',
+ url='https://github.com/Kijewski/pyjson5',
+ python_requires='~= 3.4',
+ zip_safe=False,
+ ext_modules=[Extension(
+ name,
+ sources=[name + '.pyx'],
+ include_dirs=['src'],
+ extra_compile_args=extra_compile_args,
+ extra_link_args=extra_compile_args,
+ language='c++',
+ )],
+ platforms=['any'],
+ license='Apache 2.0',
+ classifiers=[
+ 'Development Status :: 4 - Beta',
+ 'Intended Audience :: Developers',
+ 'Intended Audience :: System Administrators',
+ 'License :: OSI Approved :: Apache Software License',
+ 'Operating System :: OS Independent',
+ 'Programming Language :: Cython',
+ 'Programming Language :: JavaScript',
+ 'Programming Language :: Python :: 3',
+ 'Programming Language :: Python :: 3.4',
+ 'Programming Language :: Python :: 3.5',
+ 'Programming Language :: Python :: 3.6',
+ 'Programming Language :: Python :: 3.7',
+ 'Programming Language :: Python :: 3 :: Only',
+ 'Programming Language :: Python :: Implementation :: CPython',
+ 'Topic :: Text Processing :: General',
+ ],
+)
diff --git a/src/DESCRIPTION b/src/DESCRIPTION
new file mode 100644
index 0000000..43f722d
--- /dev/null
+++ b/src/DESCRIPTION
@@ -0,0 +1,20 @@
+'''\
+PyJSON5
+-------
+
+A `JSON5 <https://spec.json5.org/>`_ serializer and parser library for Python 3 written in Cython.
+
+The serializer returns ASCII data that can safely be used in an HTML template.
+Apostrophes, ampersands, greater-than, and less-then signs are encoded as
+unicode escaped sequences. E.g. this snippet is safe for any and all input:
+
+.. code:: python
+
+ "<a onclick='alert(" + encode(data) + ")'>show message</a>"
+
+Unless the input contains infinite or NaN values, the result will be valid
+JSON data.
+
+All valid JSON5 1.0.0 and `JSON <https://tools.ietf.org/html/rfc8259>`_ data can be read,
+unless the nesting level is absurdly high.
+'''
diff --git a/src/VERSION b/src/VERSION
new file mode 100644
index 0000000..4273b3c
--- /dev/null
+++ b/src/VERSION
@@ -0,0 +1 @@
+"0.4.3"
diff --git a/src/_constants.pyx b/src/_constants.pyx
new file mode 100644
index 0000000..c1edb56
--- /dev/null
+++ b/src/_constants.pyx
@@ -0,0 +1,15 @@
+cdef object CONST_POS_NAN = float('+NaN')
+cdef object CONST_POS_INF = float('+Infinity')
+cdef object CONST_NEG_NAN = float('-NaN')
+cdef object CONST_NEG_INF = float('-Infinity')
+
+cdef object DATETIME_CLASSES = (date, time, datetime,)
+cdef object ORD_CLASSES = (unicode, bytes, bytearray,)
+
+cdef object UCS1_COMPATIBLE_CODECS = frozenset((
+ # ASCII
+ 'ascii', 646, '646', 'us-ascii',
+ # Latin-1
+ 'latin_1', 'latin-1', 'iso-8859-1', 'iso8859-1',
+ 8859, '8859', 'cp819', 'latin', 'latin1', 'l1',
+))
diff --git a/src/_decoder.pyx b/src/_decoder.pyx
new file mode 100644
index 0000000..9f6b8d1
--- /dev/null
+++ b/src/_decoder.pyx
@@ -0,0 +1,800 @@
+cdef enum:
+ NO_EXTRA_DATA = 0x0011_0000
+
+
+cdef void _skip_single_line(ReaderRef reader):
+ cdef uint32_t c0
+ while _reader_good(reader):
+ c0 = _reader_get(reader)
+ if _is_line_terminator(c0):
+ break
+
+
+cdef boolean _skip_multiline_comment(ReaderRef reader) except False:
+ cdef uint32_t c0
+ cdef boolean seen_asterisk = False
+ cdef Py_ssize_t comment_start = _reader_tell(reader)
+
+ comment_start = _reader_tell(reader)
+
+ seen_asterisk = False
+ while True:
+ if expect(not _reader_good(reader), False):
+ break
+
+ c0 = _reader_get(reader)
+ if c0 == b'*':
+ seen_asterisk = True
+ elif seen_asterisk:
+ if c0 == b'/':
+ return True
+ seen_asterisk = False
+
+ _raise_unclosed(b'comment', comment_start)
+ return False
+
+
+# data found
+# -1: exhausted
+# -2: exception
+cdef int32_t _skip_to_data_sub(ReaderRef reader, uint32_t c0) except -2:
+ cdef int32_t c1
+ cdef boolean seen_slash
+
+ seen_slash = False
+ while True:
+ if c0 == b'/':
+ if seen_slash:
+ _skip_single_line(reader)
+ seen_slash = False
+ else:
+ seen_slash = True
+ elif c0 == b'*':
+ if expect(not seen_slash, False):
+ _raise_stray_character('asterisk', _reader_tell(reader))
+
+ _skip_multiline_comment(reader)
+ seen_slash = False
+ elif not _is_ws_zs(c0):
+ c1 = cast_to_int32(c0)
+ break
+ elif expect(seen_slash, False):
+ _raise_stray_character('slash', _reader_tell(reader))
+
+ if not _reader_good(reader):
+ c1 = -1
+ break
+
+ c0 = _reader_get(reader)
+
+ if expect(seen_slash, False):
+ _raise_stray_character('slash', _reader_tell(reader))
+
+ return c1
+
+
+# data found
+# -1 exhausted
+# -2 exception
+cdef int32_t _skip_to_data(ReaderRef reader) except -2:
+ cdef uint32_t c0
+ cdef int32_t c1
+ if _reader_good(reader):
+ c0 = _reader_get(reader)
+ c1 = _skip_to_data_sub(reader, c0)
+ else:
+ c1 = -1
+ return c1
+
+
+cdef int32_t _get_hex_character(ReaderRef reader, Py_ssize_t length) except -1:
+ cdef Py_ssize_t start
+ cdef uint32_t c0
+ cdef uint32_t result
+ cdef Py_ssize_t index
+
+ start = _reader_tell(reader)
+ result = 0
+ for index in range(length):
+ result <<= 4
+ if expect(not _reader_good(reader), False):
+ _raise_unclosed(b'escape sequence', start)
+
+ c0 = _reader_get(reader)
+ if b'0' <= c0 <= b'9':
+ result |= c0 - <uint32_t> b'0'
+ elif b'a' <= c0 <= b'f':
+ result |= c0 - <uint32_t> b'a' + 10
+ elif b'A' <= c0 <= b'F':
+ result |= c0 - <uint32_t> b'A' + 10
+ else:
+ _raise_expected_s('hexadecimal character', start, c0)
+
+ if expect(result > 0x10ffff, False):
+ _raise_expected_s('Unicode code point', start, result)
+
+ return cast_to_int32(result)
+
+
+# >= 0: character to append
+# -1: skip
+# < -1: -(next character + 1)
+cdef int32_t _get_escape_sequence(ReaderRef reader,
+ Py_ssize_t start) except 0x7ffffff:
+ cdef uint32_t c0
+ cdef uint32_t c1
+
+ c0 = _reader_get(reader)
+ if expect(not _reader_good(reader), False):
+ _raise_unclosed(b'string', start)
+
+ if c0 == b'b':
+ return 0x0008
+ elif c0 == b'f':
+ return 0x000c
+ elif c0 == b'n':
+ return 0x000a
+ elif c0 == b'r':
+ return 0x000d
+ elif c0 == b't':
+ return 0x0009
+ elif c0 == b'v':
+ return 0x000b
+ elif c0 == b'0':
+ return 0x0000
+ elif c0 == b'x':
+ return _get_hex_character(reader, 2)
+ elif c0 == b'u':
+ c0 = cast_to_uint32(_get_hex_character(reader, 4))
+ if expect(Py_UNICODE_IS_LOW_SURROGATE(c0), False):
+ _raise_expected_s('high surrogate before low surrogate', start, c0)
+ elif not Py_UNICODE_IS_HIGH_SURROGATE(c0):
+ return c0
+
+ _accept_string(reader, b'\\u')
+
+ c1 = cast_to_uint32(_get_hex_character(reader, 4))
+ if expect(not Py_UNICODE_IS_LOW_SURROGATE(c1), False):
+ _raise_expected_s('low surrogate', start, c1)
+
+ return Py_UNICODE_JOIN_SURROGATES(c0, c1)
+ elif c0 == b'U':
+ return _get_hex_character(reader, 8)
+ elif expect(b'1' <= c0 <= b'9', False):
+ _raise_expected_s('escape sequence', start, c0)
+ return -2
+ elif _is_line_terminator(c0):
+ if c0 != 0x000D:
+ return -1
+
+ c0 = _reader_get(reader)
+ if c0 == 0x000A:
+ return -1
+
+ return -cast_to_int32(c0 + 1)
+ else:
+ return cast_to_int32(c0)
+
+
+cdef object _decode_string_sub(ReaderRef reader, uint32_t delim,
+ Py_ssize_t start, uint32_t c0):
+ cdef int32_t c1
+ cdef std_vector[uint32_t] buf
+
+ while True:
+ if c0 == delim:
+ break
+
+ if expect(not _reader_good(reader), False):
+ _raise_unclosed(b'string', start)
+
+ if c0 != b'\\':
+ buf.push_back(c0)
+ c0 = _reader_get(reader)
+ continue
+
+ c1 = _get_escape_sequence(reader, start)
+ if c1 >= -1:
+ if expect(not _reader_good(reader), False):
+ _raise_unclosed(b'string', start)
+
+ if c1 >= 0:
+ c0 = cast_to_uint32(c1)
+ buf.push_back(c0)
+
+ c0 = _reader_get(reader)
+ else:
+ c0 = cast_to_uint32(-(c1 + 1))
+
+ return PyUnicode_FromKindAndData(
+ PyUnicode_4BYTE_KIND, buf.data(), buf.size(),
+ )
+
+
+cdef object _decode_string(ReaderRef reader, int32_t *c_in_out):
+ cdef uint32_t delim
+ cdef uint32_t c0
+ cdef int32_t c1
+ cdef Py_ssize_t start
+ cdef object result
+
+ c1 = c_in_out[0]
+ delim = cast_to_uint32(c1)
+ start = _reader_tell(reader)
+
+ if expect(not _reader_good(reader), False):
+ _raise_unclosed(b'string', start)
+
+ c0 = _reader_get(reader)
+ result = _decode_string_sub(reader, delim, start, c0)
+
+ c_in_out[0] = NO_EXTRA_DATA
+ return result
+
+
+cdef object _decode_number_leading_zero(ReaderRef reader, std_vector[char] &buf,
+ int32_t *c_in_out):
+ cdef uint32_t c0
+ cdef int32_t c1
+ cdef object pybuf
+
+ if not _reader_good(reader):
+ c_in_out[0] = -1
+ return 0
+
+ c0 = _reader_get(reader)
+ if _is_x(c0):
+ while True:
+ if not _reader_good(reader):
+ c1 = -1
+ break
+
+ c0 = _reader_get(reader)
+ if _is_hexadecimal(c0):
+ buf.push_back(<char> <unsigned char> c0)
+ elif c0 != b'_':
+ c1 = cast_to_int32(c0)
+ break
+
+ c_in_out[0] = c1
+ pybuf = PyBytes_FromStringAndSize(buf.data(), buf.size())
+ return int(pybuf, 16)
+ elif c0 == b'.':
+ buf.push_back(b'.')
+
+ while True:
+ if not _reader_good(reader):
+ c1 = -1
+ break
+
+ c0 = _reader_get(reader)
+ if _is_in_float_representation(c0):
+ buf.push_back(<char> <unsigned char> c0)
+ elif c0 != b'_':
+ c1 = cast_to_int32(c0)
+ break
+
+ c_in_out[0] = c1
+ pybuf = PyBytes_FromStringAndSize(buf.data(), buf.size())
+ return float(pybuf)
+ elif _is_e(c0):
+ while True:
+ if not _reader_good(reader):
+ c1 = -1
+ break
+
+ c0 = _reader_get(reader)
+ if _is_in_float_representation(c0):
+ pass
+ elif c0 == b'_':
+ pass
+ else:
+ c1 = cast_to_int32(c0)
+ break
+
+ c_in_out[0] = c1
+ return 0.0
+ else:
+ c1 = cast_to_int32(c0)
+ c_in_out[0] = c1
+ return 0
+
+
+cdef object _decode_number_any(ReaderRef reader, std_vector[char] &buf,
+ int32_t *c_in_out):
+ cdef uint32_t c0
+ cdef int32_t c1
+ cdef boolean is_float
+ cdef object pybuf
+
+ c1 = c_in_out[0]
+ c0 = cast_to_uint32(c1)
+
+ is_float = False
+ while True:
+ if _is_decimal(c0):
+ pass
+ elif _is_in_float_representation(c0):
+ is_float = True
+ elif c0 != b'_':
+ c1 = cast_to_int32(c0)
+ break
+
+ if c0 != b'_':
+ buf.push_back(<char> <unsigned char> c0)
+
+ if not _reader_good(reader):
+ c1 = -1
+ break
+
+ c0 = _reader_get(reader)
+
+ c_in_out[0] = c1
+
+ pybuf = PyBytes_FromStringAndSize(buf.data(), buf.size())
+ if is_float:
+ return float(pybuf)
+ else:
+ return int(pybuf, 10)
+
+
+cdef object _decode_number(ReaderRef reader, int32_t *c_in_out):
+ cdef uint32_t c0
+ cdef int32_t c1
+ cdef Py_ssize_t start
+ cdef std_vector[char] buf
+
+ c1 = c_in_out[0]
+ c0 = cast_to_uint32(c1)
+
+ if c0 == b'+':
+ start = _reader_tell(reader)
+ if expect(not _reader_good(reader), False):
+ _raise_unclosed(b'number', start)
+
+ c0 = _reader_get(reader)
+ if c0 == 'I':
+ _accept_string(reader, b'nfinity')
+ c_in_out[0] = NO_EXTRA_DATA
+ return CONST_POS_INF
+ elif c0 == b'N':
+ _accept_string(reader, b'aN')
+ c_in_out[0] = NO_EXTRA_DATA
+ return CONST_POS_NAN
+
+ buf.reserve(16)
+ elif c0 == b'-':
+ start = _reader_tell(reader)
+ if expect(not _reader_good(reader), False):
+ _raise_unclosed(b'number', start)
+
+ c0 = _reader_get(reader)
+ if c0 == 'I':
+ _accept_string(reader, b'nfinity')
+ c_in_out[0] = NO_EXTRA_DATA
+ return CONST_NEG_INF
+ elif c0 == b'N':
+ _accept_string(reader, b'aN')
+ c_in_out[0] = NO_EXTRA_DATA
+ return CONST_NEG_NAN
+
+ buf.reserve(16)
+ buf.push_back(b'-')
+ else:
+ buf.reserve(16)
+
+ if c0 == b'0':
+ return _decode_number_leading_zero(reader, buf, c_in_out)
+ else:
+ c1 = cast_to_int32(c0)
+ c_in_out[0] = c1
+ return _decode_number_any(reader, buf, c_in_out)
+
+
+# 1: done
+# 0: data found
+# -1: exception (exhausted)
+cdef uint32_t _skip_comma(ReaderRef reader, Py_ssize_t start,
+ uint32_t terminator, const char *what,
+ int32_t *c_in_out) except -1:
+ cdef int32_t c0
+ cdef uint32_t c1
+ cdef boolean needs_comma
+ cdef uint32_t done
+
+ c0 = c_in_out[0]
+ c1 = cast_to_uint32(c0)
+
+ needs_comma = True
+ while True:
+ c0 = _skip_to_data_sub(reader, c1)
+ if c0 < 0:
+ break
+
+ c1 = cast_to_uint32(c0)
+ if c1 == terminator:
+ c_in_out[0] = NO_EXTRA_DATA
+ return 1
+
+ if c1 != b',':
+ if expect(needs_comma, False):
+ _raise_expected_sc(
+ 'comma', terminator, _reader_tell(reader), c1,
+ )
+ c_in_out[0] = c0
+ return 0
+
+ if expect(not needs_comma, False):
+ _raise_stray_character('comma', _reader_tell(reader))
+
+ if expect(not _reader_good(reader), False):
+ break
+
+ c1 = _reader_get(reader)
+ needs_comma = False
+
+ _raise_unclosed(what, start)
+ return -1
+
+
+cdef unicode _decode_identifier_name(ReaderRef reader, int32_t *c_in_out):
+ cdef int32_t c0
+ cdef uint32_t c1
+ cdef Py_ssize_t start
+ cdef std_vector[uint32_t] buf
+
+ start = _reader_tell(reader)
+
+ c0 = c_in_out[0]
+ c1 = cast_to_uint32(c0)
+ if expect(not _is_identifier_start(c1), False):
+ _raise_expected_s('IdentifierStart', _reader_tell(reader), c1)
+
+ while True:
+ buf.push_back(c1)
+
+ if not _reader_good(reader):
+ c0 = -1
+ break
+
+ c1 = _reader_get(reader)
+ if not _is_identifier_part(c1):
+ c0 = cast_to_int32(c1)
+ break
+
+ c_in_out[0] = c0
+ return PyUnicode_FromKindAndData(
+ PyUnicode_4BYTE_KIND, buf.data(), buf.size(),
+ )
+
+
+cdef boolean _decode_object(ReaderRef reader, dict result) except False:
+ cdef int32_t c0
+ cdef uint32_t c1
+ cdef Py_ssize_t start
+ cdef boolean done
+ cdef object key
+ cdef object value
+
+ start = _reader_tell(reader)
+
+ c0 = _skip_to_data(reader)
+ if expect(c0 >= 0, True):
+ c1 = cast_to_uint32(c0)
+ if c1 == b'}':
+ return True
+
+ while True:
+ if c1 in b'"\'':
+ key = _decode_string(reader, &c0)
+ else:
+ key = _decode_identifier_name(reader, &c0)
+ if expect(c0 < 0, False):
+ break
+
+ c1 = cast_to_uint32(c0)
+ c0 = _skip_to_data_sub(reader, c1)
+ if expect(c0 < 0, False):
+ break
+
+ c1 = cast_to_uint32(c0)
+ if expect(c1 != b':', False):
+ _raise_expected_s('colon', _reader_tell(reader), c1)
+
+ if expect(not _reader_good(reader), False):
+ break
+
+ c0 = _skip_to_data(reader)
+ if expect(c0 < 0, False):
+ break
+
+ try:
+ value = _decode_recursive(reader, &c0)
+ except _DecoderException as ex:
+ result[key] = (<_DecoderException> ex).result
+ raise
+
+ if expect(c0 < 0, False):
+ break
+
+ result[key] = value
+
+ done = _skip_comma(
+ reader, start, <unsigned char>b'}', b'object', &c0,
+ )
+ if done:
+ return True
+
+ c1 = cast_to_uint32(c0)
+
+ _raise_unclosed(b'object', start)
+ return False
+
+
+cdef boolean _decode_array(ReaderRef reader, list result) except False:
+ cdef int32_t c0
+ cdef uint32_t c1
+ cdef Py_ssize_t start
+ cdef boolean done
+ cdef object value
+
+ start = _reader_tell(reader)
+
+ c0 = _skip_to_data(reader)
+ if expect(c0 >= 0, True):
+ c1 = cast_to_uint32(c0)
+ if c1 == b']':
+ return True
+
+ while True:
+ try:
+ value = _decode_recursive(reader, &c0)
+ except _DecoderException as ex:
+ result.append((<_DecoderException> ex).result)
+ raise
+
+ if expect(c0 < 0, False):
+ break
+
+ result.append(value)
+
+ done = _skip_comma(
+ reader, start, <unsigned char>b']', b'array', &c0,
+ )
+ if done:
+ return True
+
+ _raise_unclosed(b'array', start)
+
+
+cdef boolean _accept_string(ReaderRef reader, const char *string) except False:
+ cdef uint32_t c0
+ cdef uint32_t c1
+ cdef Py_ssize_t start
+
+ start = _reader_tell(reader)
+ while True:
+ c0 = string[0]
+ string += 1
+ if not c0:
+ break
+
+ if expect(not _reader_good(reader), False):
+ _raise_unclosed(b'literal', start)
+
+ c1 = _reader_get(reader)
+ if expect(c0 != c1, False):
+ _raise_expected_c(c0, start, c1)
+
+ return True
+
+
+cdef object _decode_literal(ReaderRef reader, int32_t *c_in_out):
+ cdef const char *tail
+ cdef object result
+ cdef uint32_t c0
+ cdef int32_t c1
+
+ c0 = cast_to_uint32(c_in_out[0])
+ if c0 == b'n':
+ tail = b'ull'
+ result = None
+ elif c0 == b't':
+ tail = b'rue'
+ result = True
+ elif c0 == b'f':
+ tail = b'alse'
+ result = False
+ elif c0 == b'I':
+ tail = b'nfinity'
+ result = CONST_POS_INF
+ else: # elif c0 == b'N':
+ tail = b'aN'
+ result = CONST_POS_NAN
+
+ _accept_string(reader, tail)
+
+ c_in_out[0] = NO_EXTRA_DATA
+ return result
+
+
+cdef object _decode_recursive_enter(ReaderRef reader, int32_t *c_in_out):
+ cdef object result
+ cdef int32_t c0
+ cdef uint32_t c1
+
+ c0 = c_in_out[0]
+ c1 = cast_to_uint32(c0)
+
+ _reader_enter(reader)
+ try:
+ if c1 == b'{':
+ result = {}
+ _decode_object(reader, result)
+ else:
+ result = []
+ _decode_array(reader, result)
+ except RecursionError:
+ _raise_nesting(_reader_tell(reader), result)
+ except _DecoderException as ex:
+ (<_DecoderException> ex).result = result
+ raise ex
+ finally:
+ _reader_leave(reader)
+
+ c_in_out[0] = NO_EXTRA_DATA
+ return result
+
+
+cdef object _decoder_unknown(ReaderRef reader, int32_t *c_in_out):
+ cdef int32_t c0
+ cdef uint32_t c1
+ cdef Py_ssize_t start
+
+ c0 = c_in_out[0]
+ c1 = cast_to_uint32(c0)
+ start = _reader_tell(reader)
+
+ _raise_expected_s('JSON5Value', start, c1)
+
+
+cdef object _decode_recursive(ReaderRef reader, int32_t *c_in_out):
+ cdef object (*decoder)(ReaderRef, int32_t*)
+ cdef int32_t c0
+ cdef uint32_t c1
+
+ c0 = c_in_out[0]
+ c1 = cast_to_uint32(c0)
+
+ decoder = _decoder_unknown
+ if c1 in b'ntfIN':
+ decoder = _decode_literal
+ elif c1 in b'\'"':
+ decoder = _decode_string
+ elif c1 in b'+-.0123456789':
+ decoder = _decode_number
+ elif c1 in b'{[':
+ decoder = _decode_recursive_enter
+
+ return decoder(reader, c_in_out)
+
+
+cdef object _decode_all_sub(ReaderRef reader, boolean some):
+ cdef Py_ssize_t start
+ cdef int32_t c0
+ cdef uint32_t c1
+ cdef object result
+
+ start = _reader_tell(reader)
+ c0 = _skip_to_data(reader)
+ if expect(c0 < 0, False):
+ _raise_no_data(start)
+
+ result = _decode_recursive(reader, &c0)
+ try:
+ if c0 < 0:
+ pass
+ elif not some:
+ start = _reader_tell(reader)
+ c1 = cast_to_uint32(c0)
+ c0 = _skip_to_data_sub(reader, c1)
+ if expect(c0 >= 0, False):
+ c1 = cast_to_uint32(c0)
+ _raise_extra_data(c1, start)
+ elif expect(not _is_ws_zs(c0), False):
+ start = _reader_tell(reader)
+ c1 = cast_to_uint32(c0)
+ _raise_unframed_data(c1, start)
+ except _DecoderException as ex:
+ (<_DecoderException> ex).result = result
+ raise ex
+
+ return result
+
+
+cdef object _decode_all(ReaderRef reader, boolean some):
+ cdef Exception ex_result
+ cdef _DecoderException ex
+ try:
+ return _decode_all_sub(reader, some)
+ except _DecoderException as e:
+ ex = <_DecoderException> e
+ ex_result = ex.cls(ex.msg, ex.result, ex.extra)
+ raise ex_result
+
+
+cdef object _decode_ucs1(const void *string, Py_ssize_t length,
+ Py_ssize_t maxdepth, boolean some):
+ cdef ReaderUCS1 reader = ReaderUCS1(
+ ReaderUCS(length, 0, maxdepth),
+ <const Py_UCS1*> string,
+ )
+ return _decode_all(reader, some)
+
+
+cdef object _decode_ucs2(const void *string, Py_ssize_t length,
+ Py_ssize_t maxdepth, boolean some):
+ cdef ReaderUCS2 reader = ReaderUCS2(
+ ReaderUCS(length, 0, maxdepth),
+ <const Py_UCS2*> string,
+ )
+ return _decode_all(reader, some)
+
+
+cdef object _decode_ucs4(const void *string, Py_ssize_t length,
+ Py_ssize_t maxdepth, boolean some):
+ cdef ReaderUCS4 reader = ReaderUCS4(
+ ReaderUCS(length, 0, maxdepth),
+ <const Py_UCS4*> string,
+ )
+ return _decode_all(reader, some)
+
+
+cdef object _decode_unicode(object data, Py_ssize_t maxdepth, boolean some):
+ cdef Py_ssize_t length
+ cdef int kind
+
+ PyUnicode_READY(data)
+
+ length = PyUnicode_GET_LENGTH(data)
+ kind = PyUnicode_KIND(data)
+
+ if kind == PyUnicode_1BYTE_KIND:
+ return _decode_ucs1(PyUnicode_1BYTE_DATA(data), length, maxdepth, some)
+ elif kind == PyUnicode_2BYTE_KIND:
+ return _decode_ucs2(PyUnicode_2BYTE_DATA(data), length, maxdepth, some)
+ elif kind == PyUnicode_4BYTE_KIND:
+ return _decode_ucs4(PyUnicode_4BYTE_DATA(data), length, maxdepth, some)
+ else:
+ pass # impossible
+
+
+cdef object _decode_buffer(Py_buffer &view, int32_t wordlength,
+ Py_ssize_t maxdepth, boolean some):
+ cdef object (*decoder)(const void*, Py_ssize_t, Py_ssize_t, boolean)
+ cdef Py_ssize_t length
+
+ if wordlength == 1:
+ decoder = _decode_ucs1
+ length = view.len // 1
+ elif wordlength == 2:
+ decoder = _decode_ucs2
+ length = view.len // 2
+ elif wordlength == 4:
+ decoder = _decode_ucs4
+ length = view.len // 4
+ else:
+ _raise_illegal_wordlength(wordlength)
+
+ return decoder(view.buf, length, maxdepth, some)
+
+
+cdef object _decode_callback(object cb, object args, Py_ssize_t maxdepth,
+ boolean some):
+ cdef ReaderCallback reader = ReaderCallback(
+ ReaderCallbackBase(0, maxdepth),
+ <PyObject*> cb,
+ <PyObject*> args,
+ -1,
+ )
+ return _decode_all(reader, some)
diff --git a/src/_encoder.pyx b/src/_encoder.pyx
new file mode 100644
index 0000000..f151597
--- /dev/null
+++ b/src/_encoder.pyx
@@ -0,0 +1,404 @@
+cdef enum EncType:
+ ENC_TYPE_EXCEPTION
+ ENC_TYPE_UNKNOWN
+ ENC_TYPE_NONE
+ ENC_TYPE_UNICODE
+ ENC_TYPE_BOOL
+ ENC_TYPE_BYTES
+ ENC_TYPE_LONG
+ ENC_TYPE_DECIMAL
+ ENC_TYPE_FLOAT
+ ENC_TYPE_DATETIME
+ ENC_TYPE_MAPPING
+ ENC_TYPE_SEQUENCE
+
+
+cdef boolean _encode_unicode_impl(WriterRef writer, UCSString data, Py_ssize_t length) except False:
+ cdef char buf[16]
+ cdef uint32_t c
+ cdef uint32_t s1, s2
+ cdef Py_ssize_t index
+ cdef const char *escaped_string
+ cdef Py_ssize_t escaped_length
+ cdef size_t unescaped_length
+
+ if length > 0:
+ writer.reserve(writer, 2 + length)
+ writer.append_c(writer, <char> b'"')
+ if UCSString is UCS1String:
+ while True:
+ unescaped_length = ESCAPE_DCT.find_unescaped_range(<const char*> data, length)
+ if unescaped_length > 0:
+ writer.append_s(writer, <const char*> data, unescaped_length)
+
+ data += unescaped_length
+ length -= unescaped_length
+ if length <= 0:
+ break
+
+ c = data[0]
+ escaped_string = &ESCAPE_DCT.items[c][0]
+ escaped_length = ESCAPE_DCT.items[c][7]
+ writer.append_s(writer, escaped_string, escaped_length)
+
+ data += 1
+ length -= 1
+ if length <= 0:
+ break
+ else:
+ for index in range(length):
+ c = data[index]
+ if UCSString is UCS2String:
+ if not ESCAPE_DCT.is_escaped(c):
+ writer.append_c(writer, <char> <unsigned char> c)
+ else:
+ escaped_string = &ESCAPE_DCT.items[c][0]
+ escaped_length = ESCAPE_DCT.items[c][7]
+ writer.append_s(writer, escaped_string, escaped_length)
+ elif UCSString is UCS4String:
+ if not ESCAPE_DCT.is_escaped(c):
+ writer.append_c(writer, <char> <unsigned char> c)
+ elif c < 0x10000:
+ escaped_string = &ESCAPE_DCT.items[c][0]
+ escaped_length = ESCAPE_DCT.items[c][7]
+ writer.append_s(writer, escaped_string, escaped_length)
+ else:
+ # surrogate pair
+ c -= 0x10000
+ s1 = 0xd800 | ((c >> 10) & 0x3ff)
+ s2 = 0xdc00 | (c & 0x3ff)
+
+ snprintf(buf, sizeof(buf), b'\\u%04x\\u%04x', s1, s2)
+ writer.append_s(writer, buf, 2 * 6)
+ writer.append_c(writer, <char> b'"')
+ else:
+ writer.append_s(writer, b'""', 2)
+
+ return True
+
+
+cdef boolean _encode_unicode(WriterRef writer, object data, EncType enc_type) except False:
+ cdef Py_ssize_t length
+ cdef int kind
+
+ PyUnicode_READY(data)
+
+ length = PyUnicode_GET_LENGTH(data)
+ kind = PyUnicode_KIND(data)
+
+ if kind == PyUnicode_1BYTE_KIND:
+ _encode_unicode_impl(writer, PyUnicode_1BYTE_DATA(data), length)
+ elif kind == PyUnicode_2BYTE_KIND:
+ _encode_unicode_impl(writer, PyUnicode_2BYTE_DATA(data), length)
+ elif kind == PyUnicode_4BYTE_KIND:
+ _encode_unicode_impl(writer, PyUnicode_4BYTE_DATA(data), length)
+ else:
+ pass # impossible
+
+ return True
+
+
+cdef boolean _encode_nested_key(WriterRef writer, object data) except False:
+ cdef const char *string
+ cdef char c
+ cdef Py_ssize_t index, length
+
+ cdef WriterReallocatable sub_writer = WriterReallocatable(
+ Writer(
+ _WriterReallocatable_reserve,
+ _WriterReallocatable_append_c,
+ _WriterReallocatable_append_s,
+ writer.options,
+ ),
+ 0, 0, NULL,
+ )
+ try:
+ _encode(sub_writer.base, data)
+
+ length = sub_writer.position
+ string = <char*> sub_writer.obj
+
+ writer.reserve(writer, 2 + length)
+ writer.append_c(writer, <char> b'"')
+ for index in range(length):
+ c = string[index]
+ if c not in b'\\"':
+ writer.append_c(writer, c)
+ elif c == b'\\':
+ writer.append_s(writer, b'\\\\', 2)
+ else:
+ writer.append_s(writer, b'\\u0022', 6)
+ writer.append_c(writer, <char> b'"')
+ finally:
+ if sub_writer.obj is not NULL:
+ ObjectFree(sub_writer.obj)
+
+ return True
+
+
+cdef boolean _append_ascii(WriterRef writer, object data) except False:
+ cdef Py_buffer view
+ cdef const char *buf
+
+ if PyUnicode_Check(data):
+ PyUnicode_READY(data)
+ if not PyUnicode_IS_ASCII(data):
+ raise TypeError('Expected ASCII data')
+ writer.append_s(writer, <const char*> PyUnicode_1BYTE_DATA(data), PyUnicode_GET_LENGTH(data))
+ else:
+ PyObject_GetBuffer(data, &view, PyBUF_CONTIG_RO)
+ try:
+ buf = <const char*> view.buf
+ for index in range(view.len):
+ c = buf[index]
+ if c & ~0x7f:
+ raise TypeError('Expected ASCII data')
+
+ writer.append_s(writer, buf, view.len)
+ finally:
+ PyBuffer_Release(&view)
+
+ return True
+
+
+cdef boolean _encode_sequence(WriterRef writer, object data) except False:
+ cdef boolean first
+ cdef object value
+
+ writer.append_c(writer, <char> b'[')
+ first = True
+ for value in data:
+ if not first:
+ writer.append_c(writer, <char> b',')
+ else:
+ first = False
+ _encode(writer, value)
+ writer.append_c(writer, <char> b']')
+
+ return True
+
+
+cdef boolean _encode_mapping(WriterRef writer, object data) except False:
+ cdef boolean first
+ cdef object key, value
+
+ writer.append_c(writer, <char> b'{')
+ first = True
+ for key in data:
+ if not first:
+ writer.append_c(writer, <char> b',')
+ else:
+ first = False
+ value = data[key]
+
+ if PyUnicode_Check(key):
+ _encode_unicode(writer, key, ENC_TYPE_UNICODE)
+ else:
+ _encode_nested_key(writer, key)
+
+ writer.append_c(writer, <char> b':')
+ _encode(writer, value)
+ writer.append_c(writer, <char> b'}')
+
+ return True
+
+
+cdef boolean _encode_constant(WriterRef writer, object data, EncType enc_type) except False:
+ cdef const char *string
+ cdef Py_ssize_t length
+
+ if data is True:
+ string = b'true'
+ length = 4
+ elif data is False:
+ string = b'false'
+ length = 5
+ else:
+ string = b'null'
+ length = 4
+
+ writer.append_s(writer, string, length)
+ return True
+
+
+cdef boolean _encode_bytes(WriterRef writer, object data, EncType enc_type) except False:
+ cdef unicode_data = data.decode('UTF-8', 'replace')
+ _encode_unicode(writer, unicode_data, ENC_TYPE_UNICODE)
+ return True
+
+
+cdef boolean _encode_datetime(WriterRef writer, object data, EncType enc_type) except False:
+ cdef const char *string
+ cdef Py_ssize_t length
+ cdef object stringified
+
+ stringified = data.isoformat()
+ string = PyUnicode_AsUTF8AndSize(stringified, &length)
+
+ writer.reserve(writer, 2 + length)
+ writer.append_c(writer, <char> b'"')
+ writer.append_s(writer, string, length)
+ writer.append_c(writer, <char> b'"')
+
+ return True
+
+
+cdef boolean _encode_numeric(WriterRef writer, object data, EncType enc_type) except False:
+ cdef object formatter_string
+ cdef const char *string
+ cdef Py_ssize_t length
+ cdef int classification
+
+ if enc_type == ENC_TYPE_LONG:
+ formatter_string = (<Options> writer.options).intformat
+ elif enc_type == ENC_TYPE_DECIMAL:
+ formatter_string = (<Options> writer.options).decimalformat
+ else:
+ value = PyFloat_AsDouble(data)
+ classification = fpclassify(value)
+ if classification == FP_NORMAL:
+ formatter_string = (<Options> writer.options).floatformat
+ elif classification in (FP_SUBNORMAL, FP_ZERO):
+ string = b'0'
+ length = 1
+
+ writer.append_s(writer, string, length)
+ return True
+ else:
+ if classification == FP_NAN:
+ formatter_string = (<Options> writer.options).nan
+ elif value > 0.0:
+ formatter_string = (<Options> writer.options).posinfinity
+ else:
+ formatter_string = (<Options> writer.options).neginfinity
+
+ if formatter_string is None:
+ _raise_unstringifiable(data)
+
+ string = <const char*> PyUnicode_1BYTE_DATA(formatter_string)
+ length = PyUnicode_GET_LENGTH(formatter_string)
+
+ writer.append_s(writer, string, length)
+ return True
+
+ if formatter_string is None:
+ _raise_unstringifiable(data)
+
+ formatter_string = (formatter_string % data)
+ string = PyUnicode_AsUTF8AndSize(formatter_string, &length)
+ writer.append_s(writer, string, length)
+ return True
+
+
+cdef boolean _encode_recursive(WriterRef writer, object data, EncType enc_type) except False:
+ cdef object to_json
+ cdef boolean (*encoder)(WriterRef writer, object data) except False
+
+ Py_EnterRecursiveCall(' while encoding nested JSON5 object')
+ try:
+ to_json = (<Options> writer.options).tojson
+ if to_json is not None:
+ to_json = getattr(data, to_json, None)
+ if to_json is not None:
+ if callable(to_json):
+ to_json = to_json()
+ _append_ascii(writer, to_json)
+ return True
+
+ if enc_type == ENC_TYPE_SEQUENCE:
+ encoder = _encode_sequence
+ elif enc_type == ENC_TYPE_MAPPING:
+ encoder = _encode_mapping
+ else:
+ _raise_unstringifiable(data)
+ encoder = NULL
+
+ encoder(writer, data)
+ return True
+ finally:
+ Py_LeaveRecursiveCall()
+
+
+cdef boolean _encode(WriterRef writer, object data) except False:
+ cdef boolean (*encoder)(WriterRef, object, EncType) except False
+ cdef EncType enc_type
+
+ if data is None:
+ enc_type = ENC_TYPE_NONE
+ elif PyUnicode_Check(data):
+ enc_type = ENC_TYPE_UNICODE
+ elif PyBool_Check(data):
+ enc_type = ENC_TYPE_BOOL
+ elif PyBytes_Check(data):
+ enc_type = ENC_TYPE_BYTES
+ elif PyLong_Check(data):
+ enc_type = ENC_TYPE_LONG
+ elif PyFloat_Check(data):
+ enc_type = ENC_TYPE_FLOAT
+ elif obj_has_iter(data):
+ if isinstance(data, (<Options> writer.options).mappingtypes):
+ enc_type = ENC_TYPE_MAPPING
+ else:
+ enc_type = ENC_TYPE_SEQUENCE
+ elif isinstance(data, Decimal):
+ enc_type = ENC_TYPE_DECIMAL
+ elif isinstance(data, DATETIME_CLASSES):
+ enc_type = ENC_TYPE_DATETIME
+ elif data == None:
+ enc_type = ENC_TYPE_NONE
+ else:
+ enc_type = ENC_TYPE_UNKNOWN
+
+ encoder = _encode_recursive
+ if enc_type in (ENC_TYPE_NONE, ENC_TYPE_BOOL):
+ encoder = _encode_constant
+ elif enc_type == ENC_TYPE_UNICODE:
+ encoder = _encode_unicode
+ elif enc_type == ENC_TYPE_BYTES:
+ encoder = _encode_bytes
+ elif enc_type in (ENC_TYPE_LONG, ENC_TYPE_DECIMAL, ENC_TYPE_FLOAT):
+ encoder = _encode_numeric
+ elif enc_type == ENC_TYPE_DATETIME:
+ encoder = _encode_datetime
+
+ encoder(writer, data, enc_type)
+
+ return True
+
+
+cdef boolean _encode_callback_bytes(object data, object cb, object options) except False:
+ cdef WriterCallback writer = WriterCallback(
+ Writer(
+ _WriterNoop_reserve,
+ _WriterCbBytes_append_c,
+ _WriterCbBytes_append_s,
+ <PyObject*> options,
+ ),
+ <PyObject*> cb,
+ )
+
+ if not callable(cb):
+ raise TypeError(f'type(cb)=={type(cb)!r} is callable')
+
+ _encode(writer.base, data)
+
+ return True
+
+
+cdef boolean _encode_callback_str(object data, object cb, object options) except False:
+ cdef WriterCallback writer = WriterCallback(
+ Writer(
+ _WriterNoop_reserve,
+ _WriterCbStr_append_c,
+ _WriterCbStr_append_s,
+ <PyObject*> options,
+ ),
+ <PyObject*> cb,
+ )
+
+ if not callable(cb):
+ raise TypeError(f'type(cb)=={type(cb)!r} is callable')
+
+ _encode(writer.base, data)
+
+ return True
diff --git a/src/_encoder_options.pyx b/src/_encoder_options.pyx
new file mode 100644
index 0000000..2c7da49
--- /dev/null
+++ b/src/_encoder_options.pyx
@@ -0,0 +1,221 @@
+cdef object DEFAULT_TOJSON = False
+cdef object DEFAULT_POSINFINITY = 'Infinity'
+cdef object DEFAULT_NEGINFINITY = '-Infinity'
+cdef object DEFAULT_NAN = 'NaN'
+cdef object DEFAULT_INTFORMAT = '%d'
+cdef object DEFAULT_FLOATFORMAT = '%.6e'
+cdef object DEFAULT_DECIMALFORMAT = '%s'
+cdef object DEFAULT_MAPPINGTYPES = (Mapping,)
+
+
+cdef object _options_ascii(object datum, boolean expect_ascii=True):
+ if datum is False:
+ return None
+ elif PyBytes_Check(datum):
+ datum = unicode(datum, 'UTF-8', 'strict')
+ elif not PyUnicode_Check(datum):
+ raise TypeError('Expected str instance or False')
+
+ PyUnicode_READY(datum)
+ if expect_ascii and not PyUnicode_IS_ASCII(datum):
+ raise ValueError('Expected ASCII data')
+
+ return datum
+
+
+cdef object _option_from_ascii(object name, object value, object default):
+ if value == default:
+ return
+ elif value is None:
+ return f'{name}=False'
+ else:
+ return f'{name}={value!r}'
+
+
+cdef _options_from_ascii(Options self):
+ return ', '.join(filter(bool, (
+ _option_from_ascii('tojson', self.tojson, None),
+ _option_from_ascii('posinfinity', self.posinfinity, DEFAULT_POSINFINITY),
+ _option_from_ascii('neginfinity', self.neginfinity, DEFAULT_NEGINFINITY),
+ _option_from_ascii('intformat', self.intformat, DEFAULT_INTFORMAT),
+ _option_from_ascii('floatformat', self.floatformat, DEFAULT_DECIMALFORMAT),
+ _option_from_ascii('decimalformat', self.decimalformat, DEFAULT_FLOATFORMAT),
+ _option_from_ascii('nan', self.nan, DEFAULT_NAN),
+ )))
+
+
+@final
+@auto_pickle(False)
+cdef class Options:
+ '''
+ Customizations for the ``encoder_*(...)`` function family.
+
+ Immutable. Use ``Options.update(**kw)`` to create a **new** Options instance.
+
+ Parameters
+ ----------
+ tojson : str|False|None
+ * **str:** A special method to call on objects to return a custom JSON encoded string. Must return ASCII data!
+ * **False:** No such member exists. (Default.)
+ * **None:** Use default.
+ posinfinity : str|False|None
+ * **str:** String to represent positive infinity. Must be ASCII.
+ * **False:** Throw an exception if ``float('+inf')`` is encountered.
+ * **None:** Use default: ``"Infinity"``.
+ neginfinity : str|False|None
+ * **str:** String to represent negative infinity. Must be ASCII.
+ * **False:** Throw an exception if ``float('-inf')`` is encountered.
+ * **None:** Use default: ``"-Infinity"``.
+ nan : str|False|None
+ * **str:** String to represent not-a-number. Must be ASCII.
+ * **False:** Throw an exception if ``float('NaN')`` is encountered.
+ * **None:** Use default: ``"NaN"``.
+ intformat : str|False|None
+ * **str:** Format string to use with ``int``.
+ * **False:** Throw an exception if an ``int`` is encountered.
+ * **None:** Use default: ``"%d"``.
+ floatformat : str|False|None
+ * **str:** Format string to use with ``float``.
+ * **False:** Throw an exception if a ``float`` is encountered.
+ * **None:** Use default: ``"%.6e"``.
+ decimalformat : str|False|None
+ * **str:** Format string to use with ``Decimal``.
+ * **False:** Throw an exception if a ``Decimal`` is encountered.
+ * **None:** Use default: ``"%s"``.
+ mappingtypes : Iterable[type]|False|None
+ * **Iterable[type]:** Classes the should be encoded to objects. \
+ Must be iterable over their keys, and implement ``__getitem__``.
+ * **False:** There are no objects. Any object will be encoded as list of key-value tuples.
+ * **None:** Use default: ``[collections.abc.Mapping]``.
+ '''
+ cdef readonly unicode tojson
+ '''The creation argument ``tojson``.
+ ``None`` if ``False`` was specified.
+ '''
+ cdef readonly unicode posinfinity
+ '''The creation argument ``posinfinity``.
+ ``None`` if ``False`` was specified.
+ '''
+ cdef readonly unicode neginfinity
+ '''The creation argument ``neginfinity``.
+ ``None`` if ``False`` was specified.
+ '''
+ cdef readonly unicode nan
+ '''The creation argument ``nan``.
+ ``None`` if ``False`` was specified.
+ '''
+ cdef readonly unicode intformat
+ '''The creation argument ``intformat``.
+ ``None`` if ``False`` was specified.
+ '''
+ cdef readonly unicode floatformat
+ '''The creation argument ``floatformat``.
+ ``None`` if ``False`` was specified.
+ '''
+ cdef readonly unicode decimalformat
+ '''The creation argument ``decimalformat``.
+ ``None`` if ``False`` was specified.
+ '''
+ cdef readonly tuple mappingtypes
+ '''The creation argument ``mappingtypes``.
+ ``()`` if ``False`` was specified.
+ '''
+
+
+ def __reduce__(self):
+ '''
+ Pickling is not supported (yet).
+ '''
+ raise NotImplementedError
+
+ def __reduce_ex__(self, protocol):
+ '''
+ Pickling is not supported (yet).
+ '''
+ raise NotImplementedError
+
+ def __repr__(self):
+ repr_options = _options_from_ascii(self)
+ repr_cls = (
+ ''
+ if self.mappingtypes == DEFAULT_MAPPINGTYPES else
+ repr(DEFAULT_MAPPINGTYPES)
+ )
+ return (f'Options('
+ f'{repr_options}'
+ f'{repr_options and repr_cls and ", "}'
+ f'{repr_cls}'
+ ')')
+
+ def __str__(self):
+ return self.__repr__()
+
+ def __cinit__(self, *,
+ tojson=None, posinfinity=None, neginfinity=None, nan=None,
+ decimalformat=None, intformat=None, floatformat=None,
+ mappingtypes=None):
+ cdef object cls
+
+ if tojson is None:
+ tojson = DEFAULT_TOJSON
+ if posinfinity is None:
+ posinfinity = DEFAULT_POSINFINITY
+ if neginfinity is None:
+ neginfinity = DEFAULT_NEGINFINITY
+ if nan is None:
+ nan = DEFAULT_NAN
+ if intformat is None:
+ intformat = DEFAULT_INTFORMAT
+ if floatformat is None:
+ floatformat = DEFAULT_FLOATFORMAT
+ if decimalformat is None:
+ decimalformat = DEFAULT_DECIMALFORMAT
+ if mappingtypes is None:
+ mappingtypes = DEFAULT_MAPPINGTYPES
+
+ self.tojson = _options_ascii(tojson, False)
+ self.posinfinity = _options_ascii(posinfinity)
+ self.neginfinity = _options_ascii(neginfinity)
+ self.intformat = _options_ascii(intformat)
+ self.floatformat = _options_ascii(floatformat)
+ self.decimalformat = _options_ascii(decimalformat)
+ self.nan = _options_ascii(nan)
+
+ if mappingtypes is False:
+ self.mappingtypes = ()
+ else:
+ self.mappingtypes = tuple(mappingtypes)
+ for cls in self.mappingtypes:
+ if not PyType_Check(cls):
+ raise TypeError('mappingtypes must be a sequence of types '
+ 'or False')
+
+ def update(self, **kw):
+ '''
+ Creates a new Options instance by modifying some members.
+ '''
+ return _to_options(self, kw)
+
+
+cdef Options DEFAULT_OPTIONS_OBJECT = Options()
+
+
+cdef object _to_options(Options arg, dict kw):
+ if arg is None:
+ if not kw:
+ return DEFAULT_OPTIONS_OBJECT
+ else:
+ return Options(**kw)
+ elif not kw:
+ return arg
+
+ PyDict_SetDefault(kw, 'tojson', (<Options> arg).tojson)
+ PyDict_SetDefault(kw, 'posinfinity', (<Options> arg).posinfinity)
+ PyDict_SetDefault(kw, 'neginfinity', (<Options> arg).neginfinity)
+ PyDict_SetDefault(kw, 'nan', (<Options> arg).nan)
+ PyDict_SetDefault(kw, 'intformat', (<Options> arg).intformat)
+ PyDict_SetDefault(kw, 'floatformat', (<Options> arg).floatformat)
+ PyDict_SetDefault(kw, 'decimalformat', (<Options> arg).decimalformat)
+ PyDict_SetDefault(kw, 'mappingtypes', (<Options> arg).mappingtypes)
+
+ return Options(**kw)
diff --git a/src/_exceptions.pyx b/src/_exceptions.pyx
new file mode 100644
index 0000000..286f409
--- /dev/null
+++ b/src/_exceptions.pyx
@@ -0,0 +1,12 @@
+@auto_pickle(False)
+cdef class Json5Exception(Exception):
+ '''
+ Base class of any exception thrown by PyJSON5.
+ '''
+ def __init__(self, message=None, *args):
+ super().__init__(message, *args)
+
+ @property
+ def message(self):
+ '''Human readable error description'''
+ return self.args[0]
diff --git a/src/_exceptions_decoder.pyx b/src/_exceptions_decoder.pyx
new file mode 100644
index 0000000..03fc233
--- /dev/null
+++ b/src/_exceptions_decoder.pyx
@@ -0,0 +1,92 @@
+@auto_pickle(False)
+cdef class Json5DecoderException(Json5Exception):
+ '''
+ Base class of any exception thrown by the parser.
+ '''
+ def __init__(self, message=None, result=None, *args):
+ super().__init__(message, result, *args)
+
+ @property
+ def result(self):
+ '''Deserialized data up until now.'''
+ return self.args[1]
+
+
+@final
+@auto_pickle(False)
+cdef class Json5NestingTooDeep(Json5DecoderException):
+ '''
+ The maximum nesting level on the input data was exceeded.
+ '''
+
+
+@final
+@auto_pickle(False)
+cdef class Json5EOF(Json5DecoderException):
+ '''
+ The input ended prematurely.
+ '''
+
+
+@final
+@auto_pickle(False)
+cdef class Json5IllegalCharacter(Json5DecoderException):
+ '''
+ An unexpected character was encountered.
+ '''
+ def __init__(self, message=None, result=None, character=None, *args):
+ super().__init__(message, result, character, *args)
+
+ @property
+ def character(self):
+ '''Extranous character.'''
+ return self.args[2]
+
+
+@final
+@auto_pickle(False)
+cdef class Json5ExtraData(Json5DecoderException):
+ '''
+ The input contained extranous data.
+ '''
+ def __init__(self, message=None, result=None, character=None, *args):
+ super().__init__(message, result, character, *args)
+
+ @property
+ def character(self):
+ '''
+ Extranous character.
+ '''
+ return self.args[2]
+
+
+@final
+@auto_pickle(False)
+cdef class Json5IllegalType(Json5DecoderException):
+ '''
+ The user supplied callback function returned illegal data.
+ '''
+ def __init__(self, message=None, result=None, value=None, *args):
+ super().__init__(message, result, value, *args)
+
+ @property
+ def value(self):
+ '''
+ Value that caused the problem.
+ '''
+ return self.args[2]
+
+
+@final
+@auto_pickle(False)
+cdef class _DecoderException(Exception):
+ cdef object cls
+ cdef object msg
+ cdef object extra
+ cdef object result
+
+ def __cinit__(self, cls, msg, extra, result):
+ self.cls = cls
+ self.msg = msg
+ self.extra = extra
+ self.result = result
diff --git a/src/_exceptions_encoder.pyx b/src/_exceptions_encoder.pyx
new file mode 100644
index 0000000..78665c1
--- /dev/null
+++ b/src/_exceptions_encoder.pyx
@@ -0,0 +1,21 @@
+@auto_pickle(False)
+cdef class Json5EncoderException(Json5Exception):
+ '''
+ Base class of any exception thrown by the serializer.
+ '''
+
+
+@auto_pickle(False)
+cdef class Json5UnstringifiableType(Json5EncoderException):
+ '''
+ The encoder was not able to stringify the input, or it was told not to by the supplied ``Options``.
+ '''
+ def __init__(self, message=None, unstringifiable=None):
+ super().__init__(message, unstringifiable)
+
+ @property
+ def unstringifiable(self):
+ '''
+ The value that caused the problem.
+ '''
+ return self.args[1]
diff --git a/src/_exports.pyx b/src/_exports.pyx
new file mode 100644
index 0000000..61fe156
--- /dev/null
+++ b/src/_exports.pyx
@@ -0,0 +1,605 @@
+DEFAULT_MAX_NESTING_LEVEL = 32
+'''
+Maximum nesting level of data to decode if no ``maxdepth`` argument is specified.
+'''
+
+__version__ = PyUnicode_FromKindAndData(PyUnicode_1BYTE_KIND, VERSION, VERSION_LENGTH)
+'''
+Current library version.
+'''
+
+
+def decode(object data, object maxdepth=None, object some=False):
+ '''
+ Decodes JSON5 serialized data from an ``str`` object.
+
+ .. code:: python
+
+ decode('["Hello", "world!"]') == ['Hello', 'world!']
+
+ Parameters
+ ----------
+ data : unicode
+ JSON5 serialized data
+ maxdepth : Optional[int]
+ Maximum nesting level before are the parsing is aborted.
+
+ * If ``None`` is supplied, then the value of the global variable \
+ ``DEFAULT_MAX_NESTING_LEVEL`` is used instead.
+ * If the value is ``0``, then only literals are accepted, e.g. ``false``, \
+ ``47.11``, or ``"string"``.
+ * If the value is negative, then the any nesting level is allowed until \
+ Python's recursion limit is hit.
+ some : bool
+ Allow trailing junk.
+
+ Raises
+ ------
+ Json5DecoderException
+ An exception occured while decoding.
+ TypeError
+ An argument had a wrong type.
+
+ Returns
+ -------
+ object
+ Deserialized data.
+ '''
+ if maxdepth is None:
+ maxdepth = DEFAULT_MAX_NESTING_LEVEL
+
+ if isinstance(data, unicode):
+ return _decode_unicode(data, maxdepth, bool(some))
+ else:
+ raise TypeError(f'type(data) == {type(data)!r} not supported')
+
+
+def decode_latin1(object data, object maxdepth=None, object some=False):
+ '''
+ Decodes JSON5 serialized data from a ``bytes`` object.
+
+ .. code:: python
+
+ decode_buffer(b'["Hello", "world!"]') == ['Hello', 'world!']
+
+ Parameters
+ ----------
+ data : bytes
+ JSON5 serialized data, encoded as Latin-1 or ASCII.
+ maxdepth : Optional[int]
+ see `decode(...) <pyjson5.decode_>`_
+ some : bool
+ see `decode(...) <pyjson5.decode_>`_
+
+ Raises
+ ------
+ Json5DecoderException
+ An exception occured while decoding.
+ TypeError
+ An argument had a wrong type.
+
+ Returns
+ -------
+ object
+ see `decode(...) <pyjson5.decode_>`_
+ '''
+ return decode_buffer(data, maxdepth, bool(some), 1)
+
+
+def decode_buffer(object obj, object maxdepth=None, object some=False,
+ object wordlength=None):
+ '''
+ Decodes JSON5 serialized data from an object that supports the buffer
+ protocol, e.g. bytearray.
+
+ .. code:: python
+
+ obj = memoryview(b'["Hello", "world!"]')
+
+ decode_buffer(obj) == ['Hello', 'world!']
+
+ Parameters
+ ----------
+ data : object
+ JSON5 serialized data.
+ The argument must support Python's buffer protocol, i.e.
+ ``memoryview(...)`` must work. The buffer must be contigious.
+ maxdepth : Optional[int]
+ see `decode(...) <pyjson5.decode_>`_
+ some : bool
+ see `decode(...) <pyjson5.decode_>`_
+ wordlength : Optional[int]
+ Must be 1, 2, 4 to denote UCS1, USC2 or USC4 data.
+ Surrogates are not supported. Decode the data to an ``str`` if need be.
+ If ``None`` is supplied, then the buffer's ``itemsize`` is used.
+
+ Raises
+ ------
+ Json5DecoderException
+ An exception occured while decoding.
+ TypeError
+ An argument had a wrong type.
+ ValueError
+ The value of ``wordlength`` was invalid.
+
+ Returns
+ -------
+ object
+ see `decode(...) <pyjson5.decode_>`_
+ '''
+ cdef Py_buffer view
+
+ if maxdepth is None:
+ maxdepth = DEFAULT_MAX_NESTING_LEVEL
+
+ PyObject_GetBuffer(obj, &view, PyBUF_CONTIG_RO)
+ try:
+ if wordlength is None:
+ wordlength = view.itemsize
+ return _decode_buffer(view, wordlength, maxdepth, bool(some))
+ finally:
+ PyBuffer_Release(&view)
+
+
+def decode_callback(object cb, object maxdepth=None, object some=False,
+ object args=None):
+ '''
+ Decodes JSON5 serialized data by invoking a callback.
+
+ .. code:: python
+
+ cb = iter('["Hello","world!"]').__next__
+
+ decode_callback(cb) == ['Hello', 'world!']
+
+ Parameters
+ ----------
+ cb : Callable[Any, Union[str|bytes|bytearray|int|None]]
+ A function to get values from.
+ The functions is called like ``cb(*args)``, and it returns:
+
+ * **str, bytes, bytearray:** \
+ ``len(...) == 0`` denotes exhausted input. \
+ ``len(...) == 1`` is the next character.
+ * **int:** \
+ ``< 0`` denotes exhausted input. \
+ ``>= 0`` is the ordinal value of the next character.
+ * **None:** \
+ input exhausted
+ maxdepth : Optional[int]
+ see `decode(...) <pyjson5.decode_>`_
+ some : bool
+ see `decode(...) <pyjson5.decode_>`_
+ args : Optional[Iterable[Any]]
+ Arguments to call ``cb`` with.
+
+ Raises
+ ------
+ Json5DecoderException
+ An exception occured while decoding.
+ TypeError
+ An argument had a wrong type.
+
+ Returns
+ -------
+ object
+ see ``decode(...)``
+ '''
+ if not callable(cb):
+ raise TypeError(f'type(cb)=={type(cb)!r} is not callable')
+
+ if maxdepth is None:
+ maxdepth = DEFAULT_MAX_NESTING_LEVEL
+
+ if args:
+ args = tuple(args)
+ else:
+ args = ()
+
+ return _decode_callback(cb, args, maxdepth, bool(some))
+
+
+def decode_io(object fp, object maxdepth=None, object some=True):
+ '''
+ Decodes JSON5 serialized data from a file-like object.
+
+ .. code:: python
+
+ fp = io.StringIO("""
+ ['Hello', /* TODO look into specs whom to greet */]
+ 'Wolrd' // FIXME: look for typos
+ """)
+
+ decode_io(fp) == ['Hello']
+ decode_io(fp) == 'Wolrd'
+
+ fp.seek(0)
+
+ decode_io(fp, some=False)
+ # raises Json5ExtraData('Extra data U+0027 near 56', ['Hello'], "'")
+
+ Parameters
+ ----------
+ fp : IOBase
+ A file-like object to parse from.
+ maxdepth : Optional[int] = None
+ see `decode(...) <pyjson5.decode_>`_
+ some : bool
+ see `decode(...) <pyjson5.decode_>`_
+
+ Raises
+ ------
+ Json5DecoderException
+ An exception occured while decoding.
+ TypeError
+ An argument had a wrong type.
+
+ Returns
+ -------
+ object
+ see ``decode(...)``
+ '''
+ if not isinstance(fp, IOBase):
+ raise TypeError(f'type(fp)=={type(fp)!r} is not IOBase compatible')
+ elif not fp.readable():
+ raise TypeError(f'fp is not readable')
+ elif fp.closed:
+ raise TypeError(f'fp is closed')
+
+ if maxdepth is None:
+ maxdepth = DEFAULT_MAX_NESTING_LEVEL
+
+ return _decode_callback(fp.read, (1,), maxdepth, bool(some))
+
+
+def encode(object data, *, options=None, **options_kw):
+ '''
+ Serializes a Python object to a JSON5 compatible unicode string.
+
+ .. code:: python
+
+ encode(['Hello', 'world!']) == '["Hello","world!"]'
+
+ Parameters
+ ----------
+ data : object
+ Python object to serialize.
+ options : Optional[Options]
+ Extra options for the encoder.
+ If ``options`` **and** ``options_kw`` are specified, then ``options.update(**options_kw)`` is used.
+ options_kw
+ See Option's arguments.
+
+ Raises
+ ------
+ Json5EncoderException
+ An exception occured while encoding.
+ TypeError
+ An argument had a wrong type.
+
+ Returns
+ -------
+ str
+ Unless ``float('inf')`` or ``float('nan')`` is encountered, the result
+ will be valid JSON data (as of RFC8259).
+
+ The result is always ASCII. All characters outside of the ASCII range
+ are encoded.
+
+ The result safe to use in an HTML template, e.g.
+ ``<a onclick='alert({{ encode(url) }})'>show message</a>``.
+ Apostrophes ``"'"`` are encoded as ``"\\u0027"``, less-than,
+ greater-than, and ampersand likewise.
+ '''
+ cdef void *temp = NULL
+ cdef object result
+ cdef Py_ssize_t start = (
+ <Py_ssize_t> <void*> &(<AsciiObject*> NULL).data[0]
+ )
+ cdef Py_ssize_t length
+ cdef object opts = _to_options(options, options_kw)
+ cdef WriterReallocatable writer = WriterReallocatable(
+ Writer(
+ _WriterReallocatable_reserve,
+ _WriterReallocatable_append_c,
+ _WriterReallocatable_append_s,
+ <PyObject*> opts,
+ ),
+ start, 0, NULL,
+ )
+
+ try:
+ _encode(writer.base, data)
+
+ length = writer.position - start
+ if length <= 0:
+ # impossible
+ return u''
+
+ temp = ObjectRealloc(writer.obj, writer.position + 1)
+ if temp is not NULL:
+ writer.obj = temp
+ (<char*> writer.obj)[writer.position] = 0
+
+ result = ObjectInit(<PyObject*> writer.obj, unicode)
+ writer.obj = NULL
+
+ (<PyASCIIObject*> result).length = length
+ (<PyASCIIObject*> result).hash = -1
+ (<PyASCIIObject*> result).wstr = NULL
+ (<PyASCIIObject*> result).state.interned = SSTATE_NOT_INTERNED
+ (<PyASCIIObject*> result).state.kind = PyUnicode_1BYTE_KIND
+ (<PyASCIIObject*> result).state.compact = True
+ (<PyASCIIObject*> result).state.ready = True
+ (<PyASCIIObject*> result).state.ascii = True
+
+ return result
+ finally:
+ if writer.obj is not NULL:
+ ObjectFree(writer.obj)
+
+
+def encode_bytes(object data, *, options=None, **options_kw):
+ '''
+ Serializes a Python object to a JSON5 compatible bytes string.
+
+ .. code:: python
+
+ encode_bytes(['Hello', 'world!']) == b'["Hello","world!"]'
+
+ Parameters
+ ----------
+ data : object
+ see `encode(...) <pyjson5.encode_>`_
+ options : Optional[Options]
+ see `encode(...) <pyjson5.encode_>`_
+ options_kw
+ see `encode(...) <pyjson5.encode_>`_
+
+ Raises
+ ------
+ Json5EncoderException
+ An exception occured while encoding.
+ TypeError
+ An argument had a wrong type.
+
+ Returns
+ -------
+ bytes
+ see `encode(...) <pyjson5.encode_>`_
+ '''
+ cdef void *temp = NULL
+ cdef object result
+ cdef Py_ssize_t start = (
+ <Py_ssize_t> <void*> &(<PyBytesObject*> NULL).ob_sval[0]
+ )
+ cdef Py_ssize_t length
+ cdef object opts = _to_options(options, options_kw)
+ cdef WriterReallocatable writer = WriterReallocatable(
+ Writer(
+ _WriterReallocatable_reserve,
+ _WriterReallocatable_append_c,
+ _WriterReallocatable_append_s,
+ <PyObject*> opts,
+ ),
+ start, 0, NULL,
+ )
+
+ try:
+ _encode(writer.base, data)
+
+ length = writer.position - start
+ if length <= 0:
+ # impossible
+ return b''
+
+ temp = ObjectRealloc(writer.obj, writer.position + 1)
+ if temp is not NULL:
+ writer.obj = temp
+ (<char*> writer.obj)[writer.position] = 0
+
+ result = <object> <PyObject*> ObjectInitVar(
+ (<PyVarObject*> writer.obj), bytes, length,
+ )
+ writer.obj = NULL
+
+ (<PyBytesObject*> result).ob_shash = -1
+
+ return result
+ finally:
+ if writer.obj is not NULL:
+ ObjectFree(writer.obj)
+
+
+def encode_callback(object data, object cb, object supply_bytes=False, *,
+ options=None, **options_kw):
+ '''
+ Serializes a Python object into a callback function.
+
+ The callback function ``cb`` gets called with single characters and strings
+ until the input ``data`` is fully serialized.
+
+ .. code:: python
+
+ encode_callback(['Hello', 'world!'], print)
+ #prints:
+ # [
+ # "
+ # Hello
+ # "
+ # ,
+ # "
+ # world!
+ # "
+ " ]
+
+ Parameters
+ ----------
+ data : object
+ see `encode(...) <pyjson5.encode_>`_
+ cb : Callable[[Union[bytes|str]], None]
+ A callback function.
+ Depending on the truthyness of ``supply_bytes`` either ``bytes`` or
+ ``str`` is supplied.
+ supply_bytes : bool
+ Call ``cb(...)`` with a ``bytes`` argument if true,
+ otherwise ``str``.
+ options : Optional[Options]
+ see `encode(...) <pyjson5.encode_>`_
+ options_kw
+ see `encode(...) <pyjson5.encode_>`_
+
+ Raises
+ ------
+ Json5EncoderException
+ An exception occured while encoding.
+ TypeError
+ An argument had a wrong type.
+
+ Returns
+ -------
+ Callable[[Union[bytes|str]], None]
+ The supplied argument ``cb``.
+ '''
+ cdef boolean (*encoder)(object obj, object cb, object options) except False
+ cdef Options opts = _to_options(options, options_kw)
+
+ if supply_bytes:
+ encoder = _encode_callback_bytes
+ else:
+ encoder = _encode_callback_str
+
+ encoder(data, cb, options=opts)
+
+ return cb
+
+
+def encode_io(object data, object fp, object supply_bytes=True, *,
+ options=None, **options_kw):
+ '''
+ Serializes a Python object into a file-object.
+
+ The return value of ``fp.write(...)`` is not checked.
+ If ``fp`` is unbuffered, then the result will be garbage!
+
+ Parameters
+ ----------
+ data : object
+ see `encode(...) <pyjson5.encode_>`_
+ fp : IOBase
+ A file-like object to serialize into.
+ supply_bytes : bool
+ Call ``fp.write(...)`` with a ``bytes`` argument if true,
+ otherwise ``str``.
+ options : Optional[Options]
+ see `encode(...) <pyjson5.encode_>`_
+ options_kw
+ see `encode(...) <pyjson5.encode_>`_
+
+ Raises
+ ------
+ Json5EncoderException
+ An exception occured while encoding.
+ TypeError
+ An argument had a wrong type.
+
+ Returns
+ -------
+ IOBase
+ The supplied argument ``fp``.
+ '''
+ cdef boolean (*encoder)(object obj, object cb, object options) except False
+ cdef object opts = _to_options(options, options_kw)
+
+ if not isinstance(fp, IOBase):
+ raise TypeError(f'type(fp)=={type(fp)!r} is not IOBase compatible')
+ elif not fp.writable():
+ raise TypeError(f'fp is not writable')
+ elif fp.closed:
+ raise TypeError(f'fp is closed')
+
+ if supply_bytes:
+ encoder = _encode_callback_bytes
+ else:
+ encoder = _encode_callback_str
+
+ encoder(data, fp.write, options=opts)
+
+ return fp
+
+
+def encode_noop(object data, *, options=None, **options_kw):
+ '''
+ Test if the input is serializable.
+
+ Most likely you want to serialize ``data`` directly, and catch exceptions
+ instead of using this function!
+
+ .. code:: python
+
+ encode_noop({47: 11}) == True
+ encode_noop({47: object()}) == False
+
+ Parameters
+ ----------
+ data : object
+ see `encode(...) <pyjson5.encode_>`_
+ options : Optional[Options]
+ see `encode(...) <pyjson5.encode_>`_
+ options_kw
+ see `encode(...) <pyjson5.encode_>`_
+
+ Returns
+ -------
+ bool
+ ``True`` iff ``data`` is serializable.
+ '''
+ cdef object opts = _to_options(options, options_kw)
+ cdef Writer writer = Writer(
+ _WriterNoop_reserve,
+ _WriterNoop_append_c,
+ _WriterNoop_append_s,
+ <PyObject*> opts,
+ )
+
+ try:
+ _encode(writer, data)
+ except Exception:
+ return False
+
+ return True
+
+
+__all__ = (
+ # DECODE
+ 'decode', 'decode_latin1', 'decode_buffer', 'decode_callback', 'decode_io',
+ # ENCODE
+ 'encode', 'encode_bytes', 'encode_callback', 'encode_io', 'encode_noop', 'Options',
+ # LEGACY
+ 'loads', 'load', 'dumps', 'dump',
+ # EXCEPTIONS
+ 'Json5Exception',
+ 'Json5EncoderException', 'Json5UnstringifiableType',
+ 'Json5DecoderException', 'Json5NestingTooDeep', 'Json5EOF', 'Json5IllegalCharacter', 'Json5ExtraData', 'Json5IllegalType',
+)
+
+__doc__ = '''\
+PyJSON5
+-------
+
+A JSON5 serializer and parser library for Python 3 written in Cython.
+
+The serializer returns ASCII data that can safely be used in an HTML template.
+Apostrophes, ampersands, greater-than, and less-then signs are encoded as
+unicode escaped sequences. E.g. this snippet is safe for any and all input:
+
+.. code:: python
+
+ "<a onclick='alert(" + encode(data) + ")'>show message</a>"
+
+Unless the input contains infinite or NaN values, the result will be valid
+JSON data.
+
+All valid JSON5 1.0.0 and JSON data can be read, unless the nesting level is
+absurdly high.
+'''
diff --git a/src/_imports.pyx b/src/_imports.pyx
new file mode 100644
index 0000000..c139f71
--- /dev/null
+++ b/src/_imports.pyx
@@ -0,0 +1,171 @@
+from cython import final, no_gc, auto_pickle
+from cpython cimport dict, int, list, long, tuple, type
+from cpython.bool cimport PyBool_Check
+from cpython.buffer cimport (
+ PyObject_GetBuffer, PyObject_GetBuffer, PyBUF_CONTIG_RO, PyBuffer_Release,
+)
+from cpython.bytes cimport (
+ PyBytes_AsStringAndSize, PyBytes_FromStringAndSize, PyBytes_Check,
+)
+from cpython.datetime cimport datetime, date, time
+from cpython.float cimport PyFloat_Check, PyFloat_AsDouble
+from cpython.int cimport PyInt_Check
+from cpython.long cimport PyLong_FromString, PyLong_Check
+from cpython.object cimport PyObject
+from cpython.type cimport PyType_Check
+from cpython.unicode cimport PyUnicode_Check
+from libcpp cimport bool as boolean
+from libcpp.vector cimport vector as std_vector
+
+
+cdef extern from '<cstddef>' namespace 'std' nogil:
+ ctypedef unsigned long size_t
+
+
+cdef extern from '<cstdint>' namespace 'std' nogil:
+ ctypedef unsigned char uint8_t
+ ctypedef unsigned short uint16_t
+ ctypedef unsigned long uint32_t
+ ctypedef unsigned long long uint64_t
+
+ ctypedef signed char int8_t
+ ctypedef signed short int16_t
+ ctypedef signed long int32_t
+ ctypedef signed long long int64_t
+
+
+cdef extern from '<cstdio>' namespace 'std' nogil:
+ int snprintf(char *buffer, size_t buf_size, const char *format, ...)
+ size_t strlen(const char *s)
+
+
+cdef extern from '<cstring>' namespace 'std' nogil:
+ void memcpy(void *dest, const void *std, size_t count)
+ void memset(void *dest, char value, size_t count)
+ size_t strlen(const char *s)
+
+
+cdef extern from '<cmath>' nogil:
+ enum:
+ FP_INFINITE, FP_NAN, FP_NORMAL, FP_SUBNORMAL, FP_ZERO
+
+cdef extern from '<cmath>' namespace 'std' nogil:
+ int fpclassify(...)
+
+
+cdef extern from '<utility>' namespace 'std' nogil:
+ void swap[T](T&, T&)
+
+
+cdef extern from 'src/native.hpp' namespace 'JSON5EncoderCpp' nogil:
+ int32_t cast_to_int32(...)
+ uint32_t cast_to_uint32(...)
+
+ ctypedef boolean AlwaysTrue
+ boolean obj_has_iter(object obj)
+
+ ctypedef char EscapeDctItem[8]
+ struct EscapeDct:
+ EscapeDctItem items[0x10000]
+ boolean is_escaped(uint32_t c)
+ Py_ssize_t find_unescaped_range(const char *start, Py_ssize_t length)
+ EscapeDct ESCAPE_DCT
+
+ enum:
+ VERSION_LENGTH
+ const char VERSION[]
+
+ enum:
+ LONGDESCRIPTION_LENGTH
+ const char LONGDESCRIPTION[]
+
+
+cdef extern from 'Python.h':
+ ctypedef signed char Py_UCS1
+ ctypedef signed short Py_UCS2
+ ctypedef signed long Py_UCS4
+
+ enum:
+ PyUnicode_WCHAR_KIND
+ PyUnicode_1BYTE_KIND
+ PyUnicode_2BYTE_KIND
+ PyUnicode_4BYTE_KIND
+
+ int PyUnicode_READY(object o) except -1
+ Py_ssize_t PyUnicode_GET_LENGTH(object o) nogil
+ int PyUnicode_KIND(object o) nogil
+ boolean PyUnicode_IS_ASCII(object) nogil
+ Py_UCS1 *PyUnicode_1BYTE_DATA(object o) nogil
+ Py_UCS2 *PyUnicode_2BYTE_DATA(object o) nogil
+ Py_UCS4 *PyUnicode_4BYTE_DATA(object o) nogil
+
+ boolean Py_EnterRecursiveCall(const char *where) except True
+ void Py_LeaveRecursiveCall()
+
+ bint Py_UNICODE_ISALPHA(Py_UCS4 ch) nogil
+ bint Py_UNICODE_ISDIGIT(Py_UCS4 ch) nogil
+ bint Py_UNICODE_IS_SURROGATE(Py_UCS4 ch) nogil
+ bint Py_UNICODE_IS_HIGH_SURROGATE(Py_UCS4 ch) nogil
+ bint Py_UNICODE_IS_LOW_SURROGATE(Py_UCS4 ch) nogil
+ Py_UCS4 Py_UNICODE_JOIN_SURROGATES(Py_UCS4 high, Py_UCS4 low) nogil
+
+ object PyUnicode_FromKindAndData(int kind, const void *buf, Py_ssize_t size)
+ char *PyUnicode_AsUTF8AndSize(object o, Py_ssize_t *size) except NULL
+
+ object PyDict_SetDefault(object p, object key, object value)
+
+ object CallFunction 'PyObject_CallFunction'(PyObject *cb, const char *format, ...)
+ object CallObject 'PyObject_CallObject'(PyObject *cb, PyObject *args)
+
+ ctypedef signed long Py_hash
+ ctypedef signed short wchar_t
+
+ enum:
+ SSTATE_NOT_INTERNED
+ SSTATE_INTERNED_MORTAL
+ SSTATE_INTERNED_IMMORTAL
+
+ ctypedef struct __ascii_object_state:
+ uint8_t interned
+ uint8_t kind
+ boolean compact
+ boolean ascii
+ boolean ready
+
+ ctypedef struct PyASCIIObject:
+ Py_ssize_t length
+ Py_hash hash
+ wchar_t *wstr
+ __ascii_object_state state
+
+ ctypedef struct PyVarObject:
+ pass
+
+ ctypedef struct PyBytesObject:
+ PyVarObject ob_base
+ Py_hash ob_shash
+ char ob_sval[1]
+
+ AlwaysTrue ErrNoMemory 'PyErr_NoMemory'() except True
+ void *ObjectRealloc 'PyObject_Realloc'(void *p, size_t n)
+ void ObjectFree 'PyObject_Free'(void *p)
+ object ObjectInit 'PyObject_INIT'(PyObject *obj, type cls)
+ PyVarObject *ObjectInitVar 'PyObject_InitVar'(PyVarObject *obj, type cls, Py_ssize_t size)
+
+
+ctypedef struct AsciiObject:
+ PyASCIIObject base
+ char data[1]
+
+
+cdef extern from * nogil:
+ boolean expect '__builtin_expect'(boolean actual, boolean expected)
+
+
+cdef type Decimal, Mapping, IOBase
+cdef object saferepr
+
+from collections.abc import Mapping
+from decimal import Decimal
+from io import IOBase
+from pprint import saferepr
diff --git a/src/_legacy.pyx b/src/_legacy.pyx
new file mode 100644
index 0000000..218ff83
--- /dev/null
+++ b/src/_legacy.pyx
@@ -0,0 +1,100 @@
+def loads(s, *, encoding='UTF-8', **kw):
+ '''
+ Decodes JSON5 serialized data from a string.
+
+ Use `decode(...) <pyjson5.decode_>`_ instead!
+
+ .. code:: python
+
+ loads(s) == decode(s)
+
+ Parameters
+ ----------
+ s : object
+ Unless the argument is an ``str``, it gets decoded according to the
+ parameter ``encoding``.
+ encoding : str
+ Codec to use if ``s`` is not an ``str``.
+ kw
+ Silently ignored.
+
+ Returns
+ -------
+ object
+ see ``decode(...)``
+ '''
+ if not isinstance(s, unicode):
+ s = unicode(s, encoding, 'strict')
+ return decode(s)
+
+
+def load(fp, **kw):
+ '''
+ Decodes JSON5 serialized data from a file-like object.
+
+ Use `decode_io(...) <pyjson5.decode_io_>`_ instead!
+
+ .. code:: python
+
+ load(fp) == decode_io(fp, None, False)
+
+ Parameters
+ ----------
+ fp : IOBase
+ A file-like object to parse from.
+ kw
+ Silently ignored.
+
+ Returns
+ -------
+ object
+ see ``decode(...)``
+ '''
+ return decode_io(fp, None, False)
+
+
+def dumps(obj, **kw):
+ '''
+ Serializes a Python object to a JSON5 compatible unicode string.
+
+ Use `encode(...) <pyjson5.encode_>`_ instead!
+
+ .. code:: python
+
+ dumps(obj) == encode(obj)
+
+ Parameters
+ ----------
+ obj : object
+ Python object to serialize.
+ kw
+ Silently ignored.
+
+ Returns
+ -------
+ unicode
+ see ``encode(data)``
+ '''
+ return encode(obj)
+
+
+def dump(object obj, object fp, **kw):
+ '''
+ Serializes a Python object to a JSON5 compatible unicode string.
+
+ Use `encode_io(...) <pyjson5.encode_io_>`_ instead!
+
+ .. code:: python
+
+ dump(obj, fp) == encode_io(obj, fp)
+
+ Parameters
+ ----------
+ obj : object
+ Python object to serialize.
+ fp : IOBase
+ A file-like object to serialize into.
+ kw
+ Silently ignored.
+ '''
+ encode_io(obj, fp)
diff --git a/src/_raise_decoder.pyx b/src/_raise_decoder.pyx
new file mode 100644
index 0000000..24cf494
--- /dev/null
+++ b/src/_raise_decoder.pyx
@@ -0,0 +1,81 @@
+cdef AlwaysTrue _raise_decoder(cls, msg, extra=None, result=None) except True:
+ raise _DecoderException(cls, msg, extra, result)
+
+
+cdef AlwaysTrue _raise_unclosed(const char *what, Py_ssize_t start) except True:
+ return _raise_decoder(
+ Json5EOF,
+ f'Unclosed {what} starting near {start}',
+ )
+
+
+cdef AlwaysTrue _raise_no_data(Py_ssize_t where) except True:
+ return _raise_decoder(
+ Json5EOF,
+ f'No JSON data found near {where}',
+ )
+
+
+cdef AlwaysTrue _raise_stray_character(const char *what, Py_ssize_t where) except True:
+ return _raise_decoder(
+ Json5IllegalCharacter,
+ f'Stray {what} near {where}',
+ what,
+ )
+
+
+cdef AlwaysTrue _raise_expected_sc(const char *char_a, uint32_t char_b, Py_ssize_t near, uint32_t found) except True:
+ return _raise_decoder(
+ Json5IllegalCharacter,
+ f'Expected {char_a} or U+{char_b:04x} near {near}, found U+{found:04x}',
+ f'{found:c}',
+ )
+
+
+cdef AlwaysTrue _raise_expected_s(const char *char_a, Py_ssize_t near, uint32_t found) except True:
+ return _raise_decoder(
+ Json5IllegalCharacter,
+ f'Expected {char_a} near {near}, found U+{found:04x}',
+ f'{found:c}',
+ )
+
+
+cdef AlwaysTrue _raise_expected_c(uint32_t char_a, Py_ssize_t near, uint32_t found) except True:
+ return _raise_decoder(
+ Json5IllegalCharacter,
+ f'Expected U+{char_a:04x} near {near}, found U+{found:04x}',
+ f'{found:c}',
+ )
+
+
+cdef AlwaysTrue _raise_extra_data(uint32_t found, Py_ssize_t where) except True:
+ return _raise_decoder(
+ Json5ExtraData,
+ f'Extra data U+{found:04X} near {where}',
+ f'{found:c}',
+ )
+
+
+cdef AlwaysTrue _raise_unframed_data(uint32_t found, Py_ssize_t where) except True:
+ return _raise_decoder(
+ Json5ExtraData,
+ f'Lost unframed data near {where}',
+ f'{found:c}',
+ )
+
+
+cdef AlwaysTrue _raise_nesting(Py_ssize_t where, object result=None) except True:
+ return _raise_decoder(
+ Json5NestingTooDeep,
+ f'Maximum nesting level exceeded near {where}',
+ None,
+ result,
+ )
+
+
+cdef AlwaysTrue _raise_not_ord(object value, Py_ssize_t where) except True:
+ return _raise_decoder(
+ Json5IllegalType,
+ f'type(value)=={type(value)!r} not in (int, str, bytes) near {where} or the value is not valid.',
+ value,
+ )
diff --git a/src/_raise_encoder.pyx b/src/_raise_encoder.pyx
new file mode 100644
index 0000000..5e9076d
--- /dev/null
+++ b/src/_raise_encoder.pyx
@@ -0,0 +1,6 @@
+cdef AlwaysTrue _raise_unstringifiable(object data) except True:
+ raise Json5UnstringifiableType(f'Unstringifiable type(data)={type(data)!r}', data)
+
+
+cdef AlwaysTrue _raise_illegal_wordlength(int32_t wordlength) except True:
+ raise ValueError(f'wordlength must be 1, 2 or 4, not {wordlength!r}')
diff --git a/src/_reader_callback.pyx b/src/_reader_callback.pyx
new file mode 100644
index 0000000..f99249c
--- /dev/null
+++ b/src/_reader_callback.pyx
@@ -0,0 +1,50 @@
+cdef struct ReaderCallbackBase:
+ Py_ssize_t position
+ Py_ssize_t maxdepth
+
+
+cdef struct ReaderCallback:
+ ReaderCallbackBase base
+ PyObject *callback
+ PyObject *args
+ int32_t lookahead
+
+ctypedef ReaderCallback &ReaderCallbackRef
+
+
+cdef inline uint32_t _reader_Callback_get(ReaderCallbackRef self):
+ cdef int32_t c = self.lookahead
+
+ self.lookahead = -1
+ self.base.position += 1
+
+ return cast_to_uint32(c)
+
+
+cdef int32_t _reader_Callback_good(ReaderCallbackRef self) except -1:
+ cdef Py_ssize_t c = -1
+
+ if self.lookahead >= 0:
+ return True
+
+ cdef object value = CallObject(self.callback, self.args)
+ if (value is None) or (value is False):
+ return False
+
+ if isinstance(value, int):
+ c = value
+ elif isinstance(value, ORD_CLASSES):
+ if not value:
+ return False
+ c = ord(value)
+ else:
+ _raise_not_ord(value, self.base.position)
+
+ if c < 0:
+ return False
+ elif c > 0x10ffff:
+ _raise_not_ord(value, self.base.position)
+
+ self.lookahead = c
+
+ return True
diff --git a/src/_reader_ucs.pyx b/src/_reader_ucs.pyx
new file mode 100644
index 0000000..f94a5f2
--- /dev/null
+++ b/src/_reader_ucs.pyx
@@ -0,0 +1,52 @@
+cdef struct ReaderUCS:
+ Py_ssize_t remaining
+ Py_ssize_t position
+ Py_ssize_t maxdepth
+
+
+cdef struct ReaderUCS1:
+ ReaderUCS base
+ const Py_UCS1 *string
+
+
+cdef struct ReaderUCS2:
+ ReaderUCS base
+ const Py_UCS2 *string
+
+
+cdef struct ReaderUCS4:
+ ReaderUCS base
+ const Py_UCS4 *string
+
+
+ctypedef ReaderUCS1 &ReaderUCS1Ref
+ctypedef ReaderUCS2 &ReaderUCS2Ref
+ctypedef ReaderUCS4 &ReaderUCS4Ref
+
+ctypedef Py_UCS1 *UCS1String
+ctypedef Py_UCS2 *UCS2String
+ctypedef Py_UCS4 *UCS4String
+
+ctypedef fused ReaderUCSRef:
+ ReaderUCS1Ref
+ ReaderUCS2Ref
+ ReaderUCS4Ref
+
+ctypedef fused UCSString:
+ UCS1String
+ UCS2String
+ UCS4String
+
+
+cdef inline int32_t _reader_ucs_good(ReaderUCSRef self):
+ return self.base.remaining > 0
+
+
+cdef inline uint32_t _reader_ucs_get(ReaderUCSRef self):
+ cdef int32_t c = self.string[0]
+
+ self.string += 1
+ self.base.remaining -= 1
+ self.base.position += 1
+
+ return cast_to_uint32(c)
diff --git a/src/_readers.pyx b/src/_readers.pyx
new file mode 100644
index 0000000..fff1ba0
--- /dev/null
+++ b/src/_readers.pyx
@@ -0,0 +1,37 @@
+ctypedef fused ReaderRef:
+ ReaderUCSRef
+ ReaderCallbackRef
+
+
+cdef boolean _reader_enter(ReaderRef self) except False:
+ if self.base.maxdepth == 0:
+ _raise_nesting(_reader_tell(self))
+
+ Py_EnterRecursiveCall(' while decoding nested JSON5 object')
+
+ self.base.maxdepth -= 1
+
+ return True
+
+
+cdef void _reader_leave(ReaderRef self):
+ Py_LeaveRecursiveCall()
+ self.base.maxdepth += 1
+
+
+cdef inline Py_ssize_t _reader_tell(ReaderRef self):
+ return self.base.position
+
+
+cdef inline uint32_t _reader_get(ReaderRef self):
+ if ReaderRef in ReaderUCSRef:
+ return _reader_ucs_get(self)
+ elif ReaderRef is ReaderCallbackRef:
+ return _reader_Callback_get(self)
+
+
+cdef int32_t _reader_good(ReaderRef self) except -1:
+ if ReaderRef in ReaderUCSRef:
+ return _reader_ucs_good(self)
+ elif ReaderRef is ReaderCallbackRef:
+ return _reader_Callback_good(self)
diff --git a/src/_unicode.pyx b/src/_unicode.pyx
new file mode 100644
index 0000000..3801b20
--- /dev/null
+++ b/src/_unicode.pyx
@@ -0,0 +1,131 @@
+cdef boolean _is_line_terminator(uint32_t c) nogil:
+ # https://www.ecma-international.org/ecma-262/5.1/#sec-7.3
+ if expect(c <= 0x00FF, True):
+ return c in (
+ 0x000A, # Line Feed <LF>
+ 0x000D, # Carriage Return <CR>
+ )
+ elif expect(c <= 0xFFFF, True):
+ return c in (
+ 0x2028, # Line separator <LS>
+ 0x2029, # Paragraph separator <PS>
+ )
+ else:
+ return False
+
+
+cdef boolean _is_ws_zs(uint32_t c) nogil:
+ # https://spec.json5.org/#white-space
+ # https://www.fileformat.info/info/unicode/category/Zs/list.htm
+ if expect(c <= 0x00FF, True):
+ return c in (
+ 0x0009, # Horizontal tab
+ 0x000A, # Line feed
+ 0x000B, # Vertical tab
+ 0x000C, # Form feed
+ 0x000D, # Carriage return
+ 0x0020, # Space
+ 0x0020, # SPACE
+ 0x00A0, # NO-BREAK SPACE
+ 0x00A0, # Non-breaking space
+ )
+ elif expect(c <= 0xFFFF, True):
+ return c in (
+ 0x1680, # OGHAM SPACE MARK
+ 0x2000, # EN QUAD
+ 0x2001, # EM QUAD
+ 0x2002, # EN SPACE
+ 0x2003, # EM SPACE
+ 0x2004, # THREE-PER-EM SPACE
+ 0x2005, # FOUR-PER-EM SPACE
+ 0x2006, # SIX-PER-EM SPACE
+ 0x2007, # FIGURE SPACE
+ 0x2008, # PUNCTUATION SPACE
+ 0x2009, # THIN SPACE
+ 0x200A, # HAIR SPACE
+ 0x2028, # Line separator
+ 0x2029, # Paragraph separator
+ 0x202F, # NARROW NO-BREAK SPACE
+ 0x205F, # MEDIUM MATHEMATICAL SPACE
+ 0x3000, # IDEOGRAPHIC SPACE
+ 0xFEFF, # Byte order mark
+ )
+ else:
+ return c in (
+ NO_EXTRA_DATA,
+ )
+
+
+cdef boolean _is_pc(uint32_t c) nogil:
+ # http://www.fileformat.info/info/unicode/category/Pc/list.htm
+ if expect(c <= 0x00FF, True):
+ return c in (
+ 0x005F, # LOW LINE
+ )
+ elif expect(c <= 0xFFFF, True):
+ return c in (
+ 0x203F, # UNDERTIE
+ 0x2040, # CHARACTER TIE
+ 0x2054, # INVERTED UNDERTIE
+ 0xFE33, # PRESENTATION FORM FOR VERTICAL LOW LINE
+ 0xFE34, # PRESENTATION FORM FOR VERTICAL WAVY LOW LINE
+ 0xFE4D, # DASHED LOW LINE
+ 0xFE4E, # CENTRELINE LOW LINE
+ 0xFE4F, # WAVY LOW LINE
+ 0xFF3F, # FULLWIDTH LOW LINE
+ )
+ else:
+ return False
+
+
+cdef boolean _is_identifier_start(uint32_t c) nogil:
+ return (
+ (b'A' <= c <= b'Z') or
+ (b'a' <= c <= b'z') or
+ (c in b'$_') or
+ Py_UNICODE_ISALPHA(c) or
+ False
+ )
+
+
+cdef boolean _is_identifier_part(uint32_t c) nogil:
+ return (
+ # IdentifierStart
+ _is_identifier_start(c) or
+ # UnicodeCombiningMark
+ _is_mn(c) or
+ _is_mc(c) or
+ # UnicodeDigit
+ Py_UNICODE_ISDIGIT(c) or
+ # UnicodeConnectorPunctuation
+ _is_pc(c) or
+ # ZWNJ and ZWJ
+ (c in (0x200C, 0x200D)) or
+ False
+ )
+
+
+cdef inline boolean _is_x(uint32_t c) nogil:
+ return (c | 0x20) == b'x'
+
+cdef inline boolean _is_e(uint32_t c) nogil:
+ return (c | 0x20) == b'e'
+
+cdef inline boolean _is_decimal(uint32_t c) nogil:
+ return b'0' <= c <= b'9'
+
+cdef inline boolean _is_hex(uint32_t c) nogil:
+ return b'a' <= (c | 0x20) <= b'f'
+
+cdef inline boolean _is_hexadecimal(uint32_t c) nogil:
+ return _is_decimal(c) or _is_hex(c)
+
+cdef boolean _is_in_float_representation(uint32_t c) nogil:
+ if _is_decimal(c):
+ return True
+ if _is_e(c):
+ return True
+ elif c in b'.+-':
+ return True
+ else:
+ return False
diff --git a/src/_unicode_mc.pyx b/src/_unicode_mc.pyx
new file mode 100644
index 0000000..af5b9d6
--- /dev/null
+++ b/src/_unicode_mc.pyx
@@ -0,0 +1,172 @@
+# http://www.fileformat.info/info/unicode/category/Mc/list.htm
+cdef boolean _is_mc(uint32_t c) nogil:
+ if expect(c <= 0x00FF, True):
+ return False
+ elif expect(c <= 0xFFFF, True):
+ return (
+ (c == 0x00000903) or
+ (c == 0x0000093b) or
+ (0x0000093e <= c and c <= 0x00000940) or
+ (0x00000949 <= c and c <= 0x0000094c) or
+ (0x0000094e <= c and c <= 0x0000094f) or
+ (0x00000982 <= c and c <= 0x00000983) or
+ (0x000009be <= c and c <= 0x000009c0) or
+ (0x000009c7 <= c and c <= 0x000009c8) or
+ (0x000009cb <= c and c <= 0x000009cc) or
+ (c == 0x000009d7) or
+ (c == 0x00000a03) or
+ (0x00000a3e <= c and c <= 0x00000a40) or
+ (c == 0x00000a83) or
+ (0x00000abe <= c and c <= 0x00000ac0) or
+ (c == 0x00000ac9) or
+ (0x00000acb <= c and c <= 0x00000acc) or
+ (0x00000b02 <= c and c <= 0x00000b03) or
+ (c == 0x00000b3e) or
+ (c == 0x00000b40) or
+ (0x00000b47 <= c and c <= 0x00000b48) or
+ (0x00000b4b <= c and c <= 0x00000b4c) or
+ (c == 0x00000b57) or
+ (0x00000bbe <= c and c <= 0x00000bbf) or
+ (0x00000bc1 <= c and c <= 0x00000bc2) or
+ (0x00000bc6 <= c and c <= 0x00000bc8) or
+ (0x00000bca <= c and c <= 0x00000bcc) or
+ (c == 0x00000bd7) or
+ (0x00000c01 <= c and c <= 0x00000c03) or
+ (0x00000c41 <= c and c <= 0x00000c44) or
+ (0x00000c82 <= c and c <= 0x00000c83) or
+ (c == 0x00000cbe) or
+ (0x00000cc0 <= c and c <= 0x00000cc4) or
+ (0x00000cc7 <= c and c <= 0x00000cc8) or
+ (0x00000cca <= c and c <= 0x00000ccb) or
+ (0x00000cd5 <= c and c <= 0x00000cd6) or
+ (0x00000d02 <= c and c <= 0x00000d03) or
+ (0x00000d3e <= c and c <= 0x00000d40) or
+ (0x00000d46 <= c and c <= 0x00000d48) or
+ (0x00000d4a <= c and c <= 0x00000d4c) or
+ (c == 0x00000d57) or
+ (0x00000d82 <= c and c <= 0x00000d83) or
+ (0x00000dcf <= c and c <= 0x00000dd1) or
+ (0x00000dd8 <= c and c <= 0x00000ddf) or
+ (0x00000df2 <= c and c <= 0x00000df3) or
+ (0x00000f3e <= c and c <= 0x00000f3f) or
+ (c == 0x00000f7f) or
+ False
+ )
+ else:
+ return (
+ (0x0000102b <= c and c <= 0x0000102c) or
+ (c == 0x00001031) or
+ (c == 0x00001038) or
+ (0x0000103b <= c and c <= 0x0000103c) or
+ (0x00001056 <= c and c <= 0x00001057) or
+ (0x00001062 <= c and c <= 0x00001064) or
+ (0x00001067 <= c and c <= 0x0000106d) or
+ (0x00001083 <= c and c <= 0x00001084) or
+ (0x00001087 <= c and c <= 0x0000108c) or
+ (c == 0x0000108f) or
+ (0x0000109a <= c and c <= 0x0000109c) or
+ (c == 0x000017b6) or
+ (0x000017be <= c and c <= 0x000017c5) or
+ (0x000017c7 <= c and c <= 0x000017c8) or
+ (0x00001923 <= c and c <= 0x00001926) or
+ (0x00001929 <= c and c <= 0x0000192b) or
+ (0x00001930 <= c and c <= 0x00001931) or
+ (0x00001933 <= c and c <= 0x00001938) or
+ (0x00001a19 <= c and c <= 0x00001a1a) or
+ (c == 0x00001a55) or
+ (c == 0x00001a57) or
+ (c == 0x00001a61) or
+ (0x00001a63 <= c and c <= 0x00001a64) or
+ (0x00001a6d <= c and c <= 0x00001a72) or
+ (c == 0x00001b04) or
+ (c == 0x00001b35) or
+ (c == 0x00001b3b) or
+ (0x00001b3d <= c and c <= 0x00001b41) or
+ (0x00001b43 <= c and c <= 0x00001b44) or
+ (c == 0x00001b82) or
+ (c == 0x00001ba1) or
+ (0x00001ba6 <= c and c <= 0x00001ba7) or
+ (c == 0x00001baa) or
+ (c == 0x00001be7) or
+ (0x00001bea <= c and c <= 0x00001bec) or
+ (c == 0x00001bee) or
+ (0x00001bf2 <= c and c <= 0x00001bf3) or
+ (0x00001c24 <= c and c <= 0x00001c2b) or
+ (0x00001c34 <= c and c <= 0x00001c35) or
+ (c == 0x00001ce1) or
+ (0x00001cf2 <= c and c <= 0x00001cf3) or
+ (c == 0x00001cf7) or
+ (0x0000302e <= c and c <= 0x0000302f) or
+ (0x0000a823 <= c and c <= 0x0000a824) or
+ (c == 0x0000a827) or
+ (0x0000a880 <= c and c <= 0x0000a881) or
+ (0x0000a8b4 <= c and c <= 0x0000a8c3) or
+ (0x0000a952 <= c and c <= 0x0000a953) or
+ (c == 0x0000a983) or
+ (0x0000a9b4 <= c and c <= 0x0000a9b5) or
+ (0x0000a9ba <= c and c <= 0x0000a9bb) or
+ (0x0000a9bd <= c and c <= 0x0000a9c0) or
+ (0x0000aa2f <= c and c <= 0x0000aa30) or
+ (0x0000aa33 <= c and c <= 0x0000aa34) or
+ (c == 0x0000aa4d) or
+ (c == 0x0000aa7b) or
+ (c == 0x0000aa7d) or
+ (c == 0x0000aaeb) or
+ (0x0000aaee <= c and c <= 0x0000aaef) or
+ (c == 0x0000aaf5) or
+ (0x0000abe3 <= c and c <= 0x0000abe4) or
+ (0x0000abe6 <= c and c <= 0x0000abe7) or
+ (0x0000abe9 <= c and c <= 0x0000abea) or
+ (c == 0x0000abec) or
+ (c == 0x00011000) or
+ (c == 0x00011002) or
+ (c == 0x00011082) or
+ (0x000110b0 <= c and c <= 0x000110b2) or
+ (0x000110b7 <= c and c <= 0x000110b8) or
+ (c == 0x0001112c) or
+ (c == 0x00011182) or
+ (0x000111b3 <= c and c <= 0x000111b5) or
+ (0x000111bf <= c and c <= 0x000111c0) or
+ (0x0001122c <= c and c <= 0x0001122e) or
+ (0x00011232 <= c and c <= 0x00011233) or
+ (c == 0x00011235) or
+ (0x000112e0 <= c and c <= 0x000112e2) or
+ (0x00011302 <= c and c <= 0x00011303) or
+ (0x0001133e <= c and c <= 0x0001133f) or
+ (0x00011341 <= c and c <= 0x00011344) or
+ (0x00011347 <= c and c <= 0x00011348) or
+ (0x0001134b <= c and c <= 0x0001134d) or
+ (c == 0x00011357) or
+ (0x00011362 <= c and c <= 0x00011363) or
+ (0x00011435 <= c and c <= 0x00011437) or
+ (0x00011440 <= c and c <= 0x00011441) or
+ (c == 0x00011445) or
+ (0x000114b0 <= c and c <= 0x000114b2) or
+ (c == 0x000114b9) or
+ (0x000114bb <= c and c <= 0x000114be) or
+ (c == 0x000114c1) or
+ (0x000115af <= c and c <= 0x000115b1) or
+ (0x000115b8 <= c and c <= 0x000115bb) or
+ (c == 0x000115be) or
+ (0x00011630 <= c and c <= 0x00011632) or
+ (0x0001163b <= c and c <= 0x0001163c) or
+ (c == 0x0001163e) or
+ (c == 0x000116ac) or
+ (0x000116ae <= c and c <= 0x000116af) or
+ (c == 0x000116b6) or
+ (0x00011720 <= c and c <= 0x00011721) or
+ (c == 0x00011726) or
+ (0x00011a07 <= c and c <= 0x00011a08) or
+ (c == 0x00011a39) or
+ (0x00011a57 <= c and c <= 0x00011a58) or
+ (c == 0x00011a97) or
+ (c == 0x00011c2f) or
+ (c == 0x00011c3e) or
+ (c == 0x00011ca9) or
+ (c == 0x00011cb1) or
+ (c == 0x00011cb4) or
+ (0x00016f51 <= c and c <= 0x00016f7e) or
+ (0x0001d165 <= c and c <= 0x0001d166) or
+ (0x0001d16d <= c and c <= 0x0001d172) or
+ False
+ )
diff --git a/src/_unicode_mn.pyx b/src/_unicode_mn.pyx
new file mode 100644
index 0000000..c25a354
--- /dev/null
+++ b/src/_unicode_mn.pyx
@@ -0,0 +1,330 @@
+# ranges = []
+# last = -2
+# for x in xx:
+# if x == last + 1:
+# ranges[-1][1] = x
+# else:
+# ranges.append([x, x])
+# last = x
+#
+# p = ' (\n'
+# for start, end in ranges:
+# if start < end:
+# p += f' (0x{start:08x} <= c and c <= 0x{end:08x}) or\n'
+# else:
+# p += f' (c == 0x{start:08x}) or\n'
+# p += ' False\n )\n'
+#
+
+# http://www.fileformat.info/info/unicode/category/Mn/list.htm
+cdef boolean _is_mn(uint32_t c) nogil:
+ if expect(c <= 0x00FF, True):
+ return False
+ elif expect(c <= 0xFFFF, True):
+ return (
+ (0x00000300 <= c and c <= 0x0000036f) or
+ (0x00000483 <= c and c <= 0x00000487) or
+ (0x00000591 <= c and c <= 0x000005bd) or
+ (c == 0x000005bf) or
+ (0x000005c1 <= c and c <= 0x000005c2) or
+ (0x000005c4 <= c and c <= 0x000005c5) or
+ (c == 0x000005c7) or
+ (0x00000610 <= c and c <= 0x0000061a) or
+ (0x0000064b <= c and c <= 0x0000065f) or
+ (c == 0x00000670) or
+ (0x000006d6 <= c and c <= 0x000006dc) or
+ (0x000006df <= c and c <= 0x000006e4) or
+ (0x000006e7 <= c and c <= 0x000006e8) or
+ (0x000006ea <= c and c <= 0x000006ed) or
+ (c == 0x00000711) or
+ (0x00000730 <= c and c <= 0x0000074a) or
+ (0x000007a6 <= c and c <= 0x000007b0) or
+ (0x000007eb <= c and c <= 0x000007f3) or
+ (0x00000816 <= c and c <= 0x00000819) or
+ (0x0000081b <= c and c <= 0x00000823) or
+ (0x00000825 <= c and c <= 0x00000827) or
+ (0x00000829 <= c and c <= 0x0000082d) or
+ (0x00000859 <= c and c <= 0x0000085b) or
+ (0x000008d4 <= c and c <= 0x000008e1) or
+ (0x000008e3 <= c and c <= 0x00000902) or
+ (c == 0x0000093a) or
+ (c == 0x0000093c) or
+ (0x00000941 <= c and c <= 0x00000948) or
+ (c == 0x0000094d) or
+ (0x00000951 <= c and c <= 0x00000957) or
+ (0x00000962 <= c and c <= 0x00000963) or
+ (c == 0x00000981) or
+ (c == 0x000009bc) or
+ (0x000009c1 <= c and c <= 0x000009c4) or
+ (c == 0x000009cd) or
+ (0x000009e2 <= c and c <= 0x000009e3) or
+ (0x00000a01 <= c and c <= 0x00000a02) or
+ (c == 0x00000a3c) or
+ (0x00000a41 <= c and c <= 0x00000a42) or
+ (0x00000a47 <= c and c <= 0x00000a48) or
+ (0x00000a4b <= c and c <= 0x00000a4d) or
+ (c == 0x00000a51) or
+ (0x00000a70 <= c and c <= 0x00000a71) or
+ (0x00000a81 <= c and c <= 0x00000a82) or
+ (c == 0x00000abc) or
+ (0x00000ac1 <= c and c <= 0x00000ac5) or
+ (0x00000ac7 <= c and c <= 0x00000ac8) or
+ (c == 0x00000acd) or
+ (0x00000ae2 <= c and c <= 0x00000ae3) or
+ (0x00000afa <= c and c <= 0x00000aff) or
+ (c == 0x00000b01) or
+ (c == 0x00000b3c) or
+ (c == 0x00000b3f) or
+ (0x00000b41 <= c and c <= 0x00000b44) or
+ (c == 0x00000b4d) or
+ (c == 0x00000b56) or
+ (0x00000b62 <= c and c <= 0x00000b63) or
+ (c == 0x00000b82) or
+ (c == 0x00000bc0) or
+ (c == 0x00000bcd) or
+ (c == 0x00000c00) or
+ (0x00000c3e <= c and c <= 0x00000c40) or
+ (0x00000c46 <= c and c <= 0x00000c48) or
+ (0x00000c4a <= c and c <= 0x00000c4d) or
+ (0x00000c55 <= c and c <= 0x00000c56) or
+ (0x00000c62 <= c and c <= 0x00000c63) or
+ (c == 0x00000c81) or
+ (c == 0x00000cbc) or
+ (c == 0x00000cbf) or
+ (c == 0x00000cc6) or
+ (0x00000ccc <= c and c <= 0x00000ccd) or
+ (0x00000ce2 <= c and c <= 0x00000ce3) or
+ (0x00000d00 <= c and c <= 0x00000d01) or
+ (0x00000d3b <= c and c <= 0x00000d3c) or
+ (0x00000d41 <= c and c <= 0x00000d44) or
+ (c == 0x00000d4d) or
+ (0x00000d62 <= c and c <= 0x00000d63) or
+ (c == 0x00000dca) or
+ (0x00000dd2 <= c and c <= 0x00000dd4) or
+ (c == 0x00000dd6) or
+ (c == 0x00000e31) or
+ (0x00000e34 <= c and c <= 0x00000e3a) or
+ (0x00000e47 <= c and c <= 0x00000e4e) or
+ (c == 0x00000eb1) or
+ (0x00000eb4 <= c and c <= 0x00000eb9) or
+ (0x00000ebb <= c and c <= 0x00000ebc) or
+ (0x00000ec8 <= c and c <= 0x00000ecd) or
+ (0x00000f18 <= c and c <= 0x00000f19) or
+ (c == 0x00000f35) or
+ (c == 0x00000f37) or
+ (c == 0x00000f39) or
+ (0x00000f71 <= c and c <= 0x00000f7e) or
+ (0x00000f80 <= c and c <= 0x00000f84) or
+ (0x00000f86 <= c and c <= 0x00000f87) or
+ (0x00000f8d <= c and c <= 0x00000f97) or
+ (0x00000f99 <= c and c <= 0x00000fbc) or
+ (c == 0x00000fc6) or
+ False
+ )
+ else:
+ return (
+ (0x0000102d <= c and c <= 0x00001030) or
+ (0x00001032 <= c and c <= 0x00001037) or
+ (0x00001039 <= c and c <= 0x0000103a) or
+ (0x0000103d <= c and c <= 0x0000103e) or
+ (0x00001058 <= c and c <= 0x00001059) or
+ (0x0000105e <= c and c <= 0x00001060) or
+ (0x00001071 <= c and c <= 0x00001074) or
+ (c == 0x00001082) or
+ (0x00001085 <= c and c <= 0x00001086) or
+ (c == 0x0000108d) or
+ (c == 0x0000109d) or
+ (0x0000135d <= c and c <= 0x0000135f) or
+ (0x00001712 <= c and c <= 0x00001714) or
+ (0x00001732 <= c and c <= 0x00001734) or
+ (0x00001752 <= c and c <= 0x00001753) or
+ (0x00001772 <= c and c <= 0x00001773) or
+ (0x000017b4 <= c and c <= 0x000017b5) or
+ (0x000017b7 <= c and c <= 0x000017bd) or
+ (c == 0x000017c6) or
+ (0x000017c9 <= c and c <= 0x000017d3) or
+ (c == 0x000017dd) or
+ (0x0000180b <= c and c <= 0x0000180d) or
+ (0x00001885 <= c and c <= 0x00001886) or
+ (c == 0x000018a9) or
+ (0x00001920 <= c and c <= 0x00001922) or
+ (0x00001927 <= c and c <= 0x00001928) or
+ (c == 0x00001932) or
+ (0x00001939 <= c and c <= 0x0000193b) or
+ (0x00001a17 <= c and c <= 0x00001a18) or
+ (c == 0x00001a1b) or
+ (c == 0x00001a56) or
+ (0x00001a58 <= c and c <= 0x00001a5e) or
+ (c == 0x00001a60) or
+ (c == 0x00001a62) or
+ (0x00001a65 <= c and c <= 0x00001a6c) or
+ (0x00001a73 <= c and c <= 0x00001a7c) or
+ (c == 0x00001a7f) or
+ (0x00001ab0 <= c and c <= 0x00001abd) or
+ (0x00001b00 <= c and c <= 0x00001b03) or
+ (c == 0x00001b34) or
+ (0x00001b36 <= c and c <= 0x00001b3a) or
+ (c == 0x00001b3c) or
+ (c == 0x00001b42) or
+ (0x00001b6b <= c and c <= 0x00001b73) or
+ (0x00001b80 <= c and c <= 0x00001b81) or
+ (0x00001ba2 <= c and c <= 0x00001ba5) or
+ (0x00001ba8 <= c and c <= 0x00001ba9) or
+ (0x00001bab <= c and c <= 0x00001bad) or
+ (c == 0x00001be6) or
+ (0x00001be8 <= c and c <= 0x00001be9) or
+ (c == 0x00001bed) or
+ (0x00001bef <= c and c <= 0x00001bf1) or
+ (0x00001c2c <= c and c <= 0x00001c33) or
+ (0x00001c36 <= c and c <= 0x00001c37) or
+ (0x00001cd0 <= c and c <= 0x00001cd2) or
+ (0x00001cd4 <= c and c <= 0x00001ce0) or
+ (0x00001ce2 <= c and c <= 0x00001ce8) or
+ (c == 0x00001ced) or
+ (c == 0x00001cf4) or
+ (0x00001cf8 <= c and c <= 0x00001cf9) or
+ (0x00001dc0 <= c and c <= 0x00001df9) or
+ (0x00001dfb <= c and c <= 0x00001dff) or
+ (0x000020d0 <= c and c <= 0x000020dc) or
+ (c == 0x000020e1) or
+ (0x000020e5 <= c and c <= 0x000020f0) or
+ (0x00002cef <= c and c <= 0x00002cf1) or
+ (c == 0x00002d7f) or
+ (0x00002de0 <= c and c <= 0x00002dff) or
+ (0x0000302a <= c and c <= 0x0000302d) or
+ (0x00003099 <= c and c <= 0x0000309a) or
+ (c == 0x0000a66f) or
+ (0x0000a674 <= c and c <= 0x0000a67d) or
+ (0x0000a69e <= c and c <= 0x0000a69f) or
+ (0x0000a6f0 <= c and c <= 0x0000a6f1) or
+ (c == 0x0000a802) or
+ (c == 0x0000a806) or
+ (c == 0x0000a80b) or
+ (0x0000a825 <= c and c <= 0x0000a826) or
+ (0x0000a8c4 <= c and c <= 0x0000a8c5) or
+ (0x0000a8e0 <= c and c <= 0x0000a8f1) or
+ (0x0000a926 <= c and c <= 0x0000a92d) or
+ (0x0000a947 <= c and c <= 0x0000a951) or
+ (0x0000a980 <= c and c <= 0x0000a982) or
+ (c == 0x0000a9b3) or
+ (0x0000a9b6 <= c and c <= 0x0000a9b9) or
+ (c == 0x0000a9bc) or
+ (c == 0x0000a9e5) or
+ (0x0000aa29 <= c and c <= 0x0000aa2e) or
+ (0x0000aa31 <= c and c <= 0x0000aa32) or
+ (0x0000aa35 <= c and c <= 0x0000aa36) or
+ (c == 0x0000aa43) or
+ (c == 0x0000aa4c) or
+ (c == 0x0000aa7c) or
+ (c == 0x0000aab0) or
+ (0x0000aab2 <= c and c <= 0x0000aab4) or
+ (0x0000aab7 <= c and c <= 0x0000aab8) or
+ (0x0000aabe <= c and c <= 0x0000aabf) or
+ (c == 0x0000aac1) or
+ (0x0000aaec <= c and c <= 0x0000aaed) or
+ (c == 0x0000aaf6) or
+ (c == 0x0000abe5) or
+ (c == 0x0000abe8) or
+ (c == 0x0000abed) or
+ (c == 0x0000fb1e) or
+ (0x0000fe00 <= c and c <= 0x0000fe0f) or
+ (0x0000fe20 <= c and c <= 0x0000fe2f) or
+ (c == 0x000101fd) or
+ (c == 0x000102e0) or
+ (0x00010376 <= c and c <= 0x0001037a) or
+ (0x00010a01 <= c and c <= 0x00010a03) or
+ (0x00010a05 <= c and c <= 0x00010a06) or
+ (0x00010a0c <= c and c <= 0x00010a0f) or
+ (0x00010a38 <= c and c <= 0x00010a3a) or
+ (c == 0x00010a3f) or
+ (0x00010ae5 <= c and c <= 0x00010ae6) or
+ (c == 0x00011001) or
+ (0x00011038 <= c and c <= 0x00011046) or
+ (0x0001107f <= c and c <= 0x00011081) or
+ (0x000110b3 <= c and c <= 0x000110b6) or
+ (0x000110b9 <= c and c <= 0x000110ba) or
+ (0x00011100 <= c and c <= 0x00011102) or
+ (0x00011127 <= c and c <= 0x0001112b) or
+ (0x0001112d <= c and c <= 0x00011134) or
+ (c == 0x00011173) or
+ (0x00011180 <= c and c <= 0x00011181) or
+ (0x000111b6 <= c and c <= 0x000111be) or
+ (0x000111ca <= c and c <= 0x000111cc) or
+ (0x0001122f <= c and c <= 0x00011231) or
+ (c == 0x00011234) or
+ (0x00011236 <= c and c <= 0x00011237) or
+ (c == 0x0001123e) or
+ (c == 0x000112df) or
+ (0x000112e3 <= c and c <= 0x000112ea) or
+ (0x00011300 <= c and c <= 0x00011301) or
+ (c == 0x0001133c) or
+ (c == 0x00011340) or
+ (0x00011366 <= c and c <= 0x0001136c) or
+ (0x00011370 <= c and c <= 0x00011374) or
+ (0x00011438 <= c and c <= 0x0001143f) or
+ (0x00011442 <= c and c <= 0x00011444) or
+ (c == 0x00011446) or
+ (0x000114b3 <= c and c <= 0x000114b8) or
+ (c == 0x000114ba) or
+ (0x000114bf <= c and c <= 0x000114c0) or
+ (0x000114c2 <= c and c <= 0x000114c3) or
+ (0x000115b2 <= c and c <= 0x000115b5) or
+ (0x000115bc <= c and c <= 0x000115bd) or
+ (0x000115bf <= c and c <= 0x000115c0) or
+ (0x000115dc <= c and c <= 0x000115dd) or
+ (0x00011633 <= c and c <= 0x0001163a) or
+ (c == 0x0001163d) or
+ (0x0001163f <= c and c <= 0x00011640) or
+ (c == 0x000116ab) or
+ (c == 0x000116ad) or
+ (0x000116b0 <= c and c <= 0x000116b5) or
+ (c == 0x000116b7) or
+ (0x0001171d <= c and c <= 0x0001171f) or
+ (0x00011722 <= c and c <= 0x00011725) or
+ (0x00011727 <= c and c <= 0x0001172b) or
+ (0x00011a01 <= c and c <= 0x00011a06) or
+ (0x00011a09 <= c and c <= 0x00011a0a) or
+ (0x00011a33 <= c and c <= 0x00011a38) or
+ (0x00011a3b <= c and c <= 0x00011a3e) or
+ (c == 0x00011a47) or
+ (0x00011a51 <= c and c <= 0x00011a56) or
+ (0x00011a59 <= c and c <= 0x00011a5b) or
+ (0x00011a8a <= c and c <= 0x00011a96) or
+ (0x00011a98 <= c and c <= 0x00011a99) or
+ (0x00011c30 <= c and c <= 0x00011c36) or
+ (0x00011c38 <= c and c <= 0x00011c3d) or
+ (c == 0x00011c3f) or
+ (0x00011c92 <= c and c <= 0x00011ca7) or
+ (0x00011caa <= c and c <= 0x00011cb0) or
+ (0x00011cb2 <= c and c <= 0x00011cb3) or
+ (0x00011cb5 <= c and c <= 0x00011cb6) or
+ (0x00011d31 <= c and c <= 0x00011d36) or
+ (c == 0x00011d3a) or
+ (0x00011d3c <= c and c <= 0x00011d3d) or
+ (0x00011d3f <= c and c <= 0x00011d45) or
+ (c == 0x00011d47) or
+ (0x00016af0 <= c and c <= 0x00016af4) or
+ (0x00016b30 <= c and c <= 0x00016b36) or
+ (0x00016f8f <= c and c <= 0x00016f92) or
+ (0x0001bc9d <= c and c <= 0x0001bc9e) or
+ (0x0001d167 <= c and c <= 0x0001d169) or
+ (0x0001d17b <= c and c <= 0x0001d182) or
+ (0x0001d185 <= c and c <= 0x0001d18b) or
+ (0x0001d1aa <= c and c <= 0x0001d1ad) or
+ (0x0001d242 <= c and c <= 0x0001d244) or
+ (0x0001da00 <= c and c <= 0x0001da36) or
+ (0x0001da3b <= c and c <= 0x0001da6c) or
+ (c == 0x0001da75) or
+ (c == 0x0001da84) or
+ (0x0001da9b <= c and c <= 0x0001da9f) or
+ (0x0001daa1 <= c and c <= 0x0001daaf) or
+ (0x0001e000 <= c and c <= 0x0001e006) or
+ (0x0001e008 <= c and c <= 0x0001e018) or
+ (0x0001e01b <= c and c <= 0x0001e021) or
+ (0x0001e023 <= c and c <= 0x0001e024) or
+ (0x0001e026 <= c and c <= 0x0001e02a) or
+ (0x0001e8d0 <= c and c <= 0x0001e8d6) or
+ (0x0001e944 <= c and c <= 0x0001e94a) or
+ (0x000e0100 <= c and c <= 0x000e01ef) or
+ False
+ )
diff --git a/src/_writer_callback.pyx b/src/_writer_callback.pyx
new file mode 100644
index 0000000..ebe5de6
--- /dev/null
+++ b/src/_writer_callback.pyx
@@ -0,0 +1,41 @@
+cdef struct WriterCallback:
+ Writer base
+ PyObject *callback
+
+
+cdef boolean _WriterCbBytes_append_c(Writer &writer_, char datum) except False:
+ cdef WriterCallback *writer = <WriterCallback*> &writer_
+
+ CallFunction(writer.callback, b'c', datum)
+
+ return True
+
+
+cdef boolean _WriterCbBytes_append_s(Writer &writer_, const char *s, Py_ssize_t length) except False:
+ cdef WriterCallback *writer = <WriterCallback*> &writer_
+
+ if expect(length <= 0, False):
+ return True
+
+ CallFunction(writer.callback, b'y#', s, <int> length)
+
+ return True
+
+
+cdef boolean _WriterCbStr_append_c(Writer &writer_, char datum) except False:
+ cdef WriterCallback *writer = <WriterCallback*> &writer_
+
+ CallFunction(writer.callback, b'C', datum)
+
+ return True
+
+
+cdef boolean _WriterCbStr_append_s(Writer &writer_, const char *s, Py_ssize_t length) except False:
+ cdef WriterCallback *writer = <WriterCallback*> &writer_
+
+ if expect(length <= 0, False):
+ return True
+
+ CallFunction(writer.callback, b'U#', s, <int> length)
+
+ return True
diff --git a/src/_writer_noop.pyx b/src/_writer_noop.pyx
new file mode 100644
index 0000000..3f4528b
--- /dev/null
+++ b/src/_writer_noop.pyx
@@ -0,0 +1,15 @@
+cdef struct WriterNoop:
+ Writer base
+
+
+cdef boolean _WriterNoop_reserve(WriterRef writer_, size_t amount) except False:
+ return True
+
+
+cdef boolean _WriterNoop_append_c(Writer &writer_, char datum) except False:
+ return True
+
+
+cdef boolean _WriterNoop_append_s(Writer &writer_, const char *s,
+ Py_ssize_t length) except False:
+ return True
diff --git a/src/_writer_reallocatable.pyx b/src/_writer_reallocatable.pyx
new file mode 100644
index 0000000..15bd3cd
--- /dev/null
+++ b/src/_writer_reallocatable.pyx
@@ -0,0 +1,61 @@
+cdef struct WriterReallocatable:
+ Writer base
+ size_t position
+ size_t length
+ void *obj
+
+
+cdef boolean _WriterReallocatable_reserve(WriterRef writer_, size_t amount) except False:
+ cdef size_t current_size
+ cdef size_t needed_size
+ cdef size_t new_size
+ cdef void *temp
+ cdef WriterReallocatable *writer = <WriterReallocatable*> &writer_
+
+ if expect(amount <= 0, False):
+ return True
+
+ needed_size = writer.position + amount
+ current_size = writer.length
+ if expect(needed_size < current_size, True):
+ return True
+
+ new_size = current_size
+ while new_size <= needed_size:
+ new_size = (new_size + 32) + (new_size // 4)
+ if expect(new_size < current_size, False):
+ ErrNoMemory()
+
+ temp = ObjectRealloc(writer.obj, new_size + 1)
+ if temp is NULL:
+ ErrNoMemory()
+
+ writer.obj = temp
+ writer.length = new_size
+
+ return True
+
+
+cdef boolean _WriterReallocatable_append_c(Writer &writer_, char datum) except False:
+ cdef WriterReallocatable *writer = <WriterReallocatable*> &writer_
+
+ _WriterReallocatable_reserve(writer.base, 1)
+ (<char*> writer.obj)[writer.position] = datum
+ writer.position += 1
+
+ return True
+
+
+cdef boolean _WriterReallocatable_append_s(Writer &writer_, const char *s, Py_ssize_t length) except False:
+ cdef WriterReallocatable *writer = <WriterReallocatable*> &writer_
+
+ if expect(length <= 0, False):
+ return True
+
+ _WriterReallocatable_reserve(writer.base, length)
+ memcpy(&(<char*> writer.obj)[writer.position], s, length)
+ writer.position += length
+
+ return True
+
+
diff --git a/src/_writers.pyx b/src/_writers.pyx
new file mode 100644
index 0000000..a64354b
--- /dev/null
+++ b/src/_writers.pyx
@@ -0,0 +1,8 @@
+cdef struct Writer:
+ boolean (*reserve)(Writer &writer, size_t amount) except False
+ boolean (*append_c)(Writer &writer, char datum) except False
+ boolean (*append_s)(Writer &writer, const char *s, Py_ssize_t length) except False
+ PyObject *options
+
+
+ctypedef Writer &WriterRef
diff --git a/src/native.hpp b/src/native.hpp
new file mode 100644
index 0000000..b608265
--- /dev/null
+++ b/src/native.hpp
@@ -0,0 +1,147 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <type_traits>
+
+namespace JSON5EncoderCpp {
+inline namespace {
+
+template <class From>
+constexpr std::uint32_t cast_to_uint32(
+ const From &unsigned_from,
+ typename std::enable_if<
+ !std::is_signed<From>::value
+ >::type* = nullptr
+) {
+ return static_cast<std::uint32_t>(unsigned_from);
+}
+
+template <class From>
+constexpr std::uint32_t cast_to_uint32(
+ const From &from,
+ typename std::enable_if<
+ std::is_signed<From>::value
+ >::type* = nullptr
+) {
+ using UnsignedFrom = typename std::make_unsigned<From>::type;
+ UnsignedFrom unsigned_from = static_cast<UnsignedFrom>(from);
+ return cast_to_uint32(unsigned_from);
+}
+
+template <class From>
+constexpr std::int32_t cast_to_int32(const From &from) {
+ std::uint32_t unsigned_from = cast_to_uint32(from);
+ return static_cast<std::int32_t>(unsigned_from);
+}
+
+struct AlwaysTrue {
+ constexpr inline AlwaysTrue() = default;
+ inline ~AlwaysTrue() = default;
+
+ constexpr inline AlwaysTrue(const AlwaysTrue&) = default;
+ constexpr inline AlwaysTrue(AlwaysTrue&&) = default;
+ constexpr inline AlwaysTrue &operator =(const AlwaysTrue&) = default;
+ constexpr inline AlwaysTrue &operator =(AlwaysTrue&&) = default;
+
+ template <class T>
+ constexpr inline AlwaysTrue(T&&) : AlwaysTrue() {}
+
+ template <class T>
+ constexpr inline bool operator ==(T&&) const { return true; }
+
+ constexpr inline operator bool () const { return true; }
+};
+
+bool obj_has_iter(const PyObject *obj) {
+ auto *i = Py_TYPE(obj)->tp_iter;
+ return (i != nullptr) && (i != &_PyObject_NextNotImplemented);
+}
+
+struct EscapeDct {
+ using Item = std::array<char, 8>; // 7 are needed, 1 length
+ static constexpr std::size_t length = 0x10000;
+
+ Item items[length];
+ unsigned __int128 is_escaped_array;
+
+ static constexpr Item unicode_item(size_t index) {
+ constexpr char HEX[] = "0123456789abcdef";
+ return {{
+ '\\',
+ 'u',
+ HEX[(index / 16 / 16 / 16 % 16)],
+ HEX[(index / 16 / 16 % 16)],
+ HEX[(index / 16 % 16)],
+ HEX[(index % 16)],
+ 0,
+ 6,
+ }};
+ }
+
+ static constexpr Item escaped_item(char chr) {
+ return {{ '\\', chr, 0, 0, 0, 0, 0, 2 }};
+ }
+
+ static constexpr Item verbatim_item(size_t chr) {
+ return {{ (char) (unsigned char) chr, 0, 0, 0, 0, 0, 0, 1 }};
+ }
+
+ inline bool is_escaped(uint32_t c) const {
+ return (c >= 0x0080) || (is_escaped_array & (
+ static_cast<unsigned __int128>(1) <<
+ static_cast<std::uint8_t>(c)
+ ));
+ }
+
+ inline std::size_t find_unescaped_range(const char *start, Py_ssize_t length) const {
+ Py_ssize_t index = 0;
+ while ((index < length) && !is_escaped(start[index])) {
+ ++index;
+ }
+ return index;
+ }
+
+ constexpr EscapeDct() :
+ items(),
+ is_escaped_array(static_cast<unsigned __int128>(0) - 1)
+ {
+ for (std::size_t i = 0; i < length; ++i) {
+ items[i] = unicode_item(i);
+ }
+ for (std::size_t i = 0x20; i < 0x7f; ++i) {
+ switch (i) {
+ case '"': case '\'': case '&': case '<': case '>': case '\\':
+ break;
+ default:
+ items[i] = verbatim_item(i);
+
+ is_escaped_array &= ~(
+ static_cast<unsigned __int128>(1) <<
+ static_cast<std::uint8_t>(i)
+ );
+ }
+ }
+ items[(uint8_t) '\\'] = escaped_item('\\');
+ items[(uint8_t) '\b'] = escaped_item('b');
+ items[(uint8_t) '\f'] = escaped_item('f');
+ items[(uint8_t) '\n'] = escaped_item('n');
+ items[(uint8_t) '\r'] = escaped_item('r');
+ items[(uint8_t) '\t'] = escaped_item('t');
+ }
+};
+
+const EscapeDct ESCAPE_DCT;
+
+const char VERSION[] =
+# include "./VERSION"
+;
+static constexpr std::size_t VERSION_LENGTH = sizeof(VERSION) - 1;
+
+const char LONGDESCRIPTION[] =
+# include "./VERSION"
+;
+static constexpr std::size_t LONGDESCRIPTION_LENGTH = sizeof(LONGDESCRIPTION) - 1;
+
+}
+}
