// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/json/json_parser.h"

#include <algorithm>
#include <cmath>
#include <iterator>
#include <memory>
#include <string_view>
#include <utility>
#include <vector>

#include "base/check_op.h"
#include "base/compiler_specific.h"
#include "base/feature_list.h"
#include "base/features.h"
#include "base/json/json_reader.h"
#include "base/notreached.h"
#include "base/numerics/safe_conversions.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversion_utils.h"
#include "base/strings/utf_string_conversions.h"
#include "base/third_party/icu/icu_utf.h"
#include "base/types/pass_key.h"

namespace base::internal {

namespace {

// Values 1000 and above are used by JSONFileValueSerializer::JsonFileError.
static_assert(JSONParser::JSON_PARSE_ERROR_COUNT < 1000,
              "JSONParser error out of bounds");

std::string ErrorCodeToString(JSONParser::JsonParseError error_code) {
  switch (error_code) {
    case JSONParser::JSON_NO_ERROR:
      return std::string();
    case JSONParser::JSON_SYNTAX_ERROR:
      return JSONParser::kSyntaxError;
    case JSONParser::JSON_INVALID_ESCAPE:
      return JSONParser::kInvalidEscape;
    case JSONParser::JSON_UNEXPECTED_TOKEN:
      return JSONParser::kUnexpectedToken;
    case JSONParser::JSON_TRAILING_COMMA:
      return JSONParser::kTrailingComma;
    case JSONParser::JSON_TOO_MUCH_NESTING:
      return JSONParser::kTooMuchNesting;
    case JSONParser::JSON_UNEXPECTED_DATA_AFTER_ROOT:
      return JSONParser::kUnexpectedDataAfterRoot;
    case JSONParser::JSON_UNSUPPORTED_ENCODING:
      return JSONParser::kUnsupportedEncoding;
    case JSONParser::JSON_UNQUOTED_DICTIONARY_KEY:
      return JSONParser::kUnquotedDictionaryKey;
    case JSONParser::JSON_UNREPRESENTABLE_NUMBER:
      return JSONParser::kUnrepresentableNumber;
    case JSONParser::JSON_PARSE_ERROR_COUNT:
      NOTREACHED();
  }
  NOTREACHED();
}

const int32_t kExtendedASCIIStart = 0x80;
constexpr base_icu::UChar32 kUnicodeReplacementPoint = 0xFFFD;

// UnprefixedHexStringToInt acts like |HexStringToInt|, but enforces that the
// input consists purely of hex digits. I.e. no "0x" nor "OX" prefix is
// permitted.
bool UnprefixedHexStringToInt(std::string_view input, int* output) {
  for (char i : input) {
    if (!IsHexDigit(i)) {
      return false;
    }
  }
  return HexStringToInt(input, output);
}

}  // namespace

// This is U+FFFD.
const char kUnicodeReplacementString[] = "\xEF\xBF\xBD";

const char JSONParser::kSyntaxError[] = "Syntax error.";
const char JSONParser::kInvalidEscape[] = "Invalid escape sequence.";
const char JSONParser::kUnexpectedToken[] = "Unexpected token.";
const char JSONParser::kTrailingComma[] = "Trailing comma not allowed.";
const char JSONParser::kTooMuchNesting[] = "Too much nesting.";
const char JSONParser::kUnexpectedDataAfterRoot[] =
    "Unexpected data after root element.";
const char JSONParser::kUnsupportedEncoding[] =
    "Unsupported encoding. JSON must be UTF-8.";
const char JSONParser::kUnquotedDictionaryKey[] =
    "Dictionary keys must be quoted.";
const char JSONParser::kUnrepresentableNumber[] =
    "Number cannot be represented.";

JSONParser::JSONParser(int options, size_t max_depth)
    : options_(options),
      max_depth_(max_depth),
      index_(0),
      stack_depth_(0),
      line_number_(0),
      index_last_line_(0),
      error_code_(JSON_NO_ERROR),
      error_line_(0),
      error_column_(0) {
  CHECK_LE(max_depth, kAbsoluteMaxDepth);
}

JSONParser::~JSONParser() = default;

std::optional<Value> JSONParser::Parse(std::string_view input) {
  input_ = input;
  index_ = 0;
  // Line and column counting is 1-based, but |index_| is 0-based. For example,
  // if input is "Aaa\nB" then 'A' and 'B' are both in column 1 (at lines 1 and
  // 2) and have indexes of 0 and 4. We track the line number explicitly (the
  // |line_number_| field) and the column number implicitly (the difference
  // between |index_| and |index_last_line_|). In calculating that difference,
  // |index_last_line_| is the index of the '\r' or '\n', not the index of the
  // first byte after the '\n'. For the 'B' in "Aaa\nB", its |index_| and
  // |index_last_line_| would be 4 and 3: 'B' is in column (4 - 3) = 1. We
  // initialize |index_last_line_| to -1, not 0, since -1 is the (out of range)
  // index of the imaginary '\n' immediately before the start of the string:
  // 'A' is in column (0 - -1) = 1.
  line_number_ = 1;
  index_last_line_ = static_cast<size_t>(-1);

  error_code_ = JSON_NO_ERROR;
  error_line_ = 0;
  error_column_ = 0;

  // When the input JSON string starts with a UTF-8 Byte-Order-Mark,
  // advance the start position to avoid the ParseNextToken function mis-
  // treating a Unicode BOM as an invalid character and returning NULL.
  ConsumeIfMatch("\xEF\xBB\xBF");

  // Parse the first and any nested tokens.
  std::optional<Value> root(ParseNextToken());
  if (!root) {
    return std::nullopt;
  }

  // Make sure the input stream is at an end.
  if (GetNextToken() != T_END_OF_INPUT) {
    ReportError(JSON_UNEXPECTED_DATA_AFTER_ROOT, 0);
    return std::nullopt;
  }

  return root;
}

JSONParser::JsonParseError JSONParser::error_code() const {
  return error_code_;
}

std::string JSONParser::GetErrorMessage() const {
  return FormatErrorMessage(error_line_, error_column_,
                            ErrorCodeToString(error_code_));
}

int JSONParser::error_line() const {
  return error_line_;
}

int JSONParser::error_column() const {
  return error_column_;
}

// JSONParser private //////////////////////////////////////////////////////////

std::optional<std::string_view> JSONParser::PeekChars(size_t count) {
  if (count > input_.length() - index_) {
    return std::nullopt;
  }
  // Using string_view::substr() was historically significantly slower
  // (according to base_perftests) than constructing a substring manually.
  //
  // TODO(crbug.com/40284755): Is this still the case? Ideally the bounds check
  // performed by substr would be deleted by the optimizer for being redundant
  // with the runtime check above. However, to do so, the compiler would need
  // to know `index_ <= input_.length()` is a class invariant. If we
  // restructured the code so that we only stored the remaining data, that
  // would avoid this, but it would prevent rewinding (the places in this file
  // which look at `input_[index_ - 1]`.)
  return UNSAFE_BUFFERS(std::string_view(input_.data() + index_, count));
}

std::optional<char> JSONParser::PeekChar() {
  std::optional<std::string_view> chars = PeekChars(1);
  if (chars) {
    return (*chars)[0];
  }
  return std::nullopt;
}

std::optional<std::string_view> JSONParser::ConsumeChars(size_t count) {
  std::optional<std::string_view> chars = PeekChars(count);
  if (chars) {
    index_ += count;
  }
  return chars;
}

std::optional<char> JSONParser::ConsumeChar() {
  std::optional<std::string_view> chars = ConsumeChars(1);
  if (chars) {
    return (*chars)[0];
  }
  return std::nullopt;
}

const char* JSONParser::pos() {
  CHECK_LE(index_, input_.length());
  // SAFETY: Checked above.
  return UNSAFE_BUFFERS(input_.data() + index_);
}

JSONParser::Token JSONParser::GetNextToken() {
  EatWhitespaceAndComments();

  std::optional<char> c = PeekChar();
  if (!c) {
    return T_END_OF_INPUT;
  }

  switch (*c) {
    case '{':
      return T_OBJECT_BEGIN;
    case '}':
      return T_OBJECT_END;
    case '[':
      return T_ARRAY_BEGIN;
    case ']':
      return T_ARRAY_END;
    case '"':
      return T_STRING;
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case '-':
      return T_NUMBER;
    case 't':
      return T_BOOL_TRUE;
    case 'f':
      return T_BOOL_FALSE;
    case 'n':
      return T_NULL;
    case ',':
      return T_LIST_SEPARATOR;
    case ':':
      return T_OBJECT_PAIR_SEPARATOR;
    default:
      return T_INVALID_TOKEN;
  }
}

void JSONParser::EatWhitespaceAndComments() {
  while (std::optional<char> c = PeekChar()) {
    switch (*c) {
      case '\r':
      case '\n':
        index_last_line_ = index_;
        // Don't increment line_number_ twice for "\r\n".
        if (!(c == '\n' && index_ > 0 && input_[index_ - 1] == '\r')) {
          ++line_number_;
        }
        [[fallthrough]];
      case ' ':
      case '\t':
        ConsumeChar();
        break;
      case '/':
        if (!EatComment()) {
          return;
        }
        break;
      default:
        return;
    }
  }
}

bool JSONParser::EatComment() {
  std::optional<std::string_view> comment_start = PeekChars(2);
  if (!comment_start) {
    return false;
  }

  const bool comments_allowed = options_ & JSON_ALLOW_COMMENTS;

  if (comment_start == "//") {
    if (!comments_allowed) {
      ReportError(JSON_UNEXPECTED_TOKEN, 0);
      return false;
    }

    ConsumeChars(2);
    // Single line comment, read to newline.
    while (std::optional<char> c = PeekChar()) {
      if (c == '\n' || c == '\r') {
        return true;
      }
      ConsumeChar();
    }
  } else if (comment_start == "/*") {
    if (!comments_allowed) {
      ReportError(JSON_UNEXPECTED_TOKEN, 0);
      return false;
    }

    ConsumeChars(2);
    char previous_char = '\0';
    // Block comment, read until end marker.
    while (std::optional<char> c = PeekChar()) {
      if (previous_char == '*' && c == '/') {
        // EatWhitespaceAndComments will inspect pos(), which will still be on
        // the last / of the comment, so advance once more (which may also be
        // end of input).
        ConsumeChar();
        return true;
      }
      previous_char = *ConsumeChar();
    }

    // If the comment is unterminated, GetNextToken will report T_END_OF_INPUT.
  }

  return false;
}

std::optional<Value> JSONParser::ParseNextToken() {
  return ParseToken(GetNextToken());
}

std::optional<Value> JSONParser::ParseToken(Token token) {
  switch (token) {
    case T_OBJECT_BEGIN:
      return ConsumeDictionary();
    case T_ARRAY_BEGIN:
      return ConsumeList();
    case T_STRING:
      return ConsumeString();
    case T_NUMBER:
      return ConsumeNumber();
    case T_BOOL_TRUE:
    case T_BOOL_FALSE:
    case T_NULL:
      return ConsumeLiteral();
    default:
      ReportError(JSON_UNEXPECTED_TOKEN, 0);
      return std::nullopt;
  }
}

std::optional<Value> JSONParser::ConsumeDictionary() {
  if (ConsumeChar() != '{') {
    ReportError(JSON_UNEXPECTED_TOKEN, 0);
    return std::nullopt;
  }

  StackMarker depth_check(max_depth_, &stack_depth_);
  if (depth_check.IsTooDeep()) {
    ReportError(JSON_TOO_MUCH_NESTING, -1);
    return std::nullopt;
  }

  std::vector<std::pair<std::string, std::unique_ptr<Value>>> values;

  Token token = GetNextToken();
  while (token != T_OBJECT_END) {
    if (token != T_STRING) {
      ReportError(JSON_UNQUOTED_DICTIONARY_KEY, 0);
      return std::nullopt;
    }

    // First consume the key.
    std::optional<std::string> key = ConsumeStringRaw();
    if (!key) {
      return std::nullopt;
    }

    // Read the separator.
    token = GetNextToken();
    if (token != T_OBJECT_PAIR_SEPARATOR) {
      ReportError(JSON_SYNTAX_ERROR, 0);
      return std::nullopt;
    }

    // The next token is the value. Ownership transfers to |dict|.
    ConsumeChar();
    std::optional<Value> value = ParseNextToken();
    if (!value) {
      // ReportError from deeper level.
      return std::nullopt;
    }

    values.emplace_back(std::move(*key),
                        std::make_unique<Value>(std::move(*value)));

    token = GetNextToken();
    if (token == T_LIST_SEPARATOR) {
      ConsumeChar();
      token = GetNextToken();
      if (token == T_OBJECT_END && !(options_ & JSON_ALLOW_TRAILING_COMMAS)) {
        ReportError(JSON_TRAILING_COMMA, 0);
        return std::nullopt;
      }
    } else if (token != T_OBJECT_END) {
      ReportError(JSON_SYNTAX_ERROR, 0);
      return std::nullopt;
    }
  }

  ConsumeChar();  // Closing '}'.
  // Reverse |dict_storage| to keep the last of elements with the same key in
  // the input.
  std::ranges::reverse(values);
  return Value(Value::Dict(PassKey<JSONParser>(), std::move(values)));
}

std::optional<Value> JSONParser::ConsumeList() {
  if (ConsumeChar() != '[') {
    ReportError(JSON_UNEXPECTED_TOKEN, 0);
    return std::nullopt;
  }

  StackMarker depth_check(max_depth_, &stack_depth_);
  if (depth_check.IsTooDeep()) {
    ReportError(JSON_TOO_MUCH_NESTING, -1);
    return std::nullopt;
  }

  Value::List list;

  Token token = GetNextToken();
  while (token != T_ARRAY_END) {
    std::optional<Value> item = ParseToken(token);
    if (!item) {
      // ReportError from deeper level.
      return std::nullopt;
    }

    list.Append(std::move(*item));

    token = GetNextToken();
    if (token == T_LIST_SEPARATOR) {
      ConsumeChar();
      token = GetNextToken();
      if (token == T_ARRAY_END && !(options_ & JSON_ALLOW_TRAILING_COMMAS)) {
        ReportError(JSON_TRAILING_COMMA, 0);
        return std::nullopt;
      }
    } else if (token != T_ARRAY_END) {
      ReportError(JSON_SYNTAX_ERROR, 0);
      return std::nullopt;
    }
  }

  ConsumeChar();  // Closing ']'.

  return Value(std::move(list));
}

std::optional<Value> JSONParser::ConsumeString() {
  std::optional<std::string> string = ConsumeStringRaw();
  if (!string) {
    return std::nullopt;
  }
  return Value(std::move(*string));
}

std::optional<std::string> JSONParser::ConsumeStringRaw() {
  if (ConsumeChar() != '"') {
    ReportError(JSON_UNEXPECTED_TOKEN, 0);
    return std::nullopt;
  }

  std::string string;
  for (;;) {
    auto [result, consumed] = ConsumeStringPart();
    switch (result) {
      case StringResult::kError:
        return std::nullopt;

      case StringResult::kDone:
        // This is the last time we're appending, so pre-reserve the desired
        // size, to prevent `+=` from overallocating. (In other cases, the
        // overallocating is desirable for amortization.) In particular,
        // the common case is that `string` is empty and we return in one step.
        string.reserve(string.size() + consumed.size());
        string += consumed;
        return std::move(string);

      case StringResult::kReplacementCharacter:
        string += consumed;
        string += kUnicodeReplacementString;
        break;  // Keep parsing.

      case StringResult::kEscape:
        string += consumed;
        std::optional<char> escape_char = ConsumeChar();
        if (!escape_char) {
          ReportError(JSON_INVALID_ESCAPE, -1);
          return std::nullopt;
        }

        switch (*escape_char) {
          // Allowed esape sequences:
          case 'x': {  // UTF-8 sequence.
            // UTF-8 \x escape sequences are not allowed in the spec, but they
            // are supported here for backwards-compatiblity with the old
            // parser.
            if (!(options_ & JSON_ALLOW_X_ESCAPES)) {
              ReportError(JSON_INVALID_ESCAPE, -1);
              return std::nullopt;
            }

            std::optional<std::string_view> escape_sequence = ConsumeChars(2);
            if (!escape_sequence) {
              ReportError(JSON_INVALID_ESCAPE, -3);
              return std::nullopt;
            }

            int hex_digit = 0;
            if (!UnprefixedHexStringToInt(*escape_sequence, &hex_digit)) {
              ReportError(JSON_INVALID_ESCAPE, -3);
              return std::nullopt;
            }

            // A two-character hex sequence is at most 0xff and all codepoints
            // up to 0xff are valid.
            DCHECK_LE(hex_digit, 0xff);
            DCHECK(IsValidCharacter(hex_digit));
            WriteUnicodeCharacter(hex_digit, &string);
            break;
          }
          case 'u': {  // UTF-16 sequence.
            // UTF units are of the form \uXXXX.
            base_icu::UChar32 code_point;
            if (!DecodeUTF16(&code_point)) {
              ReportError(JSON_INVALID_ESCAPE, -1);
              return std::nullopt;
            }
            WriteUnicodeCharacter(code_point, &string);
            break;
          }
          case '"':
            string.push_back('"');
            break;
          case '\\':
            string.push_back('\\');
            break;
          case '/':
            string.push_back('/');
            break;
          case 'b':
            string.push_back('\b');
            break;
          case 'f':
            string.push_back('\f');
            break;
          case 'n':
            string.push_back('\n');
            break;
          case 'r':
            string.push_back('\r');
            break;
          case 't':
            string.push_back('\t');
            break;
          case 'v':  // Not listed as valid escape sequence in the RFC.
            if (!(options_ & JSON_ALLOW_VERT_TAB)) {
              ReportError(JSON_INVALID_ESCAPE, -1);
              return std::nullopt;
            }
            string.push_back('\v');
            break;
          // All other escape squences are illegal.
          default:
            ReportError(JSON_INVALID_ESCAPE, -1);
            return std::nullopt;
        }
        break;  // Keep parsing.
    }
  }
}

std::pair<JSONParser::StringResult, std::string_view>
JSONParser::ConsumeStringPart() {
  const size_t start_index = index_;
  while (std::optional<char> c = PeekChar()) {
    // Handle non-ASCII characters, which never trigger any special handling
    // beyond needing to be valid UTF-8. ASCII characters will be handled
    // separately below.
    if (static_cast<unsigned char>(*c) >= kExtendedASCIIStart) {
      base_icu::UChar32 next_char = 0;
      size_t last_index = index_;
      if (!ReadUnicodeCharacter(input_.data(), input_.length(), &index_,
                                &next_char)) {
        if ((options_ & JSON_REPLACE_INVALID_CHARACTERS) == 0) {
          ReportError(JSON_UNSUPPORTED_ENCODING, 0);
          // No need to return consumed data.
          return {StringResult::kError, {}};
        }
        ConsumeChar();
        return {StringResult::kReplacementCharacter,
                input_.substr(start_index, last_index - start_index)};
      }

      // Valid UTF-8 will be copied as-is into the output, so keep processing.
      DCHECK_GE(next_char, kExtendedASCIIStart);
      ConsumeChar();
      continue;
    }

    if (*c == '"') {
      std::string_view ret = input_.substr(start_index, index_ - start_index);
      ConsumeChar();
      return {StringResult::kDone, ret};
    }
    if (*c == '\\') {
      std::string_view ret = input_.substr(start_index, index_ - start_index);
      ConsumeChar();
      return {StringResult::kEscape, ret};
    }

    // Per Section 7, "All Unicode characters may be placed within the
    // quotation marks, except for the characters that MUST be escaped:
    // quotation mark, reverse solidus, and the control characters (U+0000
    // through U+001F)".
    if (*c == '\n' || *c == '\r') {
      if (!(options_ & JSON_ALLOW_NEWLINES_IN_STRINGS)) {
        ReportError(JSON_UNSUPPORTED_ENCODING, -1);
        return {StringResult::kError, {}};  // No need to return consumed data.
      }
    } else if (*c <= 0x1F) {
      ReportError(JSON_UNSUPPORTED_ENCODING, -1);
      return {StringResult::kError, {}};  // No need to return consumed data.
    }

    // If this character is not an escape sequence, track any line breaks and
    // keep parsing. The JSON spec forbids unescaped ASCII control characters
    // within a string, including '\r' and '\n', but this implementation is more
    // lenient.
    if (*c == '\r' || *c == '\n') {
      index_last_line_ = index_;
      // Don't increment line_number_ twice for "\r\n". We are guaranteed that
      // (index_ > 0) because we are consuming a string, so we must have seen an
      // opening '"' quote character.
      if ((*c == '\r') || (input_[index_ - 1] != '\r')) {
        ++line_number_;
      }
    }
    ConsumeChar();
  }

  ReportError(JSON_SYNTAX_ERROR, -1);
  return {StringResult::kError, {}};  // No need to return consumed data.
}

// Entry is at the first X in \uXXXX.
bool JSONParser::DecodeUTF16(base_icu::UChar32* out_code_point) {
  std::optional<std::string_view> escape_sequence = ConsumeChars(4);
  if (!escape_sequence) {
    return false;
  }

  // Consume the UTF-16 code unit, which may be a high surrogate.
  int code_unit16_high = 0;
  if (!UnprefixedHexStringToInt(*escape_sequence, &code_unit16_high)) {
    return false;
  }

  // If this is a high surrogate, consume the next code unit to get the
  // low surrogate.
  if (CBU16_IS_SURROGATE(code_unit16_high)) {
    // Make sure this is the high surrogate.
    if (!CBU16_IS_SURROGATE_LEAD(code_unit16_high)) {
      if ((options_ & JSON_REPLACE_INVALID_CHARACTERS) == 0) {
        return false;
      }
      *out_code_point = kUnicodeReplacementPoint;
      return true;
    }

    // Make sure that the token has more characters to consume the
    // lower surrogate.
    if (!ConsumeIfMatch("\\u")) {
      if ((options_ & JSON_REPLACE_INVALID_CHARACTERS) == 0) {
        return false;
      }
      *out_code_point = kUnicodeReplacementPoint;
      return true;
    }

    escape_sequence = ConsumeChars(4);
    if (!escape_sequence) {
      return false;
    }

    int code_unit16_low = 0;
    if (!UnprefixedHexStringToInt(*escape_sequence, &code_unit16_low)) {
      return false;
    }

    if (!CBU16_IS_TRAIL(code_unit16_low)) {
      if ((options_ & JSON_REPLACE_INVALID_CHARACTERS) == 0) {
        return false;
      }
      *out_code_point = kUnicodeReplacementPoint;
      return true;
    }

    base_icu::UChar32 code_point =
        CBU16_GET_SUPPLEMENTARY(code_unit16_high, code_unit16_low);

    *out_code_point = code_point;
  } else {
    // Not a surrogate.
    DCHECK(CBU16_IS_SINGLE(code_unit16_high));

    *out_code_point = code_unit16_high;
  }

  return true;
}

std::optional<Value> JSONParser::ConsumeNumber() {
  const char* num_start = pos();
  const size_t start_index = index_;
  size_t end_index = start_index;

  if (PeekChar() == '-') {
    ConsumeChar();
  }

  if (!ReadInt(false)) {
    ReportError(JSON_SYNTAX_ERROR, 0);
    return std::nullopt;
  }
  end_index = index_;

  // The optional fraction part.
  if (PeekChar() == '.') {
    ConsumeChar();
    if (!ReadInt(true)) {
      ReportError(JSON_SYNTAX_ERROR, 0);
      return std::nullopt;
    }
    end_index = index_;
  }

  // Optional exponent part.
  std::optional<char> c = PeekChar();
  if (c == 'e' || c == 'E') {
    ConsumeChar();
    if (PeekChar() == '-' || PeekChar() == '+') {
      ConsumeChar();
    }
    if (!ReadInt(true)) {
      ReportError(JSON_SYNTAX_ERROR, 0);
      return std::nullopt;
    }
    end_index = index_;
  }

  std::string_view num_string(num_start, end_index - start_index);

  int num_int;
  if (StringToInt(num_string, &num_int)) {
    // StringToInt will treat `-0` as zero, losing the significance of the
    // negation.
    if (num_int == 0 && num_string.starts_with('-')) {
      return Value(-0.0);
    }
    return Value(num_int);
  }

  double num_double;
  if (StringToDouble(num_string, &num_double) && std::isfinite(num_double)) {
    return Value(num_double);
  }

  ReportError(JSON_UNREPRESENTABLE_NUMBER, 0);
  return std::nullopt;
}

bool JSONParser::ReadInt(bool allow_leading_zeros) {
  size_t len = 0;
  char first = 0;

  while (std::optional<char> c = PeekChar()) {
    if (!IsAsciiDigit(*c)) {
      break;
    }

    if (len == 0) {
      first = *c;
    }

    ++len;
    ConsumeChar();
  }

  if (len == 0) {
    return false;
  }

  if (!allow_leading_zeros && len > 1 && first == '0') {
    return false;
  }

  return true;
}

std::optional<Value> JSONParser::ConsumeLiteral() {
  if (ConsumeIfMatch("true")) {
    return Value(true);
  }
  if (ConsumeIfMatch("false")) {
    return Value(false);
  }
  if (ConsumeIfMatch("null")) {
    return Value(Value::Type::NONE);
  }
  ReportError(JSON_SYNTAX_ERROR, 0);
  return std::nullopt;
}

bool JSONParser::ConsumeIfMatch(std::string_view match) {
  if (match == PeekChars(match.size())) {
    ConsumeChars(match.size());
    return true;
  }
  return false;
}

void JSONParser::ReportError(JsonParseError code, int column_adjust) {
  error_code_ = code;
  error_line_ = line_number_;
  error_column_ = static_cast<int>(index_ - index_last_line_) + column_adjust;

  // For a final blank line ('\n' and then EOF), a negative column_adjust may
  // put us below 1, which doesn't really make sense for 1-based columns.
  if (error_column_ < 1) {
    error_column_ = 1;
  }
}

// static
std::string JSONParser::FormatErrorMessage(int line,
                                           int column,
                                           const std::string& description) {
  if (line || column) {
    return StringPrintf("Line: %i, column: %i, %s", line, column,
                        description.c_str());
  }
  return description;
}

}  // namespace base::internal