Added Value::findType with String key (#1574)

This adds a convenience function to return a member if it has a specific
json type. All isType values are supported.

Co-authored-by: Jordan Bayles <bayles.jordan@gmail.com>

.clang-format

@@ -1,4 +1,4 @@
 BasedOnStyle:  LLVM
 DerivePointerAlignment: false
 PointerAlignment: Left
-
+SpacesBeforeTrailingComments: 1

.github/workflows/clang-format.yml

@@ -0,0 +1,20 @@
+name: clang-format check
+on: [check_run, pull_request, push]
+
+jobs:
+  formatting-check:
+    name: formatting check
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        path:
+          - 'src'
+          - 'examples'
+          - 'include'
+    steps:
+    - uses: actions/checkout@v4
+    - name: runs clang-format style check for C/C++/Protobuf programs.
+      uses: jidicula/clang-format-action@v4.13.0
+      with:
+        clang-format-version: '18'
+        check-path: ${{ matrix.path }}

.github/workflows/cmake.yml

@@ -0,0 +1,18 @@
+name: cmake
+on: [check_run, push, pull_request]
+jobs:
+  cmake-publish:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        
+    steps:
+      - name: checkout project
+        uses: actions/checkout@v4
+
+      - name: build project
+        uses: threeal/cmake-action@v2.0.0
+        

.github/workflows/meson.yml

@@ -0,0 +1,65 @@
+name: meson build and test
+run-name: update pushed to ${{ github.ref }}
+on: [check_run, push, pull_request]
+
+jobs:
+  meson-publish:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:     
+      - name: checkout repository
+        uses: actions/checkout@v4
+        
+      - name: setup python
+        uses: actions/setup-python@v5
+      
+      - name: meson build
+        uses: BSFishy/meson-build@v1.0.3
+        with:
+          meson-version: 1.5.1
+          ninja-version: 1.11.1.1
+          action: build
+  
+      - name: meson test
+        uses: BSFishy/meson-build@v1.0.3
+        with:
+          meson-version: 1.5.1
+          ninja-version: 1.11.1.1
+          action: test
+
+  meson-coverage:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+        
+      - name: setup python
+        uses: actions/setup-python@v5
+      
+      - name: meson build
+        uses: BSFishy/meson-build@v1.0.3
+        with:
+          meson-version: 1.5.1
+          ninja-version: 1.11.1.1
+          setup-options: -Db_coverage=true
+          action: build 
+  
+      - name: meson test
+        uses: BSFishy/meson-build@v1.0.3
+        with:
+          meson-version: 1.5.1
+          ninja-version: 1.11.1.1
+          setup-options: -Db_coverage=true
+          action: test
+
+      - name: generate code coverage report
+        uses: threeal/gcovr-action@v1.0.0
+        with:
+          coveralls-send: true
+          github-token: ${{ secrets.GITHUB_TOKEN }}

.travis.yml

@@ -1,71 +0,0 @@
-# Build matrix / environment variables are explained on:
-# http://about.travis-ci.com/docs/user/build-configuration/
-# This file can be validated on: http://www.yamllint.com/
-# Or using the Ruby based travel command line tool:
-# gem install travis --no-rdoc --no-ri
-# travis lint .travis.yml
-language: cpp
-sudo: false
-addons:
-  homebrew:
-    packages:
-    - clang-format
-    - meson
-    - ninja
-    update: false # do not update homebrew by default
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    - llvm-toolchain-xenial-8
-    packages:
-    - clang-format-8
-    - clang-8
-    - valgrind
-matrix:
-  include:
-    - name: Mac clang meson static release testing
-      os: osx
-      osx_image: xcode11
-      compiler: clang
-      env:
-         CXX="clang++"
-         CC="clang"
-         LIB_TYPE=static
-         BUILD_TYPE=release
-      script: ./.travis_scripts/meson_builder.sh
-    - name: Linux xenial clang meson static release testing
-      os: linux
-      dist: xenial
-      compiler: clang
-      env:
-         CXX="clang++"
-         CC="clang"
-         LIB_TYPE=static
-         BUILD_TYPE=release
-         PYTHONUSERBASE="$(pwd)/LOCAL"
-         PATH="$PYTHONUSERBASE/bin:$PATH"
-      # before_install and install steps only needed for linux meson builds
-      before_install:
-          - source ./.travis_scripts/travis.before_install.${TRAVIS_OS_NAME}.sh
-      install:
-           - source ./.travis_scripts/travis.install.${TRAVIS_OS_NAME}.sh
-      script: ./.travis_scripts/meson_builder.sh
-    - name: Linux xenial gcc cmake coverage
-      os: linux
-      dist: xenial
-      compiler: gcc
-      env:
-        CXX=g++
-        CC=gcc
-        DO_Coverage=ON
-        BUILD_TOOL="Unix Makefiles"
-        BUILD_TYPE=Debug
-        LIB_TYPE=shared
-        DESTDIR=/tmp/cmake_json_cpp
-      before_install:
-          - pip install --user cpp-coveralls
-      script: ./.travis_scripts/cmake_builder.sh
-      after_success:
-          - coveralls --include src/lib_json --include include
-notifications:
-  email: false

.travis_scripts/cmake_builder.sh

@@ -1,130 +0,0 @@
-#!/usr/bin/env sh
-# This script can be used on the command line directly to configure several
-# different build environments.
-# This is called by `.travis.yml` via Travis CI.
-# Travis supplies $TRAVIS_OS_NAME.
-#  http://docs.travis-ci.com/user/multi-os/
-# Our .travis.yml also defines:
-
-#   - BUILD_TYPE=Release/Debug
-#   - LIB_TYPE=static/shared
-#
-# Optional environmental variables
-#   - DESTDIR <- used for setting the install prefix
-#   - BUILD_TOOL=["Unix Makefile"|"Ninja"]
-#   - BUILDNAME <- how to identify this build on the dashboard
-#   - DO_MemCheck <- if set, try to use valgrind
-#   - DO_Coverage <- if set, try to do dashboard coverage testing
-#
-
-env_set=1
-if ${BUILD_TYPE+false}; then
-  echo "BUILD_TYPE not set in environment."
-  env_set=0
-fi
-if ${LIB_TYPE+false}; then
-  echo "LIB_TYPE not set in environment."
-  env_set=0
-fi
-if ${CXX+false}; then
-  echo "CXX not set in environment."
-  env_set=0
-fi
-
-
-if [ ${env_set} -eq 0 ]; then
-  echo "USAGE:  CXX=$(which clang++)  BUILD_TYPE=[Release|Debug] LIB_TYPE=[static|shared] $0"
-  echo ""
-  echo "Examples:"
-  echo "           CXX=$(which clang++) BUILD_TYPE=Release LIB_TYPE=shared DESTDIR=/tmp/cmake_json_cpp $0"
-  echo "           CXX=$(which clang++) BUILD_TYPE=Debug   LIB_TYPE=shared DESTDIR=/tmp/cmake_json_cpp $0"
-  echo "           CXX=$(which clang++) BUILD_TYPE=Release LIB_TYPE=static DESTDIR=/tmp/cmake_json_cpp $0"
-  echo "           CXX=$(which clang++) BUILD_TYPE=Debug   LIB_TYPE=static DESTDIR=/tmp/cmake_json_cpp $0"
-
-  echo "           CXX=$(which g++)     BUILD_TYPE=Release LIB_TYPE=shared DESTDIR=/tmp/cmake_json_cpp $0"
-  echo "           CXX=$(which g++)     BUILD_TYPE=Debug   LIB_TYPE=shared DESTDIR=/tmp/cmake_json_cpp $0"
-  echo "           CXX=$(which g++)     BUILD_TYPE=Release LIB_TYPE=static DESTDIR=/tmp/cmake_json_cpp $0"
-  echo "           CXX=$(which g++)     BUILD_TYPE=Debug   LIB_TYPE=static DESTDIR=/tmp/cmake_json_cpp $0"
-
-  exit -1
-fi
-
-if ${DESTDIR+false}; then
-  DESTDIR="/usr/local"
-fi
-
-# -e: fail on error
-# -v: show commands
-# -x: show expanded commands
-set -vex
-
-env | sort
-
-which cmake
-cmake --version
-
-echo ${CXX}
-${CXX} --version
-_COMPILER_NAME=`basename ${CXX}`
-if [ "${LIB_TYPE}" = "shared" ]; then
-  _CMAKE_BUILD_SHARED_LIBS=ON
-else
-  _CMAKE_BUILD_SHARED_LIBS=OFF
-fi
-
-CTEST_TESTING_OPTION="-D ExperimentalTest"
-#   - DO_MemCheck <- if set, try to use valgrind
-if ! ${DO_MemCheck+false}; then
-   valgrind --version
-   CTEST_TESTING_OPTION="-D ExperimentalMemCheck"
-else
-#   - DO_Coverage <- if set, try to do dashboard coverage testing
-  if ! ${DO_Coverage+false}; then
-     export CXXFLAGS="-fprofile-arcs -ftest-coverage"
-     export LDFLAGS="-fprofile-arcs -ftest-coverage"
-     CTEST_TESTING_OPTION="-D ExperimentalTest -D ExperimentalCoverage"
-     #gcov --version
-  fi
-fi
-
-#  Ninja                        = Generates build.ninja files.
-if ${BUILD_TOOL+false}; then
-  BUILD_TOOL="Ninja"
-  export _BUILD_EXE=ninja
-  which ninja
-  ninja --version
-else
-#  Unix Makefiles               = Generates standard UNIX makefiles.
-  export _BUILD_EXE=make
-fi
-
-_BUILD_DIR_NAME="build-cmake_${BUILD_TYPE}_${LIB_TYPE}_${_COMPILER_NAME}_${_BUILD_EXE}"
-mkdir -p ${_BUILD_DIR_NAME}
-cd "${_BUILD_DIR_NAME}"
-  if ${BUILDNAME+false}; then
-     _HOSTNAME=`hostname -s`
-     BUILDNAME="${_HOSTNAME}_${BUILD_TYPE}_${LIB_TYPE}_${_COMPILER_NAME}_${_BUILD_EXE}"
-  fi
-  cmake \
-    -G "${BUILD_TOOL}" \
-    -DBUILDNAME:STRING="${BUILDNAME}" \
-    -DCMAKE_CXX_COMPILER:PATH=${CXX} \
-    -DCMAKE_BUILD_TYPE:STRING=${BUILD_TYPE} \
-    -DBUILD_SHARED_LIBS:BOOL=${_CMAKE_BUILD_SHARED_LIBS} \
-    -DCMAKE_INSTALL_PREFIX:PATH=${DESTDIR} \
-    ../
-
-  ctest -C ${BUILD_TYPE} -D ExperimentalStart -D ExperimentalConfigure -D ExperimentalBuild ${CTEST_TESTING_OPTION} -D ExperimentalSubmit
-  # Final step is to verify that installation succeeds
-  cmake --build . --config ${BUILD_TYPE} --target install
-
-  if [ "${DESTDIR}" != "/usr/local" ]; then
-     ${_BUILD_EXE} install
-  fi
-cd -
-
-if ${CLEANUP+false}; then
-  echo "Skipping cleanup: build directory will persist."
-else
-  rm -r "${_BUILD_DIR_NAME}"
-fi

.travis_scripts/meson_builder.sh

@@ -1,83 +0,0 @@
-#!/usr/bin/env sh
-# This script can be used on the command line directly to configure several
-# different build environments.
-# This is called by `.travis.yml` via Travis CI.
-# Travis supplies $TRAVIS_OS_NAME.
-#  http://docs.travis-ci.com/user/multi-os/
-# Our .travis.yml also defines:
-
-#   - BUILD_TYPE=release/debug
-#   - LIB_TYPE=static/shared
-
-env_set=1
-if ${BUILD_TYPE+false}; then
-  echo "BUILD_TYPE not set in environment."
-  env_set=0
-fi
-if ${LIB_TYPE+false}; then
-  echo "LIB_TYPE not set in environment."
-  env_set=0
-fi
-if ${CXX+false}; then
-  echo "CXX not set in environment."
-  env_set=0
-fi
-
-
-if [ ${env_set} -eq 0 ]; then
-  echo "USAGE:  CXX=$(which clang++)  BUILD_TYPE=[release|debug] LIB_TYPE=[static|shared] $0"
-  echo ""
-  echo "Examples:"
-  echo "           CXX=$(which clang++) BUILD_TYPE=release LIB_TYPE=shared DESTDIR=/tmp/meson_json_cpp $0"
-  echo "           CXX=$(which clang++) BUILD_TYPE=debug   LIB_TYPE=shared DESTDIR=/tmp/meson_json_cpp $0"
-  echo "           CXX=$(which clang++) BUILD_TYPE=release LIB_TYPE=static DESTDIR=/tmp/meson_json_cpp $0"
-  echo "           CXX=$(which clang++) BUILD_TYPE=debug   LIB_TYPE=static DESTDIR=/tmp/meson_json_cpp $0"
-
-  echo "           CXX=$(which g++)     BUILD_TYPE=release LIB_TYPE=shared DESTDIR=/tmp/meson_json_cpp $0"
-  echo "           CXX=$(which g++)     BUILD_TYPE=debug   LIB_TYPE=shared DESTDIR=/tmp/meson_json_cpp $0"
-  echo "           CXX=$(which g++)     BUILD_TYPE=release LIB_TYPE=static DESTDIR=/tmp/meson_json_cpp $0"
-  echo "           CXX=$(which g++)     BUILD_TYPE=debug   LIB_TYPE=static DESTDIR=/tmp/meson_json_cpp $0"
-
-  exit -1
-fi
-
-if ${DESTDIR+false}; then
-  DESTDIR="/usr/local"
-fi
-
-# -e: fail on error
-# -v: show commands
-# -x: show expanded commands
-set -vex
-
-
-env | sort
-
-which python3
-which meson
-which ninja
-echo ${CXX}
-${CXX} --version
-python3 --version
-meson --version
-ninja --version
-_COMPILER_NAME=`basename ${CXX}`
-_BUILD_DIR_NAME="build-${BUILD_TYPE}_${LIB_TYPE}_${_COMPILER_NAME}"
-
-#./.travis_scripts/run-clang-format.sh
-meson --fatal-meson-warnings --werror --buildtype ${BUILD_TYPE} --default-library ${LIB_TYPE} . "${_BUILD_DIR_NAME}"
-ninja -v -j 2 -C "${_BUILD_DIR_NAME}"
-
-cd "${_BUILD_DIR_NAME}"
-  meson test --no-rebuild --print-errorlogs
-
-  if [ "${DESTDIR}" != "/usr/local" ]; then
-     ninja install
-  fi
-cd -
-
-if ${CLEANUP+false}; then
-  echo "Skipping cleanup:  build directory will persist."
-else
-  rm -r "${_BUILD_DIR_NAME}"
-fi

.travis_scripts/run-clang-format.py

@@ -1,356 +0,0 @@
-#!/usr/bin/env python
-"""A wrapper script around clang-format, suitable for linting multiple files
-and to use for continuous integration.
-This is an alternative API for the clang-format command line.
-It runs over multiple files and directories in parallel.
-A diff output is produced and a sensible exit code is returned.
-
-NOTE: pulled from https://github.com/Sarcasm/run-clang-format, which is
-licensed under the MIT license.
-"""
-
-from __future__ import print_function, unicode_literals
-
-import argparse
-import codecs
-import difflib
-import fnmatch
-import io
-import multiprocessing
-import os
-import signal
-import subprocess
-import sys
-import traceback
-
-from functools import partial
-
-try:
-    from subprocess import DEVNULL  # py3k
-except ImportError:
-    DEVNULL = open(os.devnull, "wb")
-
-
-DEFAULT_EXTENSIONS = 'c,h,C,H,cpp,hpp,cc,hh,c++,h++,cxx,hxx'
-
-
-class ExitStatus:
-    SUCCESS = 0
-    DIFF = 1
-    TROUBLE = 2
-
-
-def list_files(files, recursive=False, extensions=None, exclude=None):
-    if extensions is None:
-        extensions = []
-    if exclude is None:
-        exclude = []
-
-    out = []
-    for file in files:
-        if recursive and os.path.isdir(file):
-            for dirpath, dnames, fnames in os.walk(file):
-                fpaths = [os.path.join(dirpath, fname) for fname in fnames]
-                for pattern in exclude:
-                    # os.walk() supports trimming down the dnames list
-                    # by modifying it in-place,
-                    # to avoid unnecessary directory listings.
-                    dnames[:] = [
-                        x for x in dnames
-                        if
-                        not fnmatch.fnmatch(os.path.join(dirpath, x), pattern)
-                    ]
-                    fpaths = [
-                        x for x in fpaths if not fnmatch.fnmatch(x, pattern)
-                    ]
-                for f in fpaths:
-                    ext = os.path.splitext(f)[1][1:]
-                    if ext in extensions:
-                        out.append(f)
-        else:
-            out.append(file)
-    return out
-
-
-def make_diff(file, original, reformatted):
-    return list(
-        difflib.unified_diff(
-            original,
-            reformatted,
-            fromfile='{}\t(original)'.format(file),
-            tofile='{}\t(reformatted)'.format(file),
-            n=3))
-
-
-class DiffError(Exception):
-    def __init__(self, message, errs=None):
-        super(DiffError, self).__init__(message)
-        self.errs = errs or []
-
-
-class UnexpectedError(Exception):
-    def __init__(self, message, exc=None):
-        super(UnexpectedError, self).__init__(message)
-        self.formatted_traceback = traceback.format_exc()
-        self.exc = exc
-
-
-def run_clang_format_diff_wrapper(args, file):
-    try:
-        ret = run_clang_format_diff(args, file)
-        return ret
-    except DiffError:
-        raise
-    except Exception as e:
-        raise UnexpectedError('{}: {}: {}'.format(file, e.__class__.__name__,
-                                                  e), e)
-
-
-def run_clang_format_diff(args, file):
-    try:
-        with io.open(file, 'r', encoding='utf-8') as f:
-            original = f.readlines()
-    except IOError as exc:
-        raise DiffError(str(exc))
-    invocation = [args.clang_format_executable, file]
-
-    # Use of utf-8 to decode the process output.
-    #
-    # Hopefully, this is the correct thing to do.
-    #
-    # It's done due to the following assumptions (which may be incorrect):
-    # - clang-format will returns the bytes read from the files as-is,
-    #   without conversion, and it is already assumed that the files use utf-8.
-    # - if the diagnostics were internationalized, they would use utf-8:
-    #   > Adding Translations to Clang
-    #   >
-    #   > Not possible yet!
-    #   > Diagnostic strings should be written in UTF-8,
-    #   > the client can translate to the relevant code page if needed.
-    #   > Each translation completely replaces the format string
-    #   > for the diagnostic.
-    #   > -- http://clang.llvm.org/docs/InternalsManual.html#internals-diag-translation
-    #
-    # It's not pretty, due to Python 2 & 3 compatibility.
-    encoding_py3 = {}
-    if sys.version_info[0] >= 3:
-        encoding_py3['encoding'] = 'utf-8'
-
-    try:
-        proc = subprocess.Popen(
-            invocation,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            universal_newlines=True,
-            **encoding_py3)
-    except OSError as exc:
-        raise DiffError(
-            "Command '{}' failed to start: {}".format(
-                subprocess.list2cmdline(invocation), exc
-            )
-        )
-    proc_stdout = proc.stdout
-    proc_stderr = proc.stderr
-    if sys.version_info[0] < 3:
-        # make the pipes compatible with Python 3,
-        # reading lines should output unicode
-        encoding = 'utf-8'
-        proc_stdout = codecs.getreader(encoding)(proc_stdout)
-        proc_stderr = codecs.getreader(encoding)(proc_stderr)
-    # hopefully the stderr pipe won't get full and block the process
-    outs = list(proc_stdout.readlines())
-    errs = list(proc_stderr.readlines())
-    proc.wait()
-    if proc.returncode:
-        raise DiffError(
-            "Command '{}' returned non-zero exit status {}".format(
-                subprocess.list2cmdline(invocation), proc.returncode
-            ),
-            errs,
-        )
-    return make_diff(file, original, outs), errs
-
-
-def bold_red(s):
-    return '\x1b[1m\x1b[31m' + s + '\x1b[0m'
-
-
-def colorize(diff_lines):
-    def bold(s):
-        return '\x1b[1m' + s + '\x1b[0m'
-
-    def cyan(s):
-        return '\x1b[36m' + s + '\x1b[0m'
-
-    def green(s):
-        return '\x1b[32m' + s + '\x1b[0m'
-
-    def red(s):
-        return '\x1b[31m' + s + '\x1b[0m'
-
-    for line in diff_lines:
-        if line[:4] in ['--- ', '+++ ']:
-            yield bold(line)
-        elif line.startswith('@@ '):
-            yield cyan(line)
-        elif line.startswith('+'):
-            yield green(line)
-        elif line.startswith('-'):
-            yield red(line)
-        else:
-            yield line
-
-
-def print_diff(diff_lines, use_color):
-    if use_color:
-        diff_lines = colorize(diff_lines)
-    if sys.version_info[0] < 3:
-        sys.stdout.writelines((l.encode('utf-8') for l in diff_lines))
-    else:
-        sys.stdout.writelines(diff_lines)
-
-
-def print_trouble(prog, message, use_colors):
-    error_text = 'error:'
-    if use_colors:
-        error_text = bold_red(error_text)
-    print("{}: {} {}".format(prog, error_text, message), file=sys.stderr)
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        '--clang-format-executable',
-        metavar='EXECUTABLE',
-        help='path to the clang-format executable',
-        default='clang-format')
-    parser.add_argument(
-        '--extensions',
-        help='comma separated list of file extensions (default: {})'.format(
-            DEFAULT_EXTENSIONS),
-        default=DEFAULT_EXTENSIONS)
-    parser.add_argument(
-        '-r',
-        '--recursive',
-        action='store_true',
-        help='run recursively over directories')
-    parser.add_argument('files', metavar='file', nargs='+')
-    parser.add_argument(
-        '-q',
-        '--quiet',
-        action='store_true')
-    parser.add_argument(
-        '-j',
-        metavar='N',
-        type=int,
-        default=0,
-        help='run N clang-format jobs in parallel'
-        ' (default number of cpus + 1)')
-    parser.add_argument(
-        '--color',
-        default='auto',
-        choices=['auto', 'always', 'never'],
-        help='show colored diff (default: auto)')
-    parser.add_argument(
-        '-e',
-        '--exclude',
-        metavar='PATTERN',
-        action='append',
-        default=[],
-        help='exclude paths matching the given glob-like pattern(s)'
-        ' from recursive search')
-
-    args = parser.parse_args()
-
-    # use default signal handling, like diff return SIGINT value on ^C
-    # https://bugs.python.org/issue14229#msg156446
-    signal.signal(signal.SIGINT, signal.SIG_DFL)
-    try:
-        signal.SIGPIPE
-    except AttributeError:
-        # compatibility, SIGPIPE does not exist on Windows
-        pass
-    else:
-        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
-
-    colored_stdout = False
-    colored_stderr = False
-    if args.color == 'always':
-        colored_stdout = True
-        colored_stderr = True
-    elif args.color == 'auto':
-        colored_stdout = sys.stdout.isatty()
-        colored_stderr = sys.stderr.isatty()
-
-    version_invocation = [args.clang_format_executable, str("--version")]
-    try:
-        subprocess.check_call(version_invocation, stdout=DEVNULL)
-    except subprocess.CalledProcessError as e:
-        print_trouble(parser.prog, str(e), use_colors=colored_stderr)
-        return ExitStatus.TROUBLE
-    except OSError as e:
-        print_trouble(
-            parser.prog,
-            "Command '{}' failed to start: {}".format(
-                subprocess.list2cmdline(version_invocation), e
-            ),
-            use_colors=colored_stderr,
-        )
-        return ExitStatus.TROUBLE
-
-    retcode = ExitStatus.SUCCESS
-    files = list_files(
-        args.files,
-        recursive=args.recursive,
-        exclude=args.exclude,
-        extensions=args.extensions.split(','))
-
-    if not files:
-        return
-
-    njobs = args.j
-    if njobs == 0:
-        njobs = multiprocessing.cpu_count() + 1
-    njobs = min(len(files), njobs)
-
-    if njobs == 1:
-        # execute directly instead of in a pool,
-        # less overhead, simpler stacktraces
-        it = (run_clang_format_diff_wrapper(args, file) for file in files)
-        pool = None
-    else:
-        pool = multiprocessing.Pool(njobs)
-        it = pool.imap_unordered(
-            partial(run_clang_format_diff_wrapper, args), files)
-    while True:
-        try:
-            outs, errs = next(it)
-        except StopIteration:
-            break
-        except DiffError as e:
-            print_trouble(parser.prog, str(e), use_colors=colored_stderr)
-            retcode = ExitStatus.TROUBLE
-            sys.stderr.writelines(e.errs)
-        except UnexpectedError as e:
-            print_trouble(parser.prog, str(e), use_colors=colored_stderr)
-            sys.stderr.write(e.formatted_traceback)
-            retcode = ExitStatus.TROUBLE
-            # stop at the first unexpected error,
-            # something could be very wrong,
-            # don't process all files unnecessarily
-            if pool:
-                pool.terminate()
-            break
-        else:
-            sys.stderr.writelines(errs)
-            if outs == []:
-                continue
-            if not args.quiet:
-                print_diff(outs, use_color=colored_stdout)
-            if retcode == ExitStatus.SUCCESS:
-                retcode = ExitStatus.DIFF
-    return retcode
-
-
-if __name__ == '__main__':
-    sys.exit(main())

