third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/util/internal/json_stream_parser.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 27 matching lines @@
 #include <memory>
 #ifndef _SHARED_PTR_H
 #include <google/protobuf/stubs/shared_ptr.h>
 #endif
 
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/util/internal/object_writer.h>
 #include <google/protobuf/util/internal/json_escaping.h>
 #include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/stubs/mathlimits.h>
+
 
 namespace google {
 namespace protobuf {
 namespace util {
 
 // Allow these symbols to be referenced as util::Status, util::error::* in
 // this file.
 using util::Status;
 namespace error {
 using util::error::INTERNAL;
@@ skipping 42 matching lines @@
       leftover_(),
       json_(),
       p_(),
       key_(),
       key_storage_(),
       finishing_(false),
       parsed_(),
       parsed_storage_(),
       string_open_(0),
       chunk_storage_(),
-      coerce_to_utf8_(false) {
+      coerce_to_utf8_(false),
+      allow_empty_null_(false),
+      loose_float_number_conversion_(false) {
   // Initialize the stack with a single value to be parsed.
   stack_.push(VALUE);
 }
 
 JsonStreamParser::~JsonStreamParser() {}
 
 
 util::Status JsonStreamParser::Parse(StringPiece json) {
   StringPiece chunk = json;
   // If we have leftovers from a previous chunk, append the new chunk to it
@@ skipping 149 matching lines @@
       return ParseNumber();
     case BEGIN_TRUE:
       return ParseTrue();
     case BEGIN_FALSE:
       return ParseFalse();
     case BEGIN_NULL:
       return ParseNull();
     case UNKNOWN:
       return ReportUnknown("Expected a value.");
     default: {
+      if (allow_empty_null_ && IsEmptyNullAllowed(type)) {
+        return ParseEmptyNull();
+      }
+
       // Special case for having been cut off while parsing, wait for more data.
       // This handles things like 'fals' being at the end of the string, we
       // don't know if the next char would be e, completing it, or something
       // else, making it invalid.
       if (!finishing_ && p_.length() < false_len) {
         return util::Status::CANCELLED;
       }
       return ReportFailure("Unexpected token.");
     }
   }
 }
 
 util::Status JsonStreamParser::ParseString() {
   util::Status result = ParseStringHelper();
   if (result.ok()) {
     ow_->RenderString(key_, parsed_);
-    key_.clear();
-    parsed_.clear();
+    key_ = StringPiece();
+    parsed_ = StringPiece();
     parsed_storage_.clear();
   }
   return result;
 }
 
 util::Status JsonStreamParser::ParseStringHelper() {
   // If we haven't seen the start quote, grab it and remember it for later.
   if (string_open_ == 0) {
     string_open_ = *p_.data();
     GOOGLE_DCHECK(string_open_ == '\"' || string_open_ == '\'');
     Advance();
   }
   // Track where we last copied data from so we can minimize copying.
   const char* last = p_.data();
   while (!p_.empty()) {
     const char* data = p_.data();
     if (*data == '\\') {
       // We're about to handle an escape, copy all bytes from last to data.
       if (last < data) {
         parsed_storage_.append(last, data - last);
-        last = data;
       }
       // If we ran out of string after the \, cancel or report an error
       // depending on if we expect more data later.
       if (p_.length() == 1) {
         if (!finishing_) {
           return util::Status::CANCELLED;
         }
         return ReportFailure("Closing quote expected in string.");
       }
       // Parse a unicode escape if we found \u in the string.
@@ skipping 35 matching lines @@
       continue;
     }
     // If we found the closing quote note it, advance past it, and return.
     if (*data == string_open_) {
       // If we didn't copy anything, reuse the input buffer.
       if (parsed_storage_.empty()) {
         parsed_ = StringPiece(last, data - last);
       } else {
         if (last < data) {
           parsed_storage_.append(last, data - last);
-          last = data;
         }
         parsed_ = StringPiece(parsed_storage_);
       }
       // Clear the quote char so next time we try to parse a string we'll
       // start fresh.
       string_open_ = 0;
       Advance();
       return util::Status::OK;
     }
     // Normal character, just advance past it.
@@ skipping 79 matching lines @@
   return util::Status::OK;
 }
 
 util::Status JsonStreamParser::ParseNumber() {
   NumberResult number;
   util::Status result = ParseNumberHelper(&number);
   if (result.ok()) {
     switch (number.type) {
       case NumberResult::DOUBLE:
         ow_->RenderDouble(key_, number.double_val);
-        key_.clear();
+        key_ = StringPiece();
         break;
 
       case NumberResult::INT:
         ow_->RenderInt64(key_, number.int_val);
-        key_.clear();
+        key_ = StringPiece();
         break;
 
       case NumberResult::UINT:
         ow_->RenderUint64(key_, number.uint_val);
-        key_.clear();
+        key_ = StringPiece();
         break;
 
       default:
         return ReportFailure("Unable to parse number.");
     }
   }
   return result;
 }
 
 util::Status JsonStreamParser::ParseNumberHelper(NumberResult* result) {
@@ skipping 27 matching lines @@
   }
 
   // Create a string containing just the number, so we can use safe_strtoX
   string number = p_.substr(0, index).ToString();
 
   // Floating point number, parse as a double.
   if (floating) {
     if (!safe_strtod(number, &result->double_val)) {
       return ReportFailure("Unable to parse number.");
     }
+    if (!loose_float_number_conversion_ &&
+        !MathLimits<double>::IsFinite(result->double_val)) {
+      return ReportFailure("Number exceeds the range of double.");
+    }
     result->type = NumberResult::DOUBLE;
     p_.remove_prefix(index);
     return util::Status::OK;
   }
 
   // Positive non-floating point number, parse as a uint64.
   if (!negative) {
     // Octal/Hex numbers are not valid JSON values.
     if (number.length() >= 2 && number[0] == '0') {
       return ReportFailure("Octal/hex numbers are not valid JSON values.");
@@ skipping 16 matching lines @@
   }
   result->type = NumberResult::INT;
   p_.remove_prefix(index);
   return util::Status::OK;
 }
 
 util::Status JsonStreamParser::HandleBeginObject() {
   GOOGLE_DCHECK_EQ('{', *p_.data());
   Advance();
   ow_->StartObject(key_);
-  key_.clear();
+  key_ = StringPiece();
   stack_.push(ENTRY);
   return util::Status::OK;
 }
 
 util::Status JsonStreamParser::ParseObjectMid(TokenType type) {
   if (type == UNKNOWN) {
     return ReportUnknown("Expected , or } after key:value pair.");
   }
 
   // Object is complete, advance past the comma and render the EndObject.
@@ skipping 29 matching lines @@
     // Key is a string (standard JSON), parse it and store the string.
     result = ParseStringHelper();
     if (result.ok()) {
       key_storage_.clear();
       if (!parsed_storage_.empty()) {
         parsed_storage_.swap(key_storage_);
         key_ = StringPiece(key_storage_);
       } else {
         key_ = parsed_;
       }
-      parsed_.clear();
+      parsed_ = StringPiece();
     }
   } else if (type == BEGIN_KEY) {
     // Key is a bare key (back compat), create a StringPiece pointing to it.
     result = ParseKey();
   } else {
     // Unknown key type, report an error.
     result = ReportFailure("Expected an object key or }.");
   }
   // On success we next expect an entry mid ':' then an object mid ',' or '}'
   if (result.ok()) {
@@ skipping 12 matching lines @@
     stack_.push(VALUE);
     return util::Status::OK;
   }
   return ReportFailure("Expected : between key:value pair.");
 }
 
 util::Status JsonStreamParser::HandleBeginArray() {
   GOOGLE_DCHECK_EQ('[', *p_.data());
   Advance();
   ow_->StartList(key_);
-  key_.clear();
+  key_ = StringPiece();
   stack_.push(ARRAY_VALUE);
   return util::Status::OK;
 }
 
 util::Status JsonStreamParser::ParseArrayValue(TokenType type) {
   if (type == UNKNOWN) {
     return ReportUnknown("Expected a value or ] within an array.");
   }
 
   if (type == END_ARRAY) {
     ow_->EndList();
     Advance();
     return util::Status::OK;
   }
 
   // The ParseValue call may push something onto the stack so we need to make
-  // sure an ARRAY_MID is after it, so we push it on now.
+  // sure an ARRAY_MID is after it, so we push it on now. Also, the parsing of
+  // empty-null array value is relying on this ARRAY_MID token.
   stack_.push(ARRAY_MID);
   util::Status result = ParseValue(type);
   if (result == util::Status::CANCELLED) {
     // If we were cancelled, pop back off the ARRAY_MID so we don't try to
     // push it on again when we try over.
     stack_.pop();
   }
   return result;
 }
 
@@ skipping 13 matching lines @@
     Advance();
     stack_.push(ARRAY_VALUE);
     return util::Status::OK;
   }
   // Illegal token after array value.
   return ReportFailure("Expected , or ] after array value.");
 }
 
 util::Status JsonStreamParser::ParseTrue() {
   ow_->RenderBool(key_, true);
-  key_.clear();
+  key_ = StringPiece();
   p_.remove_prefix(true_len);
   return util::Status::OK;
 }
 
 util::Status JsonStreamParser::ParseFalse() {
   ow_->RenderBool(key_, false);
-  key_.clear();
+  key_ = StringPiece();
   p_.remove_prefix(false_len);
   return util::Status::OK;
 }
 
 util::Status JsonStreamParser::ParseNull() {
   ow_->RenderNull(key_);
-  key_.clear();
+  key_ = StringPiece();
   p_.remove_prefix(null_len);
   return util::Status::OK;
 }
 
+util::Status JsonStreamParser::ParseEmptyNull() {
+  ow_->RenderNull(key_);
+  key_ = StringPiece();
+  return util::Status::OK;
+}
+
+bool JsonStreamParser::IsEmptyNullAllowed(TokenType type) {
+  if (stack_.empty()) return false;
+  return (stack_.top() == ARRAY_MID && type == VALUE_SEPARATOR) ||
+         stack_.top() == OBJ_MID;
+}
+
 util::Status JsonStreamParser::ReportFailure(StringPiece message) {
   static const int kContextLength = 20;
   const char* p_start = p_.data();
   const char* json_start = json_.data();
   const char* begin = std::max(p_start - kContextLength, json_start);
   const char* end =
       std::min(p_start + kContextLength, json_start + json_.size());
   StringPiece segment(begin, end - begin);
   string location(p_start - begin, ' ');
   location.push_back('^');
@@ skipping 80 matching lines @@
   // can't parse what we have so far. So we don't report an error and just
   // return UNKNOWN so we can try again later when we have more data, or if we
   // finish and we have leftovers.
   return UNKNOWN;
 }
 
 }  // namespace converter
 }  // namespace util
 }  // namespace protobuf
 }  // namespace google