third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/objectivec/GPBCodedInputStream.m

 // 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 18 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #import "GPBCodedInputStream_PackagePrivate.h"
 
 #import "GPBDictionary_PackagePrivate.h"
 #import "GPBMessage_PackagePrivate.h"
 #import "GPBUnknownFieldSet_PackagePrivate.h"
 #import "GPBUtilities_PackagePrivate.h"
 #import "GPBWireFormat.h"
 
+NSString *const GPBCodedInputStreamException =
+    GPBNSStringifySymbol(GPBCodedInputStreamException);
+
+NSString *const GPBCodedInputStreamUnderlyingErrorKey =
+    GPBNSStringifySymbol(GPBCodedInputStreamUnderlyingErrorKey);
+
+NSString *const GPBCodedInputStreamErrorDomain =
+    GPBNSStringifySymbol(GPBCodedInputStreamErrorDomain);
+
 static const NSUInteger kDefaultRecursionLimit = 64;
 
+static void RaiseException(NSInteger code, NSString *reason) {
+  NSDictionary *errorInfo = nil;
+  if ([reason length]) {
+    errorInfo = @{ GPBErrorReasonKey: reason };
+  }
+  NSError *error = [NSError errorWithDomain:GPBCodedInputStreamErrorDomain
+                                       code:code
+                                   userInfo:errorInfo];
+
+  NSDictionary *exceptionInfo =
+      @{ GPBCodedInputStreamUnderlyingErrorKey: error };
+  [[[NSException alloc] initWithName:GPBCodedInputStreamException
+                              reason:reason
+                            userInfo:exceptionInfo] raise];
+}
+
 static void CheckSize(GPBCodedInputStreamState *state, size_t size) {
   size_t newSize = state->bufferPos + size;
   if (newSize > state->bufferSize) {
-    [NSException raise:NSParseErrorException format:@""];
+    RaiseException(GPBCodedInputStreamErrorInvalidSize, nil);
   }
   if (newSize > state->currentLimit) {
     // Fast forward to end of currentLimit;
     state->bufferPos = state->currentLimit;
-    [NSException raise:NSParseErrorException format:@""];
+    RaiseException(GPBCodedInputStreamErrorSubsectionLimitReached, nil);
   }
 }
 
 static int8_t ReadRawByte(GPBCodedInputStreamState *state) {
   CheckSize(state, sizeof(int8_t));
   return ((int8_t *)state->bytes)[state->bufferPos++];
 }
 
 static int32_t ReadRawLittleEndian32(GPBCodedInputStreamState *state) {
   CheckSize(state, sizeof(int32_t));
@@ skipping 28 matching lines @@
       } else {
         result |= (tmp & 0x7f) << 21;
         result |= (tmp = ReadRawByte(state)) << 28;
         if (tmp < 0) {
           // Discard upper 32 bits.
           for (int i = 0; i < 5; i++) {
             if (ReadRawByte(state) >= 0) {
               return result;
             }
           }
-          [NSException raise:NSParseErrorException
-                      format:@"Unable to read varint32"];
+          RaiseException(GPBCodedInputStreamErrorInvalidVarInt,
+                         @"Invalid VarInt32");
         }
       }
     }
   }
   return result;
 }
 
 static int64_t ReadRawVarint64(GPBCodedInputStreamState *state) {
   int32_t shift = 0;
   int64_t result = 0;
   while (shift < 64) {
     int8_t b = ReadRawByte(state);
     result |= (int64_t)(b & 0x7F) << shift;
     if ((b & 0x80) == 0) {
       return result;
     }
     shift += 7;
   }
-  [NSException raise:NSParseErrorException format:@"Unable to read varint64"];
+  RaiseException(GPBCodedInputStreamErrorInvalidVarInt, @"Invalid VarInt64");
   return 0;
 }
 
 static void SkipRawData(GPBCodedInputStreamState *state, size_t size) {
   CheckSize(state, size);
   state->bufferPos += size;
 }
 
 double GPBCodedInputStreamReadDouble(GPBCodedInputStreamState *state) {
   int64_t value = ReadRawLittleEndian64(state);
@@ skipping 66 matching lines @@
 
 int32_t GPBCodedInputStreamReadTag(GPBCodedInputStreamState *state) {
   if (GPBCodedInputStreamIsAtEnd(state)) {
     state->lastTag = 0;
     return 0;
   }
 
   state->lastTag = ReadRawVarint32(state);
   if (state->lastTag == 0) {
     // If we actually read zero, that's not a valid tag.
-    [NSException raise:NSParseErrorException
-                format:@"Invalid last tag %d", state->lastTag];
+    RaiseException(GPBCodedInputStreamErrorInvalidTag,
+                   @"A zero tag on the wire is invalid.");
+  }
+  // Tags have to include a valid wireformat, check that also.
+  if (!GPBWireFormatIsValidTag(state->lastTag)) {
+    RaiseException(GPBCodedInputStreamErrorInvalidTag,
+                   @"Invalid wireformat in tag.");
   }
   return state->lastTag;
 }
 
 NSString *GPBCodedInputStreamReadRetainedString(
     GPBCodedInputStreamState *state) {
   int32_t size = ReadRawVarint32(state);
   NSString *result;
   if (size == 0) {
     result = @"";
   } else {
     CheckSize(state, size);
     result = [[NSString alloc] initWithBytes:&state->bytes[state->bufferPos]
                                       length:size
                                     encoding:NSUTF8StringEncoding];
     state->bufferPos += size;
     if (!result) {
 #ifdef DEBUG
       // https://developers.google.com/protocol-buffers/docs/proto#scalar
       NSLog(@"UTF-8 failure, is some field type 'string' when it should be "
             @"'bytes'?");
 #endif
-      [NSException raise:NSParseErrorException
-                  format:@"Invalid UTF-8 for a 'string'"];
+      RaiseException(GPBCodedInputStreamErrorInvalidUTF8, nil);
     }
   }
   return result;
 }
 
 NSData *GPBCodedInputStreamReadRetainedBytes(GPBCodedInputStreamState *state) {
   int32_t size = ReadRawVarint32(state);
   if (size < 0) return nil;
   CheckSize(state, size);
   NSData *result = [[NSData alloc] initWithBytes:state->bytes + state->bufferPos
@@ skipping 14 matching lines @@
              freeWhenDone:NO];
   state->bufferPos += size;
   return result;
 }
 
 size_t GPBCodedInputStreamPushLimit(GPBCodedInputStreamState *state,
                                     size_t byteLimit) {
   byteLimit += state->bufferPos;
   size_t oldLimit = state->currentLimit;
   if (byteLimit > oldLimit) {
-    [NSException raise:NSInvalidArgumentException
-                format:@"byteLimit > oldLimit: %tu > %tu", byteLimit, oldLimit];
+    RaiseException(GPBCodedInputStreamErrorInvalidSubsectionLimit, nil);
   }
   state->currentLimit = byteLimit;
   return oldLimit;
 }
 
 void GPBCodedInputStreamPopLimit(GPBCodedInputStreamState *state,
                                  size_t oldLimit) {
   state->currentLimit = oldLimit;
 }
 
 size_t GPBCodedInputStreamBytesUntilLimit(GPBCodedInputStreamState *state) {
   return state->currentLimit - state->bufferPos;
 }
 
 BOOL GPBCodedInputStreamIsAtEnd(GPBCodedInputStreamState *state) {
   return (state->bufferPos == state->bufferSize) ||
          (state->bufferPos == state->currentLimit);
 }
 
 void GPBCodedInputStreamCheckLastTagWas(GPBCodedInputStreamState *state,
                                         int32_t value) {
   if (state->lastTag != value) {
-    [NSException raise:NSParseErrorException
-                format:@"Last tag: %d should be %d", state->lastTag, value];
+    RaiseException(GPBCodedInputStreamErrorInvalidTag, @"Unexpected tag read");
   }
 }
 
 @implementation GPBCodedInputStream
 
 + (instancetype)streamWithData:(NSData *)data {
   return [[[self alloc] initWithData:data] autorelease];
 }
 
 - (instancetype)initWithData:(NSData *)data {
   if ((self = [super init])) {
 #ifdef DEBUG
     NSCAssert([self class] == [GPBCodedInputStream class],
               @"Subclassing of GPBCodedInputStream is not allowed.");
 #endif
     buffer_ = [data retain];
     state_.bytes = (const uint8_t *)[data bytes];
     state_.bufferSize = [data length];
     state_.currentLimit = state_.bufferSize;
   }
   return self;
 }
 
 - (void)dealloc {
   [buffer_ release];
   [super dealloc];
 }
 
+// Direct access is use for speed, to avoid even internally declaring things
+// read/write, etc. The warning is enabled in the project to ensure code calling
+// protos can turn on -Wdirect-ivar-access without issues.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdirect-ivar-access"
+
 - (int32_t)readTag {
   return GPBCodedInputStreamReadTag(&state_);
 }
 
 - (void)checkLastTagWas:(int32_t)value {
   GPBCodedInputStreamCheckLastTagWas(&state_, value);
 }
 
 - (BOOL)skipField:(int32_t)tag {
+  NSAssert(GPBWireFormatIsValidTag(tag), @"Invalid tag");
   switch (GPBWireFormatGetTagWireType(tag)) {
     case GPBWireFormatVarint:
       GPBCodedInputStreamReadInt32(&state_);
       return YES;
     case GPBWireFormatFixed64:
       SkipRawData(&state_, sizeof(int64_t));
       return YES;
     case GPBWireFormatLengthDelimited:
       SkipRawData(&state_, ReadRawVarint32(&state_));
       return YES;
     case GPBWireFormatStartGroup:
       [self skipMessage];
       GPBCodedInputStreamCheckLastTagWas(
           &state_, GPBWireFormatMakeTag(GPBWireFormatGetTagFieldNumber(tag),
                                         GPBWireFormatEndGroup));
       return YES;
     case GPBWireFormatEndGroup:
       return NO;
     case GPBWireFormatFixed32:
       SkipRawData(&state_, sizeof(int32_t));
       return YES;
   }
-  [NSException raise:NSParseErrorException format:@"Invalid tag %d", tag];
-  return NO;
 }
 
 - (void)skipMessage {
   while (YES) {
     int32_t tag = GPBCodedInputStreamReadTag(&state_);
     if (tag == 0 || ![self skipField:tag]) {
       return;
     }
   }
 }
 
 - (BOOL)isAtEnd {
   return GPBCodedInputStreamIsAtEnd(&state_);
 }
 
 - (size_t)position {
   return state_.bufferPos;
 }
 
+- (size_t)pushLimit:(size_t)byteLimit {
+  return GPBCodedInputStreamPushLimit(&state_, byteLimit);
+}
+
+- (void)popLimit:(size_t)oldLimit {
+  GPBCodedInputStreamPopLimit(&state_, oldLimit);
+}
+
 - (double)readDouble {
   return GPBCodedInputStreamReadDouble(&state_);
 }
 
 - (float)readFloat {
   return GPBCodedInputStreamReadFloat(&state_);
 }
 
 - (uint64_t)readUInt64 {
   return GPBCodedInputStreamReadUInt64(&state_);
@@ skipping 20 matching lines @@
 }
 
 - (NSString *)readString {
   return [GPBCodedInputStreamReadRetainedString(&state_) autorelease];
 }
 
 - (void)readGroup:(int32_t)fieldNumber
               message:(GPBMessage *)message
     extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
   if (state_.recursionDepth >= kDefaultRecursionLimit) {
-    [NSException raise:NSParseErrorException
-                format:@"recursionDepth(%tu) >= %tu", state_.recursionDepth,
-                       kDefaultRecursionLimit];
+    RaiseException(GPBCodedInputStreamErrorRecursionDepthExceeded, nil);
   }
   ++state_.recursionDepth;
   [message mergeFromCodedInputStream:self extensionRegistry:extensionRegistry];
   GPBCodedInputStreamCheckLastTagWas(
       &state_, GPBWireFormatMakeTag(fieldNumber, GPBWireFormatEndGroup));
   --state_.recursionDepth;
 }
 
 - (void)readUnknownGroup:(int32_t)fieldNumber
                  message:(GPBUnknownFieldSet *)message {
   if (state_.recursionDepth >= kDefaultRecursionLimit) {
-    [NSException raise:NSParseErrorException
-                format:@"recursionDepth(%tu) >= %tu", state_.recursionDepth,
-                       kDefaultRecursionLimit];
+    RaiseException(GPBCodedInputStreamErrorRecursionDepthExceeded, nil);
   }
   ++state_.recursionDepth;
   [message mergeFromCodedInputStream:self];
   GPBCodedInputStreamCheckLastTagWas(
       &state_, GPBWireFormatMakeTag(fieldNumber, GPBWireFormatEndGroup));
   --state_.recursionDepth;
 }
 
 - (void)readMessage:(GPBMessage *)message
     extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
   int32_t length = ReadRawVarint32(&state_);
   if (state_.recursionDepth >= kDefaultRecursionLimit) {
-    [NSException raise:NSParseErrorException
-                format:@"recursionDepth(%tu) >= %tu", state_.recursionDepth,
-                       kDefaultRecursionLimit];
+    RaiseException(GPBCodedInputStreamErrorRecursionDepthExceeded, nil);
   }
   size_t oldLimit = GPBCodedInputStreamPushLimit(&state_, length);
   ++state_.recursionDepth;
   [message mergeFromCodedInputStream:self extensionRegistry:extensionRegistry];
   GPBCodedInputStreamCheckLastTagWas(&state_, 0);
   --state_.recursionDepth;
   GPBCodedInputStreamPopLimit(&state_, oldLimit);
 }
 
 - (void)readMapEntry:(id)mapDictionary
     extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
                 field:(GPBFieldDescriptor *)field
         parentMessage:(GPBMessage *)parentMessage {
   int32_t length = ReadRawVarint32(&state_);
   if (state_.recursionDepth >= kDefaultRecursionLimit) {
-    [NSException raise:NSParseErrorException
-                format:@"recursionDepth(%tu) >= %tu", state_.recursionDepth,
-                       kDefaultRecursionLimit];
+    RaiseException(GPBCodedInputStreamErrorRecursionDepthExceeded, nil);
   }
   size_t oldLimit = GPBCodedInputStreamPushLimit(&state_, length);
   ++state_.recursionDepth;
   GPBDictionaryReadEntry(mapDictionary, self, extensionRegistry, field,
                          parentMessage);
   GPBCodedInputStreamCheckLastTagWas(&state_, 0);
   --state_.recursionDepth;
   GPBCodedInputStreamPopLimit(&state_, oldLimit);
 }
 
@@ skipping 18 matching lines @@
 }
 
 - (int32_t)readSInt32 {
   return GPBCodedInputStreamReadSInt32(&state_);
 }
 
 - (int64_t)readSInt64 {
   return GPBCodedInputStreamReadSInt64(&state_);
 }
 
+#pragma clang diagnostic pop
+
 @end