.travis_scripts/run-clang-format.sh

@@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-python $DIR/run-clang-format.py -r $DIR/../src/**/ $DIR/../include/**/

.travis_scripts/travis.before_install.linux.sh

@@ -1,8 +0,0 @@
-set -vex
-
-# Preinstalled versions of python are dependent on which Ubuntu distribution
-# you are running. The below version needs to be updated whenever we roll
-# the Ubuntu version used in Travis.
-# https://docs.travis-ci.com/user/languages/python/
-
-pyenv global 3.7.1

.travis_scripts/travis.install.linux.sh

@@ -1,5 +0,0 @@
-set -vex
-
-pip3 install --user meson ninja
-which meson
-which ninja

.travis_scripts/travis.install.osx.sh

@@ -1 +0,0 @@
-# NOTHING TO DO HERE

AUTHORS

@@ -16,7 +16,7 @@ Baruch Siach <baruch@tkos.co.il>
 Ben Boeckel <mathstuf@gmail.com>
 Benjamin Knecht <bknecht@logitech.com>
 Bernd Kuhls <bernd.kuhls@t-online.de>
-Billy Donahue <billydonahue@google.com>
+Billy Donahue <billy.donahue@gmail.com>
 Braden McDorman <bmcdorman@gmail.com>
 Brandon Myers <bmyers1788@gmail.com>
 Brendan Drew <brendan.drew@daqri.com>

CMakeLists.txt

@@ -6,7 +6,7 @@
 # policies that provide successful builds. By setting JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION
 # to a value greater than the oldest policies, all policies between
 # JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION and CMAKE_VERSION (used for this build)
