third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/java/core/src/main/java/com/google/protobuf/TextFormat.java

 // 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 643 matching lines @@
       Pattern.CASE_INSENSITIVE);
 
     /** Construct a tokenizer that parses tokens from the given text. */
     private Tokenizer(final CharSequence text) {
       this.text = text;
       this.matcher = WHITESPACE.matcher(text);
       skipWhitespace();
       nextToken();
     }
 
+    int getPreviousLine() {
+      return previousLine;
+    }
+
+    int getPreviousColumn() {
+      return previousColumn;
+    }
+
     int getLine() {
       return line;
     }
 
     int getColumn() {
       return column;
     }
 
     /** Are we at the end of the input? */
     public boolean atEnd() {
@@ skipping 693 matching lines @@
         final int n = input.read(buffer);
         if (n == -1) {
           break;
         }
         buffer.flip();
         text.append(buffer, 0, n);
       }
       return text;
     }
 
+    // Check both unknown fields and unknown extensions and log warming messages
+    // or throw exceptions according to the flag.
+    private void checkUnknownFields(final List<String> unknownFields)
+        throws ParseException {
+      if (unknownFields.isEmpty()) {
+        return;
+      }
+
+      StringBuilder msg = new StringBuilder("Input contains unknown fields and/or extensions:");
+      for (String field : unknownFields) {
+        msg.append('\n').append(field);
+      }
+
+      if (allowUnknownFields) {
+          logger.warning(msg.toString());
+      } else {
+        String[] lineColumn = unknownFields.get(0).split(":");
+        throw new ParseException(Integer.valueOf(lineColumn[0]),
+            Integer.valueOf(lineColumn[1]), msg.toString());
+      }
+    }
+
     /**
      * Parse a text-format message from {@code input} and merge the contents
      * into {@code builder}.  Extensions will be recognized if they are
      * registered in {@code extensionRegistry}.
      */
     public void merge(final CharSequence input,
                       final ExtensionRegistry extensionRegistry,
                       final Message.Builder builder)
                       throws ParseException {
       final Tokenizer tokenizer = new Tokenizer(input);
       MessageReflection.BuilderAdapter target =
           new MessageReflection.BuilderAdapter(builder);
 
+      List<String> unknownFields = new ArrayList<String>();
+
       while (!tokenizer.atEnd()) {
-        mergeField(tokenizer, extensionRegistry, target);
+        mergeField(tokenizer, extensionRegistry, target, unknownFields);
       }
+
+      checkUnknownFields(unknownFields);
     }
 
 
     /**
      * Parse a single field from {@code tokenizer} and merge it into
      * {@code builder}.
      */
     private void mergeField(final Tokenizer tokenizer,
                             final ExtensionRegistry extensionRegistry,
-                            final MessageReflection.MergeTarget target)
+                            final MessageReflection.MergeTarget target,
+                            List<String> unknownFields)
                             throws ParseException {
-      mergeField(tokenizer, extensionRegistry, target, parseInfoTreeBuilder);
+      mergeField(tokenizer, extensionRegistry, target, parseInfoTreeBuilder,
+                 unknownFields);
     }
 
     /**
      * Parse a single field from {@code tokenizer} and merge it into
      * {@code builder}.
      */
     private void mergeField(final Tokenizer tokenizer,
                             final ExtensionRegistry extensionRegistry,
                             final MessageReflection.MergeTarget target,
-                            TextFormatParseInfoTree.Builder parseTreeBuilder)
+                            TextFormatParseInfoTree.Builder parseTreeBuilder,
+                            List<String> unknownFields)
                             throws ParseException {
       FieldDescriptor field = null;
       int startLine = tokenizer.getLine();
       int startColumn = tokenizer.getColumn();
       final Descriptor type = target.getDescriptorForType();
       ExtensionRegistry.ExtensionInfo extension = null;
 
       if (tokenizer.tryConsume("[")) {
         // An extension.
         final StringBuilder name =
             new StringBuilder(tokenizer.consumeIdentifier());
         while (tokenizer.tryConsume(".")) {
           name.append('.');
           name.append(tokenizer.consumeIdentifier());
         }
 
         extension = target.findExtensionByName(
             extensionRegistry, name.toString());
 
         if (extension == null) {
-          if (!allowUnknownFields) {
-            throw tokenizer.parseExceptionPreviousToken(
-              "Extension \"" + name + "\" not found in the ExtensionRegistry.");
-          } else {
-            logger.warning(
-              "Extension \"" + name + "\" not found in the ExtensionRegistry.");
-          }
+          unknownFields.add((tokenizer.getPreviousLine() + 1) + ":" +
+              (tokenizer.getPreviousColumn() + 1) + ":\t" +
+              type.getFullName() + ".[" + name + "]");
         } else {
           if (extension.descriptor.getContainingType() != type) {
             throw tokenizer.parseExceptionPreviousToken(
               "Extension \"" + name + "\" does not extend message type \""
               + type.getFullName() + "\".");
           }
           field = extension.descriptor;
         }
 
         tokenizer.consume("]");
@@ skipping 14 matching lines @@
             field = null;
           }
         }
         // Again, special-case group names as described above.
         if (field != null && field.getType() == FieldDescriptor.Type.GROUP
             && !field.getMessageType().getName().equals(name)) {
           field = null;
         }
 
         if (field == null) {
-          if (!allowUnknownFields) {
-            throw tokenizer.unknownFieldParseExceptionPreviousToken(
-              name,
-              "Message type \"" + type.getFullName()
-              + "\" has no field named \"" + name + "\".");
-          } else {
-            logger.warning(
-              "Message type \"" + type.getFullName()
-              + "\" has no field named \"" + name + "\".");
-          }
+          unknownFields.add((tokenizer.getPreviousLine() + 1) + ":" +
+              (tokenizer.getPreviousColumn() + 1) + ":\t" +
+              type.getFullName() + "." + name);
         }
       }
 
       // Skips unknown fields.
       if (field == null) {
         // Try to guess the type of this field.
         // If this field is not a message, there should be a ":" between the
         // field name and the field value and also the field value should not
         // start with "{" or "<" which indicates the beginning of a message body.
         // If there is no ":" or there is a "{" or "<" after ":", this field has
         // to be a message or the input is ill-formed.
         if (tokenizer.tryConsume(":")
             && !tokenizer.lookingAt("{")
             && !tokenizer.lookingAt("<")) {
           skipFieldValue(tokenizer);
         } else {
           skipFieldMessage(tokenizer);
         }
         return;
       }
 
       // Handle potential ':'.
       if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
         tokenizer.tryConsume(":");  // optional
         if (parseTreeBuilder != null) {
           TextFormatParseInfoTree.Builder childParseTreeBuilder =
               parseTreeBuilder.getBuilderForSubMessageField(field);
           consumeFieldValues(tokenizer, extensionRegistry, target, field, extension,
-              childParseTreeBuilder);
+              childParseTreeBuilder, unknownFields);
         } else {
           consumeFieldValues(tokenizer, extensionRegistry, target, field, extension,
-              parseTreeBuilder);
+              parseTreeBuilder, unknownFields);
         }
       } else {
         tokenizer.consume(":");  // required
-        consumeFieldValues(
-            tokenizer, extensionRegistry, target, field, extension, parseTreeBuilder);
+        consumeFieldValues(tokenizer, extensionRegistry, target, field,
+            extension, parseTreeBuilder, unknownFields);
       }
 
       if (parseTreeBuilder != null) {
         parseTreeBuilder.setLocation(
             field, TextFormatParseLocation.create(startLine, startColumn));
       }
 
       // For historical reasons, fields may optionally be separated by commas or
       // semicolons.
       if (!tokenizer.tryConsume(";")) {
         tokenizer.tryConsume(",");
       }
     }
 
     /**
      * Parse a one or more field values from {@code tokenizer} and merge it into
      * {@code builder}.
      */
     private void consumeFieldValues(
         final Tokenizer tokenizer,
         final ExtensionRegistry extensionRegistry,
         final MessageReflection.MergeTarget target,
         final FieldDescriptor field,
         final ExtensionRegistry.ExtensionInfo extension,
-        final TextFormatParseInfoTree.Builder parseTreeBuilder)
+        final TextFormatParseInfoTree.Builder parseTreeBuilder,
+        List<String> unknownFields)
         throws ParseException {
       // Support specifying repeated field values as a comma-separated list.
       // Ex."foo: [1, 2, 3]"
       if (field.isRepeated() && tokenizer.tryConsume("[")) {
-        while (true) {
-          consumeFieldValue(tokenizer, extensionRegistry, target, field, extension,
-              parseTreeBuilder);
-          if (tokenizer.tryConsume("]")) {
-            // End of list.
-            break;
+        if (!tokenizer.tryConsume("]")) {  // Allow "foo: []" to be treated as empty.
+          while (true) {
+            consumeFieldValue(
+                tokenizer,
+                extensionRegistry,
+                target,
+                field,
+                extension,
+                parseTreeBuilder,
+                unknownFields);
+            if (tokenizer.tryConsume("]")) {
+              // End of list.
+              break;
+            }
+            tokenizer.consume(",");
           }
-          tokenizer.consume(",");
         }
       } else {
-        consumeFieldValue(
-            tokenizer, extensionRegistry, target, field, extension, parseTreeBuilder);
+        consumeFieldValue(tokenizer, extensionRegistry, target, field,
+            extension, parseTreeBuilder, unknownFields);
       }
     }
 
     /**
      * Parse a single field value from {@code tokenizer} and merge it into
      * {@code builder}.
      */
     private void consumeFieldValue(
         final Tokenizer tokenizer,
         final ExtensionRegistry extensionRegistry,
         final MessageReflection.MergeTarget target,
         final FieldDescriptor field,
         final ExtensionRegistry.ExtensionInfo extension,
-        final TextFormatParseInfoTree.Builder parseTreeBuilder)
+        final TextFormatParseInfoTree.Builder parseTreeBuilder,
+        List<String> unknownFields)
         throws ParseException {
       Object value = null;
 
       if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
         final String endToken;
         if (tokenizer.tryConsume("<")) {
           endToken = ">";
         } else {
           tokenizer.consume("{");
           endToken = "}";
         }
 
         final MessageReflection.MergeTarget subField;
         subField = target.newMergeTargetForField(field,
             (extension == null) ? null : extension.defaultInstance);
 
         while (!tokenizer.tryConsume(endToken)) {
           if (tokenizer.atEnd()) {
             throw tokenizer.parseException(
               "Expected \"" + endToken + "\".");
           }
-          mergeField(tokenizer, extensionRegistry, subField, parseTreeBuilder);
+          mergeField(tokenizer, extensionRegistry, subField, parseTreeBuilder,
+              unknownFields);
         }
 
         value = subField.finish();
 
       } else {
         switch (field.getType()) {
           case INT32:
           case SINT32:
           case SFIXED32:
             value = tokenizer.consumeInt32();
@@ skipping 452 matching lines @@
           }
         }
       }
 
       result = bigValue.longValue();
     }
 
     return result;
   }
 }