-# are set to their NEW behaivor, thereby suppressing policy warnings related to policies
+# are set to their NEW behavior, thereby suppressing policy warnings related to policies
 # between the JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION and CMAKE_VERSION.
 #
 # CMake versions greater than the JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION policies will
@@ -54,16 +54,6 @@ endif()
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
-# ---------------------------------------------------------------------------
-# use ccache if found, has to be done before project()
-# ---------------------------------------------------------------------------
-find_program(CCACHE_EXECUTABLE "ccache" HINTS /usr/local/bin /opt/local/bin)
-if(CCACHE_EXECUTABLE)
-    message(STATUS "use ccache")
-    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_EXECUTABLE}" CACHE PATH "ccache" FORCE)
-    set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_EXECUTABLE}" CACHE PATH "ccache" FORCE)
-endif()
-
 project(jsoncpp
         # Note: version must be updated in three places when doing a release. This
         # annoying process ensures that amalgamate, CMake, and meson all report the
@@ -72,11 +62,11 @@ project(jsoncpp
         # 2. ./include/json/version.h
         # 3. ./CMakeLists.txt
         # IMPORTANT: also update the PROJECT_SOVERSION!!
-        VERSION 1.9.5 # <major>[.<minor>[.<patch>[.<tweak>]]]
+        VERSION 1.9.7 # <major>[.<minor>[.<patch>[.<tweak>]]]
         LANGUAGES CXX)
 
 message(STATUS "JsonCpp Version: ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
-set(PROJECT_SOVERSION 25)
+set(PROJECT_SOVERSION 27)
 
 include(${CMAKE_CURRENT_SOURCE_DIR}/include/PreventInSourceBuilds.cmake)
 include(${CMAKE_CURRENT_SOURCE_DIR}/include/PreventInBuildInstalls.cmake)
@@ -96,12 +86,22 @@ option(BUILD_OBJECT_LIBS "Build jsoncpp_lib as a object library." ON)
 # Adhere to GNU filesystem layout conventions
 include(GNUInstallDirs)
 
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Archive output dir.")
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Library output dir.")
-set(CMAKE_PDB_OUTPUT_DIRECTORY     "${CMAKE_BINARY_DIR}/bin" CACHE PATH "PDB (MSVC debug symbol)output dir.")
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Executable/dll output dir.")
+if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Archive output dir.")
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Library output dir.")
+    set(CMAKE_PDB_OUTPUT_DIRECTORY     "${CMAKE_BINARY_DIR}/bin" CACHE PATH "PDB (MSVC debug symbol)output dir.")
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Executable/dll output dir.")
+endif()
 
-set(JSONCPP_USE_SECURE_MEMORY "0" CACHE STRING "-D...=1 to use memory-wiping allocator for STL")
+include(CheckFunctionExists)
+check_function_exists(memset_s HAVE_MEMSET_S)
+if(HAVE_MEMSET_S)
+    add_definitions("-DHAVE_MEMSET_S=1")
+endif()
+
+if(JSONCPP_USE_SECURE_MEMORY)
+    add_definitions("-DJSONCPP_USE_SECURE_MEMORY=1")
+endif()
 
 configure_file("${PROJECT_SOURCE_DIR}/version.in"
     "${PROJECT_BINARY_DIR}/version"

CONTRIBUTING.md

@@ -77,7 +77,7 @@ See `doxybuild.py --help` for options.
 To add a test, you need to create two files in test/data:
 
 * a `TESTNAME.json` file, that contains the input document in JSON format.
-* a `TESTNAME.expected` file, that contains a flatened representation of the
+* a `TESTNAME.expected` file, that contains a flattened representation of the
   input document.
 
 The `TESTNAME.expected` file format is as follows:

SECURITY.md

@@ -0,0 +1,17 @@
+# Security Policy
+
+If you have discovered a security vulnerability in this project, please report it
+privately. **Do not disclose it as a public issue.** This gives us time to work with you
+to fix the issue before public exposure, reducing the chance that the exploit will be
+used before a patch is released.
+
+Please submit the report by filling out
+[this form](https://github.com/open-source-parsers/jsoncpp/security/advisories/new).
+
+Please provide the following information in your report:
+
+- A description of the vulnerability and its impact
+- How to reproduce the issue
+
+This project is maintained by volunteers on a reasonable-effort basis. As such,
+we ask that you give us 90 days to work on a fix before public exposure.

amalgamate.py

@@ -63,7 +63,7 @@ def amalgamate_source(source_top_dir=None,
     """
     print("Amalgamating header...")
     header = AmalgamationFile(source_top_dir)
-    header.add_text("/// Json-cpp amalgamated header (http://jsoncpp.sourceforge.net/).")
+    header.add_text("/// Json-cpp amalgamated header (https://github.com/open-source-parsers/jsoncpp/).")
     header.add_text('/// It is intended to be used with #include "%s"' % header_include_path)
     header.add_file("LICENSE", wrap_in_comment=True)
     header.add_text("#ifndef JSON_AMALGAMATED_H_INCLUDED")
@@ -90,7 +90,7 @@ def amalgamate_source(source_top_dir=None,
     forward_header_include_path = base + "-forwards" + ext
     print("Amalgamating forward header...")
     header = AmalgamationFile(source_top_dir)
-    header.add_text("/// Json-cpp amalgamated forward header (http://jsoncpp.sourceforge.net/).")
+    header.add_text("/// Json-cpp amalgamated forward header (https://github.com/open-source-parsers/jsoncpp/).")
     header.add_text('/// It is intended to be used with #include "%s"' % forward_header_include_path)
     header.add_text("/// This header provides forward declaration for all JsonCpp types.")
     header.add_file("LICENSE", wrap_in_comment=True)
@@ -112,7 +112,7 @@ def amalgamate_source(source_top_dir=None,
 
     print("Amalgamating source...")
     source = AmalgamationFile(source_top_dir)
-    source.add_text("/// Json-cpp amalgamated source (http://jsoncpp.sourceforge.net/).")
+    source.add_text("/// Json-cpp amalgamated source (https://github.com/open-source-parsers/jsoncpp/).")
     source.add_text('/// It is intended to be used with #include "%s"' % header_include_path)
     source.add_file("LICENSE", wrap_in_comment=True)
     source.add_text("")

devtools/batchbuild.py

@@ -9,7 +9,7 @@ import shutil
 import string
 import subprocess
 import sys
-import cgi
+import html
 
 class BuildDesc:
     def __init__(self, prepend_envs=None, variables=None, build_type=None, generator=None):
@@ -195,12 +195,12 @@ def generate_html_report(html_report_path, builds):
     for variable in variables:
         build_types = sorted(build_types_by_variable[variable])
         nb_build_type = len(build_types_by_variable[variable])
-        th_vars.append('<th colspan="%d">%s</th>' % (nb_build_type, cgi.escape(' '.join(variable))))
+        th_vars.append('<th colspan="%d">%s</th>' % (nb_build_type, html.escape(' '.join(variable))))
         for build_type in build_types:
-            th_build_types.append('<th>%s</th>' % cgi.escape(build_type))
+            th_build_types.append('<th>%s</th>' % html.escape(build_type))
     tr_builds = []
     for generator in sorted(builds_by_generator):
-        tds = [ '<td>%s</td>\n' % cgi.escape(generator) ]
+        tds = [ '<td>%s</td>\n' % html.escape(generator) ]
         for variable in variables:
             build_types = sorted(build_types_by_variable[variable])
             for build_type in build_types:

example/readFromString/readFromString.cpp

@@ -25,7 +25,7 @@ int main() {
     const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
     if (!reader->parse(rawJson.c_str(), rawJson.c_str() + rawJsonLength, &root,
                        &err)) {
-      std::cout << "error" << std::endl;
+      std::cout << "error: " << err << std::endl;
       return EXIT_FAILURE;
     }
   }

include/PreventInSourceBuilds.cmake

@@ -2,8 +2,8 @@
 # This function will prevent in-source builds
 function(AssureOutOfSourceBuilds)
   # make sure the user doesn't play dirty with symlinks
-  get_filename_component(srcdir "${CMAKE_SOURCE_DIR}" REALPATH)
-  get_filename_component(bindir "${CMAKE_BINARY_DIR}" REALPATH)
+  get_filename_component(srcdir "${CMAKE_CURRENT_SOURCE_DIR}" REALPATH)
+  get_filename_component(bindir "${CMAKE_CURRENT_BINARY_DIR}" REALPATH)
 
   # disallow in-source builds
   if("${srcdir}" STREQUAL "${bindir}")

include/json/allocator.h

@@ -6,10 +6,12 @@
 #ifndef JSON_ALLOCATOR_H_INCLUDED
 #define JSON_ALLOCATOR_H_INCLUDED
 
+#include <algorithm>
 #include <cstring>
 #include <memory>
 
-#pragma pack(push, 8)
+#pragma pack(push)
+#pragma pack()
 
 namespace Json {
 template <typename T> class SecureAllocator {
@@ -37,8 +39,16 @@ public:
    * The memory block is filled with zeroes before being released.
    */
   void deallocate(pointer p, size_type n) {
-    // memset_s is used because memset may be optimized away by the compiler
+    // These constructs will not be removed by the compiler during optimization,
+    // unlike memset.
+#if defined(HAVE_MEMSET_S)
     memset_s(p, n * sizeof(T), 0, n * sizeof(T));
+#elif defined(_WIN32)
+    RtlSecureZeroMemory(p, n * sizeof(T));
+#else
+    std::fill_n(reinterpret_cast<volatile unsigned char*>(p), n, 0);
+#endif
+
     // free using "global operator delete"
     ::operator delete(p);
   }
@@ -68,7 +78,9 @@ public:
   // Boilerplate
   SecureAllocator() {}
   template <typename U> SecureAllocator(const SecureAllocator<U>&) {}
-  template <typename U> struct rebind { using other = SecureAllocator<U>; };
+  template <typename U> struct rebind {
+    using other = SecureAllocator<U>;
+  };
 };
 
 template <typename T, typename U>

include/json/config.h

@@ -127,7 +127,7 @@ using LargestUInt = UInt64;
 
 template <typename T>
 using Allocator =
-    typename std::conditional<JSONCPP_USING_SECURE_MEMORY, SecureAllocator<T>,
+    typename std::conditional<JSONCPP_USE_SECURE_MEMORY, SecureAllocator<T>,
                               std::allocator<T>>::type;
 using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
 using IStringStream =

include/json/json_features.h

@@ -10,7 +10,8 @@
 #include "forwards.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 
-#pragma pack(push, 8)
+#pragma pack(push)
+#pragma pack()
 
 namespace Json {
 

include/json/reader.h

@@ -23,7 +23,8 @@
 #pragma warning(disable : 4251)
 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
 
-#pragma pack(push, 8)
+#pragma pack(push)
+#pragma pack()
 
 namespace Json {
 
@@ -50,12 +51,12 @@ public:
   };
 
   /** \brief Constructs a Reader allowing all features for parsing.
-    * \deprecated Use CharReader and CharReaderBuilder.
+   * \deprecated Use CharReader and CharReaderBuilder.
    */
   Reader();
 
   /** \brief Constructs a Reader allowing the specified feature set for parsing.
-    * \deprecated Use CharReader and CharReaderBuilder.
+   * \deprecated Use CharReader and CharReaderBuilder.
    */
   Reader(const Features& features);
 
@@ -189,6 +190,7 @@ private:
   using Errors = std::deque<ErrorInfo>;
 
   bool readToken(Token& token);
+  bool readTokenSkippingComments(Token& token);
   void skipSpaces();
   bool match(const Char* pattern, int patternLength);
   bool readComment();
@@ -220,7 +222,6 @@ private:
                                 int& column) const;
   String getLocationLineAndColumn(Location location) const;
   void addComment(Location begin, Location end, CommentPlacement placement);
-  void skipCommentTokens(Token& token);
 
   static bool containsNewLine(Location begin, Location end);
   static String normalizeEOL(Location begin, Location end);
@@ -243,6 +244,12 @@ private:
  */
 class JSON_API CharReader {
 public:
+  struct JSON_API StructuredError {
+    ptrdiff_t offset_start;
+    ptrdiff_t offset_limit;
+    String message;
+  };
+
   virtual ~CharReader() = default;
   /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
    * document. The document must be a UTF-8 encoded string containing the
@@ -261,7 +268,12 @@ public:
    * error occurred.
    */
   virtual bool parse(char const* beginDoc, char const* endDoc, Value* root,
-                     String* errs) = 0;
+                     String* errs);
+
+  /** \brief Returns a vector of structured errors encountered while parsing.
+   * Each parse call resets the stored list of errors.
+   */
+  std::vector<StructuredError> getStructuredErrors() const;
 
   class JSON_API Factory {
   public:
@@ -271,7 +283,21 @@ public:
      */
     virtual CharReader* newCharReader() const = 0;
   }; // Factory
-};   // CharReader
+
+protected:
+  class Impl {
+  public:
+    virtual ~Impl() = default;
+    virtual bool parse(char const* beginDoc, char const* endDoc, Value* root,
+                       String* errs) = 0;
+    virtual std::vector<StructuredError> getStructuredErrors() const = 0;
+  };
+
+  explicit CharReader(std::unique_ptr<Impl> impl) : _impl(std::move(impl)) {}
+
+private:
+  std::unique_ptr<Impl> _impl;
+}; // CharReader
 
 /** \brief Build a CharReader implementation.
  *
@@ -359,6 +385,12 @@ public:
    * \snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode
    */
   static void strictMode(Json::Value* settings);
+  /** ECMA-404 mode.
+   * \pre 'settings' != NULL (but Json::null is fine)
+   * \remark Defaults:
+   * \snippet src/lib_json/json_reader.cpp CharReaderBuilderECMA404Mode
+   */
+  static void ecma404Mode(Json::Value* settings);
 };
 
 /** Consume entire stream and use its begin/end.

include/json/value.h

@@ -3,8 +3,8 @@
 // recognized in your jurisdiction.
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
-#ifndef JSON_H_INCLUDED
-#define JSON_H_INCLUDED
+#ifndef JSON_VALUE_H_INCLUDED
+#define JSON_VALUE_H_INCLUDED
 
 #if !defined(JSON_IS_AMALGAMATION)
 #include "forwards.h"
@@ -39,6 +39,10 @@
 #endif
 #endif
 
+#if __cplusplus >= 201703L
+#define JSONCPP_HAS_STRING_VIEW 1
+#endif
+
 #include <array>
 #include <exception>
 #include <map>
@@ -46,6 +50,10 @@
 #include <string>
 #include <vector>
 
+#ifdef JSONCPP_HAS_STRING_VIEW
+#include <string_view>
+#endif
+
 // Disable warning C4251: <data member>: <type> needs to have dll-interface to
 // be used by...
 #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
@@ -53,7 +61,8 @@
 #pragma warning(disable : 4251 4275)
 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
 
-#pragma pack(push, 8)
+#pragma pack(push)
+#pragma pack()
 
 /** \brief JSON (JavaScript Object Notation).
  */
@@ -341,6 +350,9 @@ public:
    */
   Value(const StaticString& value);
   Value(const String& value);
+#ifdef JSONCPP_HAS_STRING_VIEW
+  Value(std::string_view value);
+#endif
   Value(bool value);
   Value(std::nullptr_t ptr) = delete;
   Value(const Value& other);
@@ -374,7 +386,7 @@ public:
   int compare(const Value& other) const;
 
   const char* asCString() const; ///< Embedded zeroes could cause you trouble!
-#if JSONCPP_USING_SECURE_MEMORY
+#if JSONCPP_USE_SECURE_MEMORY
   unsigned getCStringLength() const; // Allows you to understand the length of
                                      // the CString
 #endif
@@ -383,6 +395,12 @@ public:
    *  \return false if !string. (Seg-fault if str or end are NULL.)
    */
   bool getString(char const** begin, char const** end) const;
+#ifdef JSONCPP_HAS_STRING_VIEW
+  /** Get string_view of string-value.
+   *  \return false if !string. (Seg-fault if str is NULL.)
+   */
+  bool getString(std::string_view* str) const;
+#endif
   Int asInt() const;
   UInt asUInt() const;
 #if defined(JSON_HAS_INT64)
@@ -436,7 +454,7 @@ public:
   /// \post type() is arrayValue
   void resize(ArrayIndex newSize);
 
-  //@{
+  ///@{
   /// Access an array element (zero based index). If the array contains less
   /// than index element, then null value are inserted in the array so that
   /// its size is index+1.
@@ -444,15 +462,15 @@ public:
   /// this from the operator[] which takes a string.)
   Value& operator[](ArrayIndex index);
   Value& operator[](int index);
-  //@}
+  ///@}
 
-  //@{
+  ///@{
   /// Access an array element (zero based index).
   /// (You may need to say 'value[0u]' to get your compiler to distinguish
   /// this from the operator[] which takes a string.)
   const Value& operator[](ArrayIndex index) const;
   const Value& operator[](int index) const;
-  //@}
+  ///@}
 
   /// If the array contains at least index+1 elements, returns the element
   /// value, otherwise returns defaultValue.
@@ -469,6 +487,15 @@ public:
   bool insert(ArrayIndex index, const Value& newValue);
   bool insert(ArrayIndex index, Value&& newValue);
 
+#ifdef JSONCPP_HAS_STRING_VIEW
+  /// Access an object value by name, create a null member if it does not exist.
+  /// \param key may contain embedded nulls.
+  Value& operator[](std::string_view key);
+  /// Access an object value by name, returns null if there is no member with
+  /// that name.
+  /// \param key may contain embedded nulls.
+  const Value& operator[](std::string_view key) const;
+#else
   /// Access an object value by name, create a null member if it does not exist.
   /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
   /// Exceeding that will cause an exception.
@@ -483,6 +510,7 @@ public:
   /// that name.
   /// \param key may contain embedded nulls.
   const Value& operator[](const String& key) const;
+#endif
   /** \brief Access an object value by name, create a null member if it does not
    * exist.
    *
@@ -496,22 +524,54 @@ public:
    *   \endcode
    */
   Value& operator[](const StaticString& key);
+#ifdef JSONCPP_HAS_STRING_VIEW
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  Value get(std::string_view key, const Value& defaultValue) const;
+#else
   /// Return the member named key if it exist, defaultValue otherwise.
   /// \note deep copy
   Value get(const char* key, const Value& defaultValue) const;
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  /// \param key may contain embedded nulls.
+  Value get(const String& key, const Value& defaultValue) const;
+#endif
   /// Return the member named key if it exist, defaultValue otherwise.
   /// \note deep copy
   /// \note key may contain embedded nulls.
   Value get(const char* begin, const char* end,
             const Value& defaultValue) const;
-  /// Return the member named key if it exist, defaultValue otherwise.
-  /// \note deep copy
-  /// \param key may contain embedded nulls.
-  Value get(const String& key, const Value& defaultValue) const;
   /// Most general and efficient version of isMember()const, get()const,
   /// and operator[]const
   /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
   Value const* find(char const* begin, char const* end) const;
+  /// Most general and efficient version of isMember()const, get()const,
+  /// and operator[]const
+  Value const* find(const String& key) const;
+
+  /// Calls find and only returns a valid pointer if the type is found
+  template <typename T, bool (T::*TMemFn)() const>
+  Value const* findValue(const String& key) const {
+    Value const* found = find(key);
+    if (!found || !(found->*TMemFn)())
+      return nullptr;
+    return found;
+  }
+
+  Value const* findNull(const String& key) const;
+  Value const* findBool(const String& key) const;
+  Value const* findInt(const String& key) const;
+  Value const* findInt64(const String& key) const;
+  Value const* findUInt(const String& key) const;
+  Value const* findUInt64(const String& key) const;
+  Value const* findIntegral(const String& key) const;
+  Value const* findDouble(const String& key) const;
+  Value const* findNumeric(const String& key) const;
+  Value const* findString(const String& key) const;
+  Value const* findArray(const String& key) const;
+  Value const* findObject(const String& key) const;
+
   /// Most general and efficient version of object-mutators.
   /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
   /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
@@ -521,20 +581,28 @@ public:
   /// Do nothing if it did not exist.
   /// \pre type() is objectValue or nullValue
   /// \post type() is unchanged
+#if JSONCPP_HAS_STRING_VIEW
+  void removeMember(std::string_view key);
+#else
   void removeMember(const char* key);
   /// Same as removeMember(const char*)
   /// \param key may contain embedded nulls.
   void removeMember(const String& key);
-  /// Same as removeMember(const char* begin, const char* end, Value* removed),
-  /// but 'key' is null-terminated.
-  bool removeMember(const char* key, Value* removed);
+#endif
   /** \brief Remove the named map member.
    *
    *  Update 'removed' iff removed.
    *  \param key may contain embedded nulls.
    *  \return true iff removed (no exceptions)
    */
+#if JSONCPP_HAS_STRING_VIEW
+  bool removeMember(std::string_view key, Value* removed);
+#else
   bool removeMember(String const& key, Value* removed);
+  /// Same as removeMember(const char* begin, const char* end, Value* removed),
+  /// but 'key' is null-terminated.
+  bool removeMember(const char* key, Value* removed);
+#endif
   /// Same as removeMember(String const& key, Value* removed)
   bool removeMember(const char* begin, const char* end, Value* removed);
   /** \brief Remove the indexed array element.
@@ -545,12 +613,18 @@ public:
    */
   bool removeIndex(ArrayIndex index, Value* removed);
 
+#ifdef JSONCPP_HAS_STRING_VIEW
+  /// Return true if the object has a member named key.
+  /// \param key may contain embedded nulls.
+  bool isMember(std::string_view key) const;
+#else
   /// Return true if the object has a member named key.
   /// \note 'key' must be null-terminated.
   bool isMember(const char* key) const;
   /// Return true if the object has a member named key.
   /// \param key may contain embedded nulls.
   bool isMember(const String& key) const;
+#endif
   /// Same as isMember(String const& key)const
   bool isMember(const char* begin, const char* end) const;
 
@@ -584,6 +658,26 @@ public:
   iterator begin();
   iterator end();
 
+  /// \brief Returns a reference to the first element in the `Value`.
+  /// Requires that this value holds an array or json object, with at least one
+  /// element.
+  const Value& front() const;
+
+  /// \brief Returns a reference to the first element in the `Value`.
+  /// Requires that this value holds an array or json object, with at least one
+  /// element.
+  Value& front();
+
+  /// \brief Returns a reference to the last element in the `Value`.
+  /// Requires that value holds an array or json object, with at least one
+  /// element.
+  const Value& back() const;
+
+  /// \brief Returns a reference to the last element in the `Value`.
+  /// Requires that this value holds an array or json object, with at least one
+  /// element.
+  Value& back();
+
   // Accessors for the [start, limit) range of bytes within the JSON text from
   // which this value was parsed, if any.
   void setOffsetStart(ptrdiff_t start);
@@ -924,6 +1018,14 @@ public:
 
 inline void swap(Value& a, Value& b) { a.swap(b); }
 
+inline const Value& Value::front() const { return *begin(); }
+
+inline Value& Value::front() { return *begin(); }
+
+inline const Value& Value::back() const { return *(--end()); }
+
+inline Value& Value::back() { return *(--end()); }
+
 } // namespace Json
 
 #pragma pack(pop)

include/json/version.h

@@ -9,19 +9,18 @@
 // 3. /CMakeLists.txt
 // IMPORTANT: also update the SOVERSION!!
 
-#define JSONCPP_VERSION_STRING "1.9.5"
+#define JSONCPP_VERSION_STRING "1.9.7"
 #define JSONCPP_VERSION_MAJOR 1
 #define JSONCPP_VERSION_MINOR 9
-#define JSONCPP_VERSION_PATCH 5
+#define JSONCPP_VERSION_PATCH 7
 #define JSONCPP_VERSION_QUALIFIER
 #define JSONCPP_VERSION_HEXA                                                   \
   ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) |             \
    (JSONCPP_VERSION_PATCH << 8))
 
-#ifdef JSONCPP_USING_SECURE_MEMORY
-#undef JSONCPP_USING_SECURE_MEMORY
+#if !defined(JSONCPP_USE_SECURE_MEMORY)
+#define JSONCPP_USE_SECURE_MEMORY 0
 #endif
-#define JSONCPP_USING_SECURE_MEMORY 0
 // If non-zero, the library zeroes any memory that it has allocated before
 // it frees its memory.
 

include/json/writer.h

@@ -20,7 +20,8 @@
 #pragma warning(disable : 4251)
 #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
 
-#pragma pack(push, 8)
+#pragma pack(push)
+#pragma pack()
 
 namespace Json {
 
@@ -63,7 +64,7 @@ public:
      */
     virtual StreamWriter* newStreamWriter() const = 0;
   }; // Factory
-};   // StreamWriter
+}; // StreamWriter
 
 /** \brief Write into stringstream, then return string, for convenience.
  * A StreamWriter will be created from the factory, used, and then deleted.
@@ -167,8 +168,7 @@ public:
 #pragma warning(push)
 #pragma warning(disable : 4996) // Deriving from deprecated class
 #endif
-class JSON_API FastWriter
-    : public Writer {
+class JSON_API FastWriter : public Writer {
 public:
   FastWriter();
   ~FastWriter() override = default;
@@ -217,7 +217,7 @@ private:
  *     - otherwise, it the values do not fit on one line, or the array contains
  *       object or non empty array, then print one value per line.
  *
- * If the Value have comments then they are outputed according to their
+ * If the Value have comments then they are outputted according to their
  *#CommentPlacement.
  *
  * \sa Reader, Value, Value::setComment()
@@ -227,8 +227,7 @@ private:
 #pragma warning(push)
 #pragma warning(disable : 4996) // Deriving from deprecated class
 #endif
-class JSON_API
-    StyledWriter : public Writer {
+class JSON_API StyledWriter : public Writer {
 public:
   StyledWriter();
   ~StyledWriter() override = default;
@@ -286,7 +285,7 @@ private:
  *     - otherwise, it the values do not fit on one line, or the array contains
  *       object or non empty array, then print one value per line.
  *
- * If the Value have comments then they are outputed according to their
+ * If the Value have comments then they are outputted according to their
  #CommentPlacement.
  *
  * \sa Reader, Value, Value::setComment()
@@ -296,8 +295,7 @@ private:
 #pragma warning(push)
 #pragma warning(disable : 4996) // Deriving from deprecated class
 #endif
-class JSON_API
-    StyledStreamWriter {
+class JSON_API StyledStreamWriter {
 public:
   /**
    * \param indentation Each level will be indented by this amount extra.
@@ -353,6 +351,7 @@ String JSON_API valueToString(
     PrecisionType precisionType = PrecisionType::significantDigits);
 String JSON_API valueToString(bool value);
 String JSON_API valueToQuotedString(const char* value);
+String JSON_API valueToQuotedString(const char* value, size_t length);
 
 /// \brief Output using the StyledStreamWriter.
 /// \see Json::operator>>()

jsoncpp-namespaced-targets.cmake

@@ -1,7 +1,9 @@
-if (TARGET jsoncpp_static)
-    add_library(JsonCpp::JsonCpp INTERFACE IMPORTED)
-    set_target_properties(JsonCpp::JsonCpp PROPERTIES INTERFACE_LINK_LIBRARIES "jsoncpp_static")
-elseif (TARGET jsoncpp_lib)
-    add_library(JsonCpp::JsonCpp INTERFACE IMPORTED)
-    set_target_properties(JsonCpp::JsonCpp PROPERTIES INTERFACE_LINK_LIBRARIES "jsoncpp_lib")
-endif ()
+if (NOT TARGET JsonCpp::JsonCpp)
+    if (TARGET jsoncpp_static)
+        add_library(JsonCpp::JsonCpp INTERFACE IMPORTED)
+        set_target_properties(JsonCpp::JsonCpp PROPERTIES INTERFACE_LINK_LIBRARIES "jsoncpp_static")
+    elseif (TARGET jsoncpp_lib)
+        add_library(JsonCpp::JsonCpp INTERFACE IMPORTED)
+        set_target_properties(JsonCpp::JsonCpp PROPERTIES INTERFACE_LINK_LIBRARIES "jsoncpp_lib")
+    endif ()
+endif ()

jsoncppConfig.cmake.in

@@ -1,5 +1,5 @@
 cmake_policy(PUSH)
-cmake_policy(VERSION 3.0)
+cmake_policy(VERSION 3.0...3.26)
 
 @PACKAGE_INIT@
 

jsoncppConfig.cmake.meson.in

@@ -0,0 +1,6 @@
+@PACKAGE_INIT@
+
+@MESON_SHARED_TARGET@
+@MESON_STATIC_TARGET@
+
+include ( "${CMAKE_CURRENT_LIST_DIR}/jsoncpp-namespaced-targets.cmake" )

meson.build

@@ -9,13 +9,13 @@ project(
   # 2. /include/json/version.h
   # 3. /CMakeLists.txt
   # IMPORTANT: also update the SOVERSION!!
-  version : '1.9.4',
+  version : '1.9.7',
   default_options : [
     'buildtype=release',
     'cpp_std=c++11',
     'warning_level=1'],
   license : 'Public Domain',
-  meson_version : '>= 0.49.0')
+  meson_version : '>= 0.54.0')
 
 
 jsoncpp_headers = files([
@@ -50,7 +50,7 @@ jsoncpp_lib = library(
     'src/lib_json/json_value.cpp',
     'src/lib_json/json_writer.cpp',
   ]),
-  soversion : 25,
+  soversion : 27,
   install : true,
   include_directories : jsoncpp_include_directories,
   cpp_args: dll_export_flag)
@@ -62,6 +62,43 @@ import('pkgconfig').generate(
   filebase : 'jsoncpp',
   description : 'A C++ library for interacting with JSON')
 
+cmakeconf = configuration_data()
+cmakeconf.set('MESON_LIB_DIR', get_option('libdir'))
+cmakeconf.set('MESON_INCLUDE_DIR', get_option('includedir'))
+
+fs = import('fs')
+if get_option('default_library') == 'shared'
+  shared_name = fs.name(jsoncpp_lib.full_path())
+endif
+if get_option('default_library') == 'static'
+  static_name = fs.name(jsoncpp_lib.full_path())
+endif
+if get_option('default_library') == 'both'
+  shared_name = fs.name(jsoncpp_lib.get_shared_lib().full_path())
+  static_name = fs.name(jsoncpp_lib.get_static_lib().full_path())
+endif
+
+if get_option('default_library') == 'shared' or get_option('default_library') == 'both'
+   cmakeconf.set('MESON_SHARED_TARGET', '''
+add_library(jsoncpp_lib IMPORTED SHARED)
+set_target_properties(jsoncpp_lib PROPERTIES
+  IMPORTED_LOCATION "''' + join_paths('${PACKAGE_PREFIX_DIR}', get_option('libdir'), shared_name) + '''"
+  INTERFACE_INCLUDE_DIRECTORIES "''' + join_paths('${PACKAGE_PREFIX_DIR}', get_option('includedir')) + '")')
+endif
+if get_option('default_library') == 'static' or get_option('default_library') == 'both'
+   cmakeconf.set('MESON_STATIC_TARGET', '''
+add_library(jsoncpp_static IMPORTED STATIC)
+set_target_properties(jsoncpp_static PROPERTIES
+  IMPORTED_LOCATION "''' + join_paths('${PACKAGE_PREFIX_DIR}', get_option('libdir'), static_name) + '''"
+  INTERFACE_INCLUDE_DIRECTORIES "''' + join_paths('${PACKAGE_PREFIX_DIR}', get_option('includedir')) + '")')
+endif
+
+import('cmake').configure_package_config_file(
+  name: 'jsoncpp',
+  input: 'jsoncppConfig.cmake.meson.in',
+  configuration: cmakeconf)
+install_data('jsoncpp-namespaced-targets.cmake', install_dir : join_paths(get_option('libdir'), 'cmake', jsoncpp_lib.name()))
+
 # for libraries bundling jsoncpp
 jsoncpp_dep = declare_dependency(
   include_directories : jsoncpp_include_directories,
@@ -73,7 +110,7 @@ if meson.is_subproject() or not get_option('tests')
   subdir_done()
 endif
 
-python = import('python').find_installation()
+python = find_program('python3')
 
 jsoncpp_test = executable(
   'jsoncpp_test', files([

src/jsontestrunner/main.cpp

@@ -240,11 +240,14 @@ static int parseCommandLine(int argc, const char* argv[], Options* opts) {
     return printUsage(argv);
   }
   int index = 1;
-  if (Json::String(argv[index]) == "--json-checker") {
-    opts->features = Json::Features::strictMode();
+  if (Json::String(argv[index]) == "--parse-only") {
     opts->parseOnly = true;
     ++index;
   }
+  if (Json::String(argv[index]) == "--strict") {
+    opts->features = Json::Features::strictMode();
+    ++index;
+  }
   if (Json::String(argv[index]) == "--json-config") {
     printConfig();
     return 3;

src/lib_json/CMakeLists.txt

@@ -132,7 +132,6 @@ if(BUILD_SHARED_LIBS)
     target_include_directories(${SHARED_LIB} PUBLIC
         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
         $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
-        $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
     )
 
     list(APPEND CMAKE_TARGETS ${SHARED_LIB})
@@ -142,9 +141,9 @@ if(BUILD_STATIC_LIBS)
     set(STATIC_LIB ${PROJECT_NAME}_static)
     add_library(${STATIC_LIB} STATIC ${PUBLIC_HEADERS} ${JSONCPP_SOURCES})
 
-    # avoid name clashes on windows as the shared import lib is alse named jsoncpp.lib
+    # avoid name clashes on windows as the shared import lib is also named jsoncpp.lib
     if(NOT DEFINED STATIC_SUFFIX AND BUILD_SHARED_LIBS)
-        if (MSVC)
+        if (MSVC OR ("${CMAKE_C_SIMULATE_ID}" STREQUAL "MSVC"))
             set(STATIC_SUFFIX "_static")
         else()
             set(STATIC_SUFFIX "")
@@ -166,7 +165,6 @@ if(BUILD_STATIC_LIBS)
     target_include_directories(${STATIC_LIB} PUBLIC
         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
         $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
-        $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
     )
 
     list(APPEND CMAKE_TARGETS ${STATIC_LIB})
@@ -193,7 +191,6 @@ if(BUILD_OBJECT_LIBS)
     target_include_directories(${OBJECT_LIB} PUBLIC
         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
         $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
-        $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
     )
 
     list(APPEND CMAKE_TARGETS ${OBJECT_LIB})

src/lib_json/json_reader.cpp

@@ -12,6 +12,7 @@
 #endif // if !defined(JSON_IS_AMALGAMATION)
 #include <algorithm>
 #include <cassert>
+#include <cmath>
 #include <cstring>
 #include <iostream>
 #include <istream>
@@ -22,13 +23,6 @@
 #include <utility>
 
 #include <cstdio>
-#if __cplusplus >= 201103L
-
-#if !defined(sscanf)
-#define sscanf std::sscanf
-#endif
-
-#endif //__cplusplus
 
 #if defined(_MSC_VER)
 #if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
@@ -52,11 +46,7 @@ static size_t const stackLimit_g =
 
 namespace Json {
 
-#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
 using CharReaderPtr = std::unique_ptr<CharReader>;
-#else
-using CharReaderPtr = std::auto_ptr<CharReader>;
-#endif
 
 // Implementation of class Features
 // ////////////////////////////////
@@ -128,7 +118,7 @@ bool Reader::parse(const char* beginDoc, const char* endDoc, Value& root,
 
   bool successful = readValue();
   Token token;
-  skipCommentTokens(token);
+  readTokenSkippingComments(token);
   if (collectComments_ && !commentsBefore_.empty())
     root.setComment(commentsBefore_, commentAfter);
   if (features_.strictRoot_) {
@@ -156,7 +146,7 @@ bool Reader::readValue() {
     throwRuntimeError("Exceeded stackLimit in readValue().");
 
   Token token;
-  skipCommentTokens(token);
+  readTokenSkippingComments(token);
   bool successful = true;
 
   if (collectComments_ && !commentsBefore_.empty()) {
@@ -224,14 +214,14 @@ bool Reader::readValue() {
   return successful;
 }
 
-void Reader::skipCommentTokens(Token& token) {
+bool Reader::readTokenSkippingComments(Token& token) {
+  bool success = readToken(token);
   if (features_.allowComments_) {
-    do {
-      readToken(token);
-    } while (token.type_ == tokenComment);
-  } else {
-    readToken(token);
+    while (success && token.type_ == tokenComment) {
+      success = readToken(token);
+    }
   }
+  return success;
 }
 
 bool Reader::readToken(Token& token) {
@@ -445,12 +435,7 @@ bool Reader::readObject(Token& token) {
   Value init(objectValue);
   currentValue().swapPayload(init);
   currentValue().setOffsetStart(token.start_ - begin_);
-  while (readToken(tokenName)) {
-    bool initialTokenOk = true;
-    while (tokenName.type_ == tokenComment && initialTokenOk)
-      initialTokenOk = readToken(tokenName);
-    if (!initialTokenOk)
-      break;
+  while (readTokenSkippingComments(tokenName)) {
     if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
       return true;
     name.clear();
@@ -479,15 +464,11 @@ bool Reader::readObject(Token& token) {
       return recoverFromError(tokenObjectEnd);
 
     Token comma;
-    if (!readToken(comma) ||
-        (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
-         comma.type_ != tokenComment)) {
+    if (!readTokenSkippingComments(comma) ||
+        (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator)) {
       return addErrorAndRecover("Missing ',' or '}' in object declaration",
                                 comma, tokenObjectEnd);
     }
-    bool finalizeTokenOk = true;
-    while (comma.type_ == tokenComment && finalizeTokenOk)
-      finalizeTokenOk = readToken(comma);
     if (comma.type_ == tokenObjectEnd)
       return true;
   }
@@ -517,10 +498,7 @@ bool Reader::readArray(Token& token) {
 
     Token currentToken;
     // Accept Comment after last item in the array.
-    ok = readToken(currentToken);
-    while (currentToken.type_ == tokenComment && ok) {
-      ok = readToken(currentToken);
-    }
+    ok = readTokenSkippingComments(currentToken);
     bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
                          currentToken.type_ != tokenArrayEnd);
     if (!ok || badTokenType) {
@@ -598,11 +576,16 @@ bool Reader::decodeDouble(Token& token) {
 
 bool Reader::decodeDouble(Token& token, Value& decoded) {
   double value = 0;
-  String buffer(token.start_, token.end_);
-  IStringStream is(buffer);
-  if (!(is >> value))
-    return addError(
-        "'" + String(token.start_, token.end_) + "' is not a number.", token);
+  IStringStream is(String(token.start_, token.end_));
+  if (!(is >> value)) {
+    if (value == std::numeric_limits<double>::max())
+      value = std::numeric_limits<double>::infinity();
+    else if (value == std::numeric_limits<double>::lowest())
+      value = -std::numeric_limits<double>::infinity();
+    else if (!std::isinf(value))
+      return addError(
+          "'" + String(token.start_, token.end_) + "' is not a number.", token);
+  }
   decoded = value;
   return true;
 }
@@ -766,7 +749,7 @@ void Reader::getLocationLineAndColumn(Location location, int& line,
   while (current < location && current != end_) {
     Char c = *current++;
     if (c == '\r') {
-      if (*current == '\n')
+      if (current != end_ && *current == '\n')
         ++current;
       lastLineStart = current;
       ++line;
@@ -883,17 +866,12 @@ class OurReader {
 public:
   using Char = char;
   using Location = const Char*;
-  struct StructuredError {
-    ptrdiff_t offset_start;
-    ptrdiff_t offset_limit;
-    String message;
-  };
 
   explicit OurReader(OurFeatures const& features);
   bool parse(const char* beginDoc, const char* endDoc, Value& root,
              bool collectComments = true);
   String getFormattedErrorMessages() const;
-  std::vector<StructuredError> getStructuredErrors() const;
+  std::vector<CharReader::StructuredError> getStructuredErrors() const;
 
 private:
   OurReader(OurReader const&);      // no impl
@@ -936,6 +914,7 @@ private:
   using Errors = std::deque<ErrorInfo>;
 
   bool readToken(Token& token);
+  bool readTokenSkippingComments(Token& token);
   void skipSpaces();
   void skipBom(bool skipBom);
   bool match(const Char* pattern, int patternLength);
@@ -969,7 +948,6 @@ private:
                                 int& column) const;
   String getLocationLineAndColumn(Location location) const;
   void addComment(Location begin, Location end, CommentPlacement placement);
-  void skipCommentTokens(Token& token);
 
   static String normalizeEOL(Location begin, Location end);
   static bool containsNewLine(Location begin, Location end);
@@ -1023,7 +1001,7 @@ bool OurReader::parse(const char* beginDoc, const char* endDoc, Value& root,
   bool successful = readValue();
   nodes_.pop();
   Token token;
-  skipCommentTokens(token);
+  readTokenSkippingComments(token);
   if (features_.failIfExtra_ && (token.type_ != tokenEndOfStream)) {
     addError("Extra non-whitespace after JSON value.", token);
     return false;
@@ -1051,7 +1029,7 @@ bool OurReader::readValue() {
   if (nodes_.size() > features_.stackLimit_)
     throwRuntimeError("Exceeded stackLimit in readValue().");
   Token token;
-  skipCommentTokens(token);
+  readTokenSkippingComments(token);
   bool successful = true;
 
   if (collectComments_ && !commentsBefore_.empty()) {
@@ -1138,14 +1116,14 @@ bool OurReader::readValue() {
   return successful;
 }
 
-void OurReader::skipCommentTokens(Token& token) {
+bool OurReader::readTokenSkippingComments(Token& token) {
+  bool success = readToken(token);
   if (features_.allowComments_) {
-    do {
-      readToken(token);
-    } while (token.type_ == tokenComment);
-  } else {
-    readToken(token);
+    while (success && token.type_ == tokenComment) {
+      success = readToken(token);
+    }
   }
+  return success;
 }
 
 bool OurReader::readToken(Token& token) {
@@ -1442,12 +1420,7 @@ bool OurReader::readObject(Token& token) {
   Value init(objectValue);
   currentValue().swapPayload(init);
   currentValue().setOffsetStart(token.start_ - begin_);
-  while (readToken(tokenName)) {
-    bool initialTokenOk = true;
-    while (tokenName.type_ == tokenComment && initialTokenOk)
-      initialTokenOk = readToken(tokenName);
-    if (!initialTokenOk)
-      break;
+  while (readTokenSkippingComments(tokenName)) {
     if (tokenName.type_ == tokenObjectEnd &&
         (name.empty() ||
          features_.allowTrailingCommas_)) // empty object or trailing comma
@@ -1484,15 +1457,11 @@ bool OurReader::readObject(Token& token) {
       return recoverFromError(tokenObjectEnd);
 
     Token comma;
-    if (!readToken(comma) ||
-        (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
-         comma.type_ != tokenComment)) {
+    if (!readTokenSkippingComments(comma) ||
+        (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator)) {
       return addErrorAndRecover("Missing ',' or '}' in object declaration",
                                 comma, tokenObjectEnd);
     }
-    bool finalizeTokenOk = true;
-    while (comma.type_ == tokenComment && finalizeTokenOk)
-      finalizeTokenOk = readToken(comma);
     if (comma.type_ == tokenObjectEnd)
       return true;
   }
@@ -1526,10 +1495,7 @@ bool OurReader::readArray(Token& token) {
 
     Token currentToken;
     // Accept Comment after last item in the array.
-    ok = readToken(currentToken);
-    while (currentToken.type_ == tokenComment && ok) {
-      ok = readToken(currentToken);
-    }
+    ok = readTokenSkippingComments(currentToken);
     bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
                          currentToken.type_ != tokenArrayEnd);
     if (!ok || badTokenType) {
@@ -1607,7 +1573,7 @@ bool OurReader::decodeNumber(Token& token, Value& decoded) {
     const auto digit(static_cast<Value::UInt>(c - '0'));
     if (value >= threshold) {
       // We've hit or exceeded the max value divided by 10 (rounded down). If
-      // a) we've only just touched the limit, meaing value == threshold,
+      // a) we've only just touched the limit, meaning value == threshold,
       // b) this is the last digit, or
       // c) it's small enough to fit in that rounding delta, we're okay.
       // Otherwise treat this number as a double to avoid overflow.
@@ -1644,11 +1610,15 @@ bool OurReader::decodeDouble(Token& token) {
 
 bool OurReader::decodeDouble(Token& token, Value& decoded) {
   double value = 0;
-  const String buffer(token.start_, token.end_);
-  IStringStream is(buffer);
+  IStringStream is(String(token.start_, token.end_));
   if (!(is >> value)) {
-    return addError(
-        "'" + String(token.start_, token.end_) + "' is not a number.", token);
+    if (value == std::numeric_limits<double>::max())
+      value = std::numeric_limits<double>::infinity();
+    else if (value == std::numeric_limits<double>::lowest())
+      value = -std::numeric_limits<double>::infinity();
+    else if (!std::isinf(value))
+      return addError(
+          "'" + String(token.start_, token.end_) + "' is not a number.", token);
   }
   decoded = value;
   return true;
@@ -1813,7 +1783,7 @@ void OurReader::getLocationLineAndColumn(Location location, int& line,
   while (current < location && current != end_) {
     Char c = *current++;
     if (c == '\r') {
-      if (*current == '\n')
+      if (current != end_ && *current == '\n')
         ++current;
       lastLineStart = current;
       ++line;
@@ -1848,10 +1818,11 @@ String OurReader::getFormattedErrorMessages() const {
   return formattedMessage;
 }
 
-std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
-  std::vector<OurReader::StructuredError> allErrors;
+std::vector<CharReader::StructuredError>
+OurReader::getStructuredErrors() const {
+  std::vector<CharReader::StructuredError> allErrors;
   for (const auto& error : errors_) {
-    OurReader::StructuredError structured;
+    CharReader::StructuredError structured;
     structured.offset_start = error.token_.start_ - begin_;
     structured.offset_limit = error.token_.end_ - begin_;
     structured.message = error.message_;
@@ -1861,20 +1832,36 @@ std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
 }
 
 class OurCharReader : public CharReader {
-  bool const collectComments_;
-  OurReader reader_;
 
 public:
   OurCharReader(bool collectComments, OurFeatures const& features)
-      : collectComments_(collectComments), reader_(features) {}
-  bool parse(char const* beginDoc, char const* endDoc, Value* root,
-             String* errs) override {
-    bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
-    if (errs) {
-      *errs = reader_.getFormattedErrorMessages();
+      : CharReader(
+            std::unique_ptr<OurImpl>(new OurImpl(collectComments, features))) {}
+
+protected:
+  class OurImpl : public Impl {
+  public:
+    OurImpl(bool collectComments, OurFeatures const& features)
+        : collectComments_(collectComments), reader_(features) {}
+
+    bool parse(char const* beginDoc, char const* endDoc, Value* root,
+               String* errs) override {
+      bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
+      if (errs) {
+        *errs = reader_.getFormattedErrorMessages();
+      }
+      return ok;
     }
-    return ok;
-  }
+
+    std::vector<CharReader::StructuredError>
+    getStructuredErrors() const override {
+      return reader_.getStructuredErrors();
+    }
+
+  private:
+    bool const collectComments_;
+    OurReader reader_;
+  };
 };
 
 CharReaderBuilder::CharReaderBuilder() { setDefaults(&settings_); }
@@ -1963,6 +1950,32 @@ void CharReaderBuilder::setDefaults(Json::Value* settings) {
   (*settings)["skipBom"] = true;
   //! [CharReaderBuilderDefaults]
 }
+// static
+void CharReaderBuilder::ecma404Mode(Json::Value* settings) {
+  //! [CharReaderBuilderECMA404Mode]
+  (*settings)["allowComments"] = false;
+  (*settings)["allowTrailingCommas"] = false;
+  (*settings)["strictRoot"] = false;
+  (*settings)["allowDroppedNullPlaceholders"] = false;
+  (*settings)["allowNumericKeys"] = false;
+  (*settings)["allowSingleQuotes"] = false;
+  (*settings)["stackLimit"] = 1000;
+  (*settings)["failIfExtra"] = true;
+  (*settings)["rejectDupKeys"] = false;
+  (*settings)["allowSpecialFloats"] = false;
+  (*settings)["skipBom"] = false;
+  //! [CharReaderBuilderECMA404Mode]
+}
+
+std::vector<CharReader::StructuredError>
+CharReader::getStructuredErrors() const {
+  return _impl->getStructuredErrors();
+}
+
+bool CharReader::parse(char const* beginDoc, char const* endDoc, Value* root,
+                       String* errs) {
+  return _impl->parse(beginDoc, endDoc, root, errs);
+}
 
 //////////////////////////////////
 // global functions
@@ -1971,7 +1984,7 @@ bool parseFromStream(CharReader::Factory const& fact, IStream& sin, Value* root,
                      String* errs) {
   OStringStream ssin;
   ssin << sin.rdbuf();
-  String doc = ssin.str();
+  String doc = std::move(ssin).str();
   char const* begin = doc.data();
   char const* end = begin + doc.size();
   // Note that we do not actually need a null-terminator.

src/lib_json/json_value.cpp

@@ -17,6 +17,10 @@
 #include <sstream>
 #include <utility>
 
+#ifdef JSONCPP_HAS_STRING_VIEW
+#include <string_view>
+#endif
+
 // Provide implementation equivalent of std::snprintf for older _MSC compilers
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #include <stdarg.h>
@@ -87,7 +91,8 @@ template <typename T, typename U>
 static inline bool InRange(double d, T min, U max) {
   // The casts can lose precision, but we are looking only for
   // an approximate range. Might fail on edge cases though. ~cdunn
-  return d >= static_cast<double>(min) && d <= static_cast<double>(max);
+  return d >= static_cast<double>(min) && d <= static_cast<double>(max) &&
+         !(static_cast<U>(d) == min && d != static_cast<double>(min));
 }
 #else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
 static inline double integerToDouble(Json::UInt64 value) {
@@ -101,7 +106,8 @@ template <typename T> static inline double integerToDouble(T value) {
 
 template <typename T, typename U>
 static inline bool InRange(double d, T min, U max) {
-  return d >= integerToDouble(min) && d <= integerToDouble(max);
+  return d >= integerToDouble(min) && d <= integerToDouble(max) &&
+         !(static_cast<U>(d) == min && d != integerToDouble(min));
 }
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
 
@@ -163,7 +169,7 @@ inline static void decodePrefixedString(bool isPrefixed, char const* prefixed,
 /** Free the string duplicated by
  * duplicateStringValue()/duplicateAndPrefixStringValue().
  */
-#if JSONCPP_USING_SECURE_MEMORY
+#if JSONCPP_USE_SECURE_MEMORY
 static inline void releasePrefixedStringValue(char* value) {
   unsigned length = 0;
   char const* valueDecoded;
@@ -178,10 +184,10 @@ static inline void releaseStringValue(char* value, unsigned length) {
   memset(value, 0, size);
   free(value);
 }
-#else  // !JSONCPP_USING_SECURE_MEMORY
+#else  // !JSONCPP_USE_SECURE_MEMORY
 static inline void releasePrefixedStringValue(char* value) { free(value); }
 static inline void releaseStringValue(char* value, unsigned) { free(value); }
-#endif // JSONCPP_USING_SECURE_MEMORY
+#endif // JSONCPP_USE_SECURE_MEMORY
 
 } // namespace Json
 
@@ -418,6 +424,14 @@ Value::Value(const String& value) {
       value.data(), static_cast<unsigned>(value.length()));
 }
 
+#ifdef JSONCPP_HAS_STRING_VIEW
+Value::Value(std::string_view value) {
+  initBasic(stringValue, true);
+  value_.string_ = duplicateAndPrefixStringValue(
+      value.data(), static_cast<unsigned>(value.length()));
+}
+#endif
+
 Value::Value(const StaticString& value) {
   initBasic(stringValue);
   value_.string_ = const_cast<char*>(value.c_str());
@@ -599,7 +613,7 @@ const char* Value::asCString() const {
   return this_str;
 }
 
-#if JSONCPP_USING_SECURE_MEMORY
+#if JSONCPP_USE_SECURE_MEMORY
 unsigned Value::getCStringLength() const {
   JSON_ASSERT_MESSAGE(type() == stringValue,
                       "in Json::Value::asCString(): requires stringValue");
@@ -625,6 +639,21 @@ bool Value::getString(char const** begin, char const** end) const {
   return true;
 }
 
+#ifdef JSONCPP_HAS_STRING_VIEW
+bool Value::getString(std::string_view* str) const {
+  if (type() != stringValue)
+    return false;
+  if (value_.string_ == nullptr)
+    return false;
+  const char* begin;
+  unsigned length;
+  decodePrefixedString(this->isAllocated(), this->value_.string_, &length,
+                       &begin);
+  *str = std::string_view(begin, length);
+  return true;
+}
+#endif
+
 String Value::asString() const {
   switch (type()) {
   case nullValue:
@@ -682,7 +711,7 @@ Value::UInt Value::asUInt() const {
     JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
     return UInt(value_.uint_);
   case realValue:
-    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0u, maxUInt),
                         "double out of UInt range");
     return UInt(value_.real_);
   case nullValue:
@@ -705,6 +734,11 @@ Value::Int64 Value::asInt64() const {
     JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
     return Int64(value_.uint_);
   case realValue:
+    // If the double value is in proximity to minInt64, it will be rounded to
+    // minInt64. The correct value in this scenario is indeterminable
+    JSON_ASSERT_MESSAGE(
+        value_.real_ != minInt64,
+        "Double value is minInt64, precise value cannot be determined");
     JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
                         "double out of Int64 range");
     return Int64(value_.real_);
@@ -726,7 +760,7 @@ Value::UInt64 Value::asUInt64() const {
   case uintValue:
     return UInt64(value_.uint_);
   case realValue:
-    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0u, maxUInt64),
                         "double out of UInt64 range");
     return UInt64(value_.real_);
   case nullValue:
@@ -837,7 +871,7 @@ bool Value::isConvertibleTo(ValueType other) const {
            type() == booleanValue || type() == nullValue;
   case uintValue:
     return isUInt() ||
-           (type() == realValue && InRange(value_.real_, 0, maxUInt)) ||
+           (type() == realValue && InRange(value_.real_, 0u, maxUInt)) ||
            type() == booleanValue || type() == nullValue;
   case realValue:
     return isNumeric() || type() == booleanValue || type() == nullValue;
@@ -1092,12 +1126,64 @@ Value const* Value::find(char const* begin, char const* end) const {
     return nullptr;
   return &(*it).second;
 }
+Value const* Value::find(const String& key) const {
+  return find(key.data(), key.data() + key.length());
+}
+
+Value const* Value::findNull(const String& key) const {
+  return findValue<Value, &Value::isNull>(key);
+}
+Value const* Value::findBool(const String& key) const {
+  return findValue<Value, &Value::isBool>(key);
+}
+Value const* Value::findInt(const String& key) const {
+  return findValue<Value, &Value::isInt>(key);
+}
+Value const* Value::findInt64(const String& key) const {
+  return findValue<Value, &Value::isInt64>(key);
+}
+Value const* Value::findUInt(const String& key) const {
+  return findValue<Value, &Value::isUInt>(key);
+}
+Value const* Value::findUInt64(const String& key) const {
+  return findValue<Value, &Value::isUInt64>(key);
+}
+Value const* Value::findIntegral(const String& key) const {
+  return findValue<Value, &Value::isIntegral>(key);
+}
+Value const* Value::findDouble(const String& key) const {
+  return findValue<Value, &Value::isDouble>(key);
+}
+Value const* Value::findNumeric(const String& key) const {
+  return findValue<Value, &Value::isNumeric>(key);
+}
+Value const* Value::findString(const String& key) const {
+  return findValue<Value, &Value::isString>(key);
+}
+Value const* Value::findArray(const String& key) const {
+  return findValue<Value, &Value::isArray>(key);
+}
+Value const* Value::findObject(const String& key) const {
+  return findValue<Value, &Value::isObject>(key);
+}
+
 Value* Value::demand(char const* begin, char const* end) {
   JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
                       "in Json::Value::demand(begin, end): requires "
                       "objectValue or nullValue");
   return &resolveReference(begin, end);
 }
+#ifdef JSONCPP_HAS_STRING_VIEW
+const Value& Value::operator[](std::string_view key) const {
+  Value const* found = find(key.data(), key.data() + key.length());
+  if (!found)
+    return nullSingleton();
+  return *found;
+}
+Value& Value::operator[](std::string_view key) {
+  return resolveReference(key.data(), key.data() + key.length());
+}
+#else
 const Value& Value::operator[](const char* key) const {
   Value const* found = find(key, key + strlen(key));
   if (!found)
@@ -1105,7 +1191,7 @@ const Value& Value::operator[](const char* key) const {
   return *found;
 }
 Value const& Value::operator[](const String& key) const {
-  Value const* found = find(key.data(), key.data() + key.length());
+  Value const* found = find(key);
   if (!found)
     return nullSingleton();
   return *found;
@@ -1118,6 +1204,7 @@ Value& Value::operator[](const char* key) {
 Value& Value::operator[](const String& key) {
   return resolveReference(key.data(), key.data() + key.length());
 }
+#endif
 
 Value& Value::operator[](const StaticString& key) {
   return resolveReference(key.c_str());
@@ -1157,12 +1244,18 @@ Value Value::get(char const* begin, char const* end,
   Value const* found = find(begin, end);
   return !found ? defaultValue : *found;
 }
+#ifdef JSONCPP_HAS_STRING_VIEW
+Value Value::get(std::string_view key, const Value& defaultValue) const {
+  return get(key.data(), key.data() + key.length(), defaultValue);
+}
+#else
 Value Value::get(char const* key, Value const& defaultValue) const {
   return get(key, key + strlen(key), defaultValue);
 }
 Value Value::get(String const& key, Value const& defaultValue) const {
   return get(key.data(), key.data() + key.length(), defaultValue);
 }
+#endif
 
 bool Value::removeMember(const char* begin, const char* end, Value* removed) {
   if (type() != objectValue) {
@@ -1178,12 +1271,31 @@ bool Value::removeMember(const char* begin, const char* end, Value* removed) {
   value_.map_->erase(it);
   return true;
 }
+#ifdef JSONCPP_HAS_STRING_VIEW
+bool Value::removeMember(std::string_view key, Value* removed) {
+  return removeMember(key.data(), key.data() + key.length(), removed);
+}
+#else
 bool Value::removeMember(const char* key, Value* removed) {
   return removeMember(key, key + strlen(key), removed);
 }
 bool Value::removeMember(String const& key, Value* removed) {
   return removeMember(key.data(), key.data() + key.length(), removed);
 }
+#endif
+
+#ifdef JSONCPP_HAS_STRING_VIEW
+void Value::removeMember(std::string_view key) {
+  JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
+                      "in Json::Value::removeMember(): requires objectValue");
+  if (type() == nullValue)
+    return;
+
+  CZString actualKey(key.data(), unsigned(key.length()),
+                     CZString::noDuplication);
+  value_.map_->erase(actualKey);
+}
+#else
 void Value::removeMember(const char* key) {
   JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
                       "in Json::Value::removeMember(): requires objectValue");
@@ -1194,6 +1306,7 @@ void Value::removeMember(const char* key) {
   value_.map_->erase(actualKey);
 }
 void Value::removeMember(const String& key) { removeMember(key.c_str()); }
+#endif
 
 bool Value::removeIndex(ArrayIndex index, Value* removed) {
   if (type() != arrayValue) {
@@ -1205,7 +1318,7 @@ bool Value::removeIndex(ArrayIndex index, Value* removed) {
     return false;
   }
   if (removed)
-    *removed = it->second;
+    *removed = std::move(it->second);
   ArrayIndex oldSize = size();
   // shift left all items left, into the place of the "removed"
   for (ArrayIndex i = index; i < (oldSize - 1); ++i) {
@@ -1223,12 +1336,18 @@ bool Value::isMember(char const* begin, char const* end) const {
   Value const* value = find(begin, end);
   return nullptr != value;
 }
+#ifdef JSONCPP_HAS_STRING_VIEW
+bool Value::isMember(std::string_view key) const {
+  return isMember(key.data(), key.data() + key.length());
+}
+#else
 bool Value::isMember(char const* key) const {
   return isMember(key, key + strlen(key));
 }
 bool Value::isMember(String const& key) const {
   return isMember(key.data(), key.data() + key.length());
 }
+#endif
 
 Value::Members Value::getMemberNames() const {
   JSON_ASSERT_MESSAGE(
@@ -1308,8 +1427,12 @@ bool Value::isInt64() const {
     // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
     // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
     // require the value to be strictly less than the limit.
-    return value_.real_ >= double(minInt64) &&
-           value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
+    // minInt64 is -2^63 which can be represented as a double, but since double
+    // values in its proximity are also rounded to -2^63, we require the value
+    // to be strictly greater than the limit to avoid returning 'true' for
+    // values that are not in the range
+    return value_.real_ > double(minInt64) && value_.real_ < double(maxInt64) &&
+           IsIntegral(value_.real_);
   default:
     break;
   }
@@ -1347,7 +1470,11 @@ bool Value::isIntegral() const {
     // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
     // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
     // require the value to be strictly less than the limit.
-    return value_.real_ >= double(minInt64) &&
+    // minInt64 is -2^63 which can be represented as a double, but since double
+    // values in its proximity are also rounded to -2^63, we require the value
+    // to be strictly greater than the limit to avoid returning 'true' for
+    // values that are not in the range
+    return value_.real_ > double(minInt64) &&
            value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
 #else
     return value_.real_ >= minInt && value_.real_ <= maxUInt &&
@@ -1410,9 +1537,8 @@ void Value::setComment(String comment, CommentPlacement placement) {
     // Always discard trailing newline, to aid indentation.
     comment.pop_back();
   }
-  JSON_ASSERT(!comment.empty());
   JSON_ASSERT_MESSAGE(
-      comment[0] == '\0' || comment[0] == '/',
+      comment.empty() || comment[0] == '/',
       "in Json::Value::setComment(): Comments must start with /");
   comments_.set(placement, std::move(comment));
 }

src/lib_json/json_writer.cpp

@@ -10,6 +10,8 @@
 #include <algorithm>
 #include <cassert>
 #include <cctype>
+#include <cmath>
+#include <cstdio>
 #include <cstring>
 #include <iomanip>
 #include <memory>
@@ -17,67 +19,6 @@
 #include <sstream>
 #include <utility>
 
-#if __cplusplus >= 201103L
-#include <cmath>
-#include <cstdio>
-
-#if !defined(isnan)
-#define isnan std::isnan
-#endif
-
-#if !defined(isfinite)
-#define isfinite std::isfinite
-#endif
-
-#else
-#include <cmath>
-#include <cstdio>
-
-#if defined(_MSC_VER)
-#if !defined(isnan)
-#include <float.h>
-#define isnan _isnan
-#endif
-
-#if !defined(isfinite)
-#include <float.h>
-#define isfinite _finite
-#endif
-
-#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
-#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
-#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
-
-#endif //_MSC_VER
-
-#if defined(__sun) && defined(__SVR4) // Solaris
-#if !defined(isfinite)
-#include <ieeefp.h>
-#define isfinite finite
-#endif
-#endif
-
-#if defined(__hpux)
-#if !defined(isfinite)
-#if defined(__ia64) && !defined(finite)
-#define isfinite(x)                                                            \
-  ((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _IsFinite(x)))
-#endif
-#endif
-#endif
-
-#if !defined(isnan)
-// IEEE standard states that NaN values will not compare to themselves
-#define isnan(x) ((x) != (x))
-#endif
-
-#if !defined(__APPLE__)
-#if !defined(isfinite)
-#define isfinite finite
-#endif
-#endif
-#endif
-
 #if defined(_MSC_VER)
 // Disable warning about strdup being deprecated.
 #pragma warning(disable : 4996)
@@ -85,11 +26,7 @@
 
 namespace Json {
 
-#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
 using StreamWriterPtr = std::unique_ptr<StreamWriter>;
-#else
-using StreamWriterPtr = std::auto_ptr<StreamWriter>;
-#endif
 
 String valueToString(LargestInt value) {
   UIntToStringBuffer buffer;
@@ -129,11 +66,12 @@ String valueToString(double value, bool useSpecialFloats,
   // Print into the buffer. We need not request the alternative representation
   // that always has a decimal point because JSON doesn't distinguish the
   // concepts of reals and integers.
-  if (!isfinite(value)) {
-    static const char* const reps[2][3] = {{"NaN", "-Infinity", "Infinity"},
-                                           {"null", "-1e+9999", "1e+9999"}};
-    return reps[useSpecialFloats ? 0 : 1]
-               [isnan(value) ? 0 : (value < 0) ? 1 : 2];
+  if (!std::isfinite(value)) {
+    if (std::isnan(value))
+      return useSpecialFloats ? "NaN" : "null";
+    if (value < 0)
+      return useSpecialFloats ? "-Infinity" : "-1e+9999";
+    return useSpecialFloats ? "Infinity" : "1e+9999";
   }
 
   String buffer(size_t(36), '\0');
@@ -353,6 +291,10 @@ String valueToQuotedString(const char* value) {
   return valueToQuotedStringN(value, strlen(value));
 }
 
+String valueToQuotedString(const char* value, size_t length) {
+  return valueToQuotedStringN(value, length);
+}
+
 // Class Writer
 // //////////////////////////////////////////////////////////////////
 Writer::~Writer() = default;
@@ -490,7 +432,7 @@ void StyledWriter::writeValue(const Value& value) {
         const String& name = *it;
         const Value& childValue = value[name];
         writeCommentBeforeValue(childValue);
-        writeWithIndent(valueToQuotedString(name.c_str()));
+        writeWithIndent(valueToQuotedString(name.c_str(), name.size()));
         document_ += " : ";
         writeValue(childValue);
         if (++it == members.end()) {
@@ -708,7 +650,7 @@ void StyledStreamWriter::writeValue(const Value& value) {
         const String& name = *it;
         const Value& childValue = value[name];
         writeCommentBeforeValue(childValue);
-        writeWithIndent(valueToQuotedString(name.c_str()));
+        writeWithIndent(valueToQuotedString(name.c_str(), name.size()));
         *document_ << " : ";
         writeValue(childValue);
         if (++it == members.end()) {
@@ -1246,7 +1188,7 @@ String writeString(StreamWriter::Factory const& factory, Value const& root) {
   OStringStream sout;
   StreamWriterPtr const writer(factory.newStreamWriter());
   writer->write(root, &sout);
-  return sout.str();
+  return std::move(sout).str();
 }
 
 OStream& operator<<(OStream& sout, Value const& root) {

src/test_lib_json/jsontest.cpp

@@ -410,7 +410,7 @@ Json::String ToJsonString(const char* toConvert) {
 
 Json::String ToJsonString(Json::String in) { return in; }
 
-#if JSONCPP_USING_SECURE_MEMORY
+#if JSONCPP_USE_SECURE_MEMORY
 Json::String ToJsonString(std::string in) {
   return Json::String(in.data(), in.data() + in.length());
 }

src/test_lib_json/jsontest.h

@@ -74,7 +74,7 @@ public:
 
   /// Removes the last PredicateContext added to the predicate stack
   /// chained list.
-  /// Next messages will be targed at the PredicateContext that was removed.
+  /// Next messages will be targeted at the PredicateContext that was removed.
   TestResult& popPredicateContext();
 
   bool failed() const;
@@ -185,7 +185,7 @@ TestResult& checkEqual(TestResult& result, T expected, U actual,
 
 Json::String ToJsonString(const char* toConvert);
 Json::String ToJsonString(Json::String in);
-#if JSONCPP_USING_SECURE_MEMORY
+#if JSONCPP_USE_SECURE_MEMORY
 Json::String ToJsonString(std::string in);
 #endif
 

src/test_lib_json/main.cpp

@@ -76,6 +76,8 @@ struct ValueTest : JsonTest::TestCase {
   Json::Value float_{0.00390625f};
   Json::Value array1_;
   Json::Value object1_;
+  Json::Value object2_;
+  Json::Value object3_;
   Json::Value emptyString_{""};
   Json::Value string1_{"a"};
   Json::Value string_{"sometext with space"};
@@ -85,6 +87,34 @@ struct ValueTest : JsonTest::TestCase {
   ValueTest() {
     array1_.append(1234);
     object1_["id"] = 1234;
+
+    // object2 with matching values
+    object2_["null"] = Json::nullValue;
+    object2_["bool"] = true;
+    object2_["int"] = Json::Int{Json::Value::maxInt};
+    object2_["int64"] = Json::Int64{Json::Value::maxInt64};
+    object2_["uint"] = Json::UInt{Json::Value::maxUInt};
+    object2_["uint64"] = Json::UInt64{Json::Value::maxUInt64};
+    object2_["integral"] = 1234;
+    object2_["double"] = 1234.56789;
+    object2_["numeric"] = 0.12345f;
+    object2_["string"] = "string";
+    object2_["array"] = Json::arrayValue;
+    object2_["object"] = Json::objectValue;
+
+    // object3 with not matching values
+    object3_["object"] = Json::nullValue;
+    object3_["null"] = true;
+    object3_["bool"] = Json::Int{Json::Value::maxInt};
+    object3_["int"] = "not_an_int";
+    object3_["int64"] = "not_an_int64";
+    object3_["uint"] = "not_an_uint";
+    object3_["uin64"] = "not_an_uint64";
+    object3_["integral"] = 1234.56789;
+    object3_["double"] = false;
+    object3_["numeric"] = "string";
+    object3_["string"] = Json::arrayValue;
+    object3_["array"] = Json::objectValue;
   }
 
   struct IsCheck {
@@ -220,11 +250,76 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, objects) {
   JSONTEST_ASSERT(foundId != nullptr);
   JSONTEST_ASSERT_EQUAL(Json::Value(1234), *foundId);
 
+  const std::string stringIdKey = "id";
+  const Json::Value* stringFoundId = object1_.find(stringIdKey);
+  JSONTEST_ASSERT(stringFoundId != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), *stringFoundId);
+
   const char unknownIdKey[] = "unknown id";
   const Json::Value* foundUnknownId =
       object1_.find(unknownIdKey, unknownIdKey + strlen(unknownIdKey));
   JSONTEST_ASSERT_EQUAL(nullptr, foundUnknownId);
 
+  const std::string stringUnknownIdKey = "unknown id";
+  const Json::Value* stringFoundUnknownId = object1_.find(stringUnknownIdKey);
+  JSONTEST_ASSERT_EQUAL(nullptr, stringFoundUnknownId);
+
+  // Access through find<Type>()
+  const Json::Value* nullFound = object2_.findNull("null");
+  JSONTEST_ASSERT(nullFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::nullValue, *nullFound);
+  JSONTEST_ASSERT(object3_.findNull("null") == nullptr);
+
+  const Json::Value* boolFound = object2_.findBool("bool");
+  JSONTEST_ASSERT(boolFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(true, *boolFound);
+  JSONTEST_ASSERT(object3_.findBool("bool") == nullptr);
+
+  const Json::Value* intFound = object2_.findInt("int");
+  JSONTEST_ASSERT(intFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::Int{Json::Value::maxInt}, *intFound);
+  JSONTEST_ASSERT(object3_.findInt("int") == nullptr);
+
+  const Json::Value* int64Found = object2_.findInt64("int64");
+  JSONTEST_ASSERT(int64Found != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::Int64{Json::Value::maxInt64}, *int64Found);
+  JSONTEST_ASSERT(object3_.findInt64("int64") == nullptr);
+
+  const Json::Value* uintFound = object2_.findUInt("uint");
+  JSONTEST_ASSERT(uintFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::UInt{Json::Value::maxUInt}, *uintFound);
+  JSONTEST_ASSERT(object3_.findUInt("uint") == nullptr);
+
+  const Json::Value* uint64Found = object2_.findUInt64("uint64");
+  JSONTEST_ASSERT(uint64Found != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::UInt64{Json::Value::maxUInt64}, *uint64Found);
+  JSONTEST_ASSERT(object3_.findUInt64("uint64") == nullptr);
+
+  const Json::Value* integralFound = object2_.findIntegral("integral");
+  JSONTEST_ASSERT(integralFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(1234, *integralFound);
+  JSONTEST_ASSERT(object3_.findIntegral("integral") == nullptr);
+
+  const Json::Value* doubleFound = object2_.findDouble("double");
+  JSONTEST_ASSERT(doubleFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(1234.56789, *doubleFound);
+  JSONTEST_ASSERT(object3_.findDouble("double") == nullptr);
+
+  const Json::Value* numericFound = object2_.findNumeric("numeric");
+  JSONTEST_ASSERT(numericFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(0.12345f, *numericFound);
+  JSONTEST_ASSERT(object3_.findNumeric("numeric") == nullptr);
+
+  const Json::Value* stringFound = object2_.findString("string");
+  JSONTEST_ASSERT(stringFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(std::string{"string"}, *stringFound);
+  JSONTEST_ASSERT(object3_.findString("string") == nullptr);
+
+  const Json::Value* arrayFound = object2_.findArray("array");
+  JSONTEST_ASSERT(arrayFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::arrayValue, *arrayFound);
+  JSONTEST_ASSERT(object3_.findArray("array") == nullptr);
+
   // Access through demand()
   const char yetAnotherIdKey[] = "yet another id";
   const Json::Value* foundYetAnotherId =
@@ -310,10 +405,14 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, arrays) {
   const Json::Value& constArray = array1_;
   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray.front());
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray.back());
 
   // Access through non-const reference
   JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
   JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_.front());
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_.back());
 
   array1_[2] = Json::Value(17);
   JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
@@ -356,6 +455,8 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, resizePopulatesAllMissingElements) {
   v.resize(n);
   JSONTEST_ASSERT_EQUAL(n, v.size());
   JSONTEST_ASSERT_EQUAL(n, std::distance(v.begin(), v.end()));
+  JSONTEST_ASSERT_EQUAL(v.front(), Json::Value{});
+  JSONTEST_ASSERT_EQUAL(v.back(), Json::Value{});
   for (const Json::Value& e : v)
     JSONTEST_ASSERT_EQUAL(e, Json::Value{});
 }
@@ -406,6 +507,8 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, arrayInsertAtRandomIndex) {
   JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[0]); // check append
   JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[1]);
   JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[2]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array.front());
+  JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array.back());
 
   // insert lvalue at the head
   JSONTEST_ASSERT(array.insert(0, str1));
@@ -413,6 +516,8 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, arrayInsertAtRandomIndex) {
   JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);
   JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[2]);
   JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[3]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array.front());
+  JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array.back());
   // checking address
   for (Json::ArrayIndex i = 0; i < 3; i++) {
     JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
@@ -425,6 +530,8 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, arrayInsertAtRandomIndex) {
   JSONTEST_ASSERT_EQUAL(Json::Value("index4"), array[2]);
   JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[3]);
   JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[4]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array.front());
+  JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array.back());
   // checking address
   for (Json::ArrayIndex i = 0; i < 4; i++) {
     JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
@@ -438,6 +545,8 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, arrayInsertAtRandomIndex) {
   JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[3]);
   JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[4]);
   JSONTEST_ASSERT_EQUAL(Json::Value("index5"), array[5]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array.front());
+  JSONTEST_ASSERT_EQUAL(Json::Value("index5"), array.back());
   // checking address
   for (Json::ArrayIndex i = 0; i < 5; i++) {
     JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
@@ -1168,15 +1277,13 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, integers) {
   JSONTEST_ASSERT_EQUAL(true, val.asBool());
   JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
 
-  // int64 min (floating point constructor). Note that kint64min *is* exactly
-  // representable as a double.
+  // int64 min (floating point constructor). Since double values in proximity of
+  // kint64min are rounded to kint64min, we don't check for conversion to int64.
   val = Json::Value(double(kint64min));
 
   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
   checks = IsCheck();
-  checks.isInt64_ = true;
-  checks.isIntegral_ = true;
   checks.isDouble_ = true;
   checks.isNumeric_ = true;
   JSONTEST_ASSERT_PRED(checkIs(val, checks));
@@ -1185,8 +1292,6 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, integers) {
   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-  JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
-  JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
   JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
   JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
   JSONTEST_ASSERT_EQUAL(true, val.asBool());
@@ -3618,12 +3723,12 @@ JSONTEST_FIXTURE_LOCAL(CharReaderAllowSpecialFloatsTest, issue209) {
   for (const auto& td : test_data) {
     bool ok = reader->parse(&*td.in.begin(), &*td.in.begin() + td.in.size(),
                             &root, &errs);
-    JSONTEST_ASSERT(td.ok == ok) << "line:" << td.line << "\n"
-                                 << "  expected: {"
-                                 << "ok:" << td.ok << ", in:\'" << td.in << "\'"
-                                 << "}\n"
-                                 << "  actual: {"
-                                 << "ok:" << ok << "}\n";
+    // clang-format off
+    JSONTEST_ASSERT(td.ok == ok) <<
+        "line:" << td.line << "\n  " <<
+        "expected: {ok:" << td.ok << ", in:\'" << td.in << "\'}\n " <<
+        "actual: {ok:" << ok << "}\n";
+    // clang-format on
   }
 
   {
@@ -3903,6 +4008,36 @@ JSONTEST_FIXTURE_LOCAL(FuzzTest, fuzzDoesntCrash) {
                              example.size()));
 }
 
+struct ParseWithStructuredErrorsTest : JsonTest::TestCase {
+  void testErrors(
+      const std::string& doc, bool success,
+      const std::vector<Json::CharReader::StructuredError>& expectedErrors) {
+    Json::CharReaderBuilder b;
+    CharReaderPtr reader(b.newCharReader());
+    Json::Value root;
+    JSONTEST_ASSERT_EQUAL(
+        reader->parse(doc.data(), doc.data() + doc.length(), &root, nullptr),
+        success);
+    auto actualErrors = reader->getStructuredErrors();
+    JSONTEST_ASSERT_EQUAL(expectedErrors.size(), actualErrors.size());
+    for (std::size_t i = 0; i < actualErrors.size(); i++) {
+      const auto& a = actualErrors[i];
+      const auto& e = expectedErrors[i];
+      JSONTEST_ASSERT_EQUAL(a.offset_start, e.offset_start);
+      JSONTEST_ASSERT_EQUAL(a.offset_limit, e.offset_limit);
+      JSONTEST_ASSERT_STRING_EQUAL(a.message, e.message);
+    }
+  }
+};
+
+JSONTEST_FIXTURE_LOCAL(ParseWithStructuredErrorsTest, success) {
+  testErrors("{}", true, {});
+}
+
+JSONTEST_FIXTURE_LOCAL(ParseWithStructuredErrorsTest, singleError) {
+  testErrors("{ 1 : 2 }", false, {{2, 3, "Missing '}' or object member name"}});
+}
+
 int main(int argc, const char* argv[]) {
   JsonTest::Runner runner;
 

test/data/fail_strict_comment_01.json

@@ -0,0 +1,4 @@
+{
+  "a": "aaa",
+  "b": "bbb" // comments not allowed in strict mode
+}

test/data/fail_strict_comment_02.json

@@ -0,0 +1,4 @@
+{
+  "a": "aaa", // comments not allowed in strict mode
+  "b": "bbb"
+}

test/data/fail_strict_comment_03.json

@@ -0,0 +1,3 @@
+{
+  "array" : [1, 2, 3 /* comments not allowed in strict mode */]
+}

test/data/fail_test_object_02.json

@@ -0,0 +1 @@
+{"one": 1 /* } */ { "two" : 2 }

test/data/legacy_test_real_13.expected

@@ -0,0 +1,3 @@
+.=[]
+.[0]=-inf
+.[1]=inf

test/data/legacy_test_real_13.json

@@ -0,0 +1 @@
+[-1e+9999, 1e+9999]

test/runjsontests.py

@@ -97,14 +97,17 @@ def runAllTests(jsontest_executable_path, input_dir = None,
     valgrind_path = use_valgrind and VALGRIND_CMD or ''
     for input_path in tests + test_jsonchecker:
         expect_failure = os.path.basename(input_path).startswith('fail')
-        is_json_checker_test = (input_path in test_jsonchecker) or expect_failure
+        is_json_checker_test = input_path in test_jsonchecker
+        is_parse_only = is_json_checker_test or expect_failure
+        is_strict_test = ('_strict_' in os.path.basename(input_path)) or is_json_checker_test
         print('TESTING:', input_path, end=' ')
-        options = is_json_checker_test and '--json-checker' or ''
+        options = is_parse_only and '--parse-only' or ''
+        options += is_strict_test and ' --strict' or ''
         options += ' --json-writer %s'%writerClass
         cmd = '%s%s %s "%s"' % (            valgrind_path, jsontest_executable_path, options,
             input_path)
         status, process_output = getStatusOutput(cmd)
-        if is_json_checker_test:
+        if is_parse_only:
             if expect_failure:
                 if not status:
                     print('FAILED')