Update third_party/protobuf to protobuf-v3.0.0-beta-3

third_party/protobuf/objectivec/GPBDescriptor.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 17 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #import "GPBDescriptor_PackagePrivate.h"
 
 #import <objc/runtime.h>
 
 #import "GPBUtilities_PackagePrivate.h"
 #import "GPBWireFormat.h"
 #import "GPBMessage_PackagePrivate.h"
-#import "google/protobuf/Descriptor.pbobjc.h"
 
 // The address of this variable is used as a key for obj_getAssociatedObject.
 static const char kTextFormatExtraValueKey = 0;
 
 // Utility function to generate selectors on the fly.
 static SEL SelFromStrings(const char *prefix, const char *middle,
                           const char *suffix, BOOL takesArg) {
   if (prefix == NULL && suffix == NULL && !takesArg) {
     return sel_getUid(middle);
   }
@@ skipping 36 matching lines @@
   for (GPBFieldDescriptor *fieldDesc in allMessageFields) {
     if (fieldDesc->description_->hasIndex == hasIndex) {
       [result addObject:fieldDesc];
     }
   }
   return result;
 }
 
 @implementation GPBDescriptor {
   Class messageClass_;
-  NSArray *enums_;
   GPBFileDescriptor *file_;
   BOOL wireFormat_;
 }
 
 @synthesize messageClass = messageClass_;
 @synthesize fields = fields_;
 @synthesize oneofs = oneofs_;
-@synthesize enums = enums_;
 @synthesize extensionRanges = extensionRanges_;
 @synthesize extensionRangesCount = extensionRangesCount_;
 @synthesize file = file_;
 @synthesize wireFormat = wireFormat_;
 
 + (instancetype)
     allocDescriptorForClass:(Class)messageClass
                   rootClass:(Class)rootClass
                        file:(GPBFileDescriptor *)file
-                     fields:(GPBMessageFieldDescription *)fieldDescriptions
-                 fieldCount:(NSUInteger)fieldCount
-                     oneofs:(GPBMessageOneofDescription *)oneofDescriptions
-                 oneofCount:(NSUInteger)oneofCount
-                      enums:(GPBMessageEnumDescription *)enumDescriptions
-                  enumCount:(NSUInteger)enumCount
-                     ranges:(const GPBExtensionRange *)ranges
-                 rangeCount:(NSUInteger)rangeCount
-                storageSize:(size_t)storageSize
-                 wireFormat:(BOOL)wireFormat {
+                     fields:(void *)fieldDescriptions
+                 fieldCount:(uint32_t)fieldCount
+                storageSize:(uint32_t)storageSize
+                      flags:(GPBDescriptorInitializationFlags)flags {
+  // The rootClass is no longer used, but it is passed in to ensure it
+  // was started up during initialization also.
+  (void)rootClass;
   NSMutableArray *fields = nil;
-  NSMutableArray *oneofs = nil;
-  NSMutableArray *enums = nil;
-  NSMutableArray *extensionRanges = nil;
   GPBFileSyntax syntax = file.syntax;
-  for (NSUInteger i = 0; i < fieldCount; ++i) {
+  BOOL fieldsIncludeDefault =
+      (flags & GPBDescriptorInitializationFlag_FieldsWithDefault) != 0;
+
+  void *desc;
+  for (uint32_t i = 0; i < fieldCount; ++i) {
     if (fields == nil) {
       fields = [[NSMutableArray alloc] initWithCapacity:fieldCount];
     }
-    GPBFieldDescriptor *fieldDescriptor = [[GPBFieldDescriptor alloc]
-        initWithFieldDescription:&fieldDescriptions[i]
-                       rootClass:rootClass
-                          syntax:syntax];
+    // Need correctly typed pointer for array indexing below to work.
+    if (fieldsIncludeDefault) {
+      GPBMessageFieldDescriptionWithDefault *fieldDescWithDefault = fieldDescriptions;
+      desc = &(fieldDescWithDefault[i]);
+    } else {
+      GPBMessageFieldDescription *fieldDesc = fieldDescriptions;
+      desc = &(fieldDesc[i]);
+    }
+    GPBFieldDescriptor *fieldDescriptor =
+        [[GPBFieldDescriptor alloc] initWithFieldDescription:desc
+                                             includesDefault:fieldsIncludeDefault
+                                                      syntax:syntax];
     [fields addObject:fieldDescriptor];
     [fieldDescriptor release];
   }
-  for (NSUInteger i = 0; i < oneofCount; ++i) {
-    if (oneofs == nil) {
-      oneofs = [[NSMutableArray alloc] initWithCapacity:oneofCount];
-    }
-    GPBMessageOneofDescription *oneofDescription = &oneofDescriptions[i];
-    NSArray *fieldsForOneof =
-        NewFieldsArrayForHasIndex(oneofDescription->index, fields);
-    GPBOneofDescriptor *oneofDescriptor =
-        [[GPBOneofDescriptor alloc] initWithOneofDescription:oneofDescription
-                                                      fields:fieldsForOneof];
-    [oneofs addObject:oneofDescriptor];
-    [oneofDescriptor release];
-    [fieldsForOneof release];
-  }
-  for (NSUInteger i = 0; i < enumCount; ++i) {
-    if (enums == nil) {
-      enums = [[NSMutableArray alloc] initWithCapacity:enumCount];
-    }
-    GPBEnumDescriptor *enumDescriptor =
-        enumDescriptions[i].enumDescriptorFunc();
-    [enums addObject:enumDescriptor];
-  }
 
+  BOOL wireFormat = (flags & GPBDescriptorInitializationFlag_WireFormat) != 0;
   GPBDescriptor *descriptor = [[self alloc] initWithClass:messageClass
                                                      file:file
                                                    fields:fields
-                                                   oneofs:oneofs
-                                                    enums:enums
-                                          extensionRanges:ranges
-                                     extensionRangesCount:rangeCount
                                               storageSize:storageSize
                                                wireFormat:wireFormat];
   [fields release];
-  [oneofs release];
-  [enums release];
-  [extensionRanges release];
-  return descriptor;
-}
-
-+ (instancetype)
-    allocDescriptorForClass:(Class)messageClass
-                  rootClass:(Class)rootClass
-                       file:(GPBFileDescriptor *)file
-                     fields:(GPBMessageFieldDescription *)fieldDescriptions
-                 fieldCount:(NSUInteger)fieldCount
-                     oneofs:(GPBMessageOneofDescription *)oneofDescriptions
-                 oneofCount:(NSUInteger)oneofCount
-                      enums:(GPBMessageEnumDescription *)enumDescriptions
-                  enumCount:(NSUInteger)enumCount
-                     ranges:(const GPBExtensionRange *)ranges
-                 rangeCount:(NSUInteger)rangeCount
-                storageSize:(size_t)storageSize
-                 wireFormat:(BOOL)wireFormat
-        extraTextFormatInfo:(const char *)extraTextFormatInfo {
-  GPBDescriptor *descriptor = [self allocDescriptorForClass:messageClass
-                                                  rootClass:rootClass
-                                                       file:file
-                                                     fields:fieldDescriptions
-                                                 fieldCount:fieldCount
-                                                     oneofs:oneofDescriptions
-                                                 oneofCount:oneofCount
-                                                      enums:enumDescriptions
-                                                  enumCount:enumCount
-                                                     ranges:ranges
-                                                 rangeCount:rangeCount
-                                                storageSize:storageSize
-                                                 wireFormat:wireFormat];
-  // Extra info is a compile time option, so skip the work if not needed.
-  if (extraTextFormatInfo) {
-    NSValue *extraInfoValue = [NSValue valueWithPointer:extraTextFormatInfo];
-    for (GPBFieldDescriptor *fieldDescriptor in descriptor->fields_) {
-      if (fieldDescriptor->description_->flags & GPBFieldTextFormatNameCustom) {
-        objc_setAssociatedObject(fieldDescriptor, &kTextFormatExtraValueKey,
-                                 extraInfoValue,
-                                 OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-      }
-    }
-  }
   return descriptor;
 }
 
 - (instancetype)initWithClass:(Class)messageClass
                          file:(GPBFileDescriptor *)file
                        fields:(NSArray *)fields
-                       oneofs:(NSArray *)oneofs
-                        enums:(NSArray *)enums
-              extensionRanges:(const GPBExtensionRange *)extensionRanges
-         extensionRangesCount:(NSUInteger)extensionRangesCount
-                  storageSize:(size_t)storageSize
+                  storageSize:(uint32_t)storageSize
                    wireFormat:(BOOL)wireFormat {
   if ((self = [super init])) {
     messageClass_ = messageClass;
     file_ = file;
     fields_ = [fields retain];
-    oneofs_ = [oneofs retain];
-    enums_ = [enums retain];
-    extensionRanges_ = extensionRanges;
-    extensionRangesCount_ = extensionRangesCount;
     storageSize_ = storageSize;
     wireFormat_ = wireFormat;
   }
   return self;
 }
 
 - (void)dealloc {
   [fields_ release];
   [oneofs_ release];
-  [enums_ release];
   [super dealloc];
 }
 
+- (void)setupOneofs:(const char **)oneofNames
+              count:(uint32_t)count
+      firstHasIndex:(int32_t)firstHasIndex {
+  NSCAssert(firstHasIndex < 0, @"Should always be <0");
+  NSMutableArray *oneofs = [[NSMutableArray alloc] initWithCapacity:count];
+  for (uint32_t i = 0, hasIndex = firstHasIndex; i < count; ++i, --hasIndex) {
+    const char *name = oneofNames[i];
+    NSArray *fieldsForOneof = NewFieldsArrayForHasIndex(hasIndex, fields_);
+    NSCAssert(fieldsForOneof.count > 0,
+              @"No fields for this oneof? (%s:%d)", name, hasIndex);
+    GPBOneofDescriptor *oneofDescriptor =
+        [[GPBOneofDescriptor alloc] initWithName:name fields:fieldsForOneof];
+    [oneofs addObject:oneofDescriptor];
+    [oneofDescriptor release];
+    [fieldsForOneof release];
+  }
+  oneofs_ = oneofs;
+}
+
+- (void)setupExtraTextInfo:(const char *)extraTextFormatInfo {
+  // Extra info is a compile time option, so skip the work if not needed.
+  if (extraTextFormatInfo) {
+    NSValue *extraInfoValue = [NSValue valueWithPointer:extraTextFormatInfo];
+    for (GPBFieldDescriptor *fieldDescriptor in fields_) {
+      if (fieldDescriptor->description_->flags & GPBFieldTextFormatNameCustom) {
+        objc_setAssociatedObject(fieldDescriptor, &kTextFormatExtraValueKey,
+                                 extraInfoValue,
+                                 OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+      }
+    }
+  }
+}
+
+- (void)setupExtensionRanges:(const GPBExtensionRange *)ranges count:(int32_t)count {
+  extensionRanges_ = ranges;
+  extensionRangesCount_ = count;
+}
+
 - (NSString *)name {
   return NSStringFromClass(messageClass_);
 }
 
 - (id)copyWithZone:(NSZone *)zone {
 #pragma unused(zone)
   return [self retain];
 }
 
 - (GPBFieldDescriptor *)fieldWithNumber:(uint32_t)fieldNumber {
@@ skipping 16 matching lines @@
 
 - (GPBOneofDescriptor *)oneofWithName:(NSString *)name {
   for (GPBOneofDescriptor *descriptor in oneofs_) {
     if ([descriptor.name isEqual:name]) {
       return descriptor;
     }
   }
   return nil;
 }
 
-- (GPBEnumDescriptor *)enumWithName:(NSString *)name {
-  for (GPBEnumDescriptor *descriptor in enums_) {
-    if ([descriptor.name isEqual:name]) {
-      return descriptor;
-    }
-  }
-  return nil;
-}
-
 @end
 
 @implementation GPBFileDescriptor {
   NSString *package_;
   GPBFileSyntax syntax_;
 }
 
 @synthesize package = package_;
 @synthesize syntax = syntax_;
 
 - (instancetype)initWithPackage:(NSString *)package
                          syntax:(GPBFileSyntax)syntax {
   self = [super init];
   if (self) {
     package_ = [package copy];
     syntax_ = syntax;
   }
   return self;
 }
 
 @end
 
 @implementation GPBOneofDescriptor
 
 @synthesize fields = fields_;
 
-- (instancetype)initWithOneofDescription:
-                    (GPBMessageOneofDescription *)oneofDescription
-                                  fields:(NSArray *)fields {
+- (instancetype)initWithName:(const char *)name fields:(NSArray *)fields {
   self = [super init];
   if (self) {
-    NSAssert(oneofDescription->index < 0, @"Should always be <0");
-    oneofDescription_ = oneofDescription;
+    name_ = name;
     fields_ = [fields retain];
     for (GPBFieldDescriptor *fieldDesc in fields) {
       fieldDesc->containingOneof_ = self;
     }
 
-    caseSel_ = SelFromStrings(NULL, oneofDescription->name, "OneOfCase", NO);
+    caseSel_ = SelFromStrings(NULL, name, "OneOfCase", NO);
   }
   return self;
 }
 
 - (void)dealloc {
   [fields_ release];
   [super dealloc];
 }
 
 - (NSString *)name {
-  return @(oneofDescription_->name);
+  return @(name_);
 }
 
 - (GPBFieldDescriptor *)fieldWithNumber:(uint32_t)fieldNumber {
   for (GPBFieldDescriptor *descriptor in fields_) {
     if (GPBFieldNumber(descriptor) == fieldNumber) {
       return descriptor;
     }
   }
   return nil;
 }
@@ skipping 27 matching lines @@
   NSCAssert((description->flags & GPBFieldRepeated) != 0,
             @"Only valid on repeated fields");
   GPBWireFormat format =
       GPBWireFormatForType(description->dataType,
                            ((description->flags & GPBFieldPacked) == 0));
   return GPBWireFormatMakeTag(description->number, format);
 }
 
 @implementation GPBFieldDescriptor {
   GPBGenericValue defaultValue_;
-  GPBFieldOptions *fieldOptions_;
 
   // Message ivars
   Class msgClass_;
 
   // Enum ivars.
   // If protos are generated with GenerateEnumDescriptors on then it will
   // be a enumDescriptor, otherwise it will be a enumVerifier.
   union {
     GPBEnumDescriptor *enumDescriptor_;
     GPBEnumValidationFunc enumVerifier_;
   } enumHandling_;
 }
 
-@synthesize fieldOptions = fieldOptions_;
 @synthesize msgClass = msgClass_;
 @synthesize containingOneof = containingOneof_;
 
 - (instancetype)init {
   // Throw an exception if people attempt to not use the designated initializer.
   self = [super init];
   if (self != nil) {
     [self doesNotRecognizeSelector:_cmd];
     self = nil;
   }
   return self;
 }
 
-- (instancetype)initWithFieldDescription:
-                    (GPBMessageFieldDescription *)description
-                               rootClass:(Class)rootClass
+- (instancetype)initWithFieldDescription:(void *)description
+                         includesDefault:(BOOL)includesDefault
                                   syntax:(GPBFileSyntax)syntax {
   if ((self = [super init])) {
-    description_ = description;
-    getSel_ = sel_getUid(description->name);
-    setSel_ = SelFromStrings("set", description->name, NULL, YES);
+    GPBMessageFieldDescription *coreDesc;
+    if (includesDefault) {
+      coreDesc = &(((GPBMessageFieldDescriptionWithDefault *)description)->core);
+    } else {
+      coreDesc = description;
+    }
+    description_ = coreDesc;
+    getSel_ = sel_getUid(coreDesc->name);
+    setSel_ = SelFromStrings("set", coreDesc->name, NULL, YES);
 
-    GPBDataType dataType = description->dataType;
+    GPBDataType dataType = coreDesc->dataType;
     BOOL isMessage = GPBDataTypeIsMessage(dataType);
     BOOL isMapOrArray = GPBFieldIsMapOrArray(self);
 
     if (isMapOrArray) {
       // map<>/repeated fields get a *Count property (inplace of a has*) to
       // support checking if there are any entries without triggering
       // autocreation.
-      hasOrCountSel_ = SelFromStrings(NULL, description->name, "_Count", NO);
+      hasOrCountSel_ = SelFromStrings(NULL, coreDesc->name, "_Count", NO);
     } else {
       // If there is a positive hasIndex, then:
       //   - All fields types for proto2 messages get has* selectors.
       //   - Only message fields for proto3 messages get has* selectors.
       // Note: the positive check is to handle oneOfs, we can't check
       // containingOneof_ because it isn't set until after initialization.
-      if ((description->hasIndex >= 0) &&
-          (description->hasIndex != GPBNoHasBit) &&
+      if ((coreDesc->hasIndex >= 0) &&
+          (coreDesc->hasIndex != GPBNoHasBit) &&
           ((syntax != GPBFileSyntaxProto3) || isMessage)) {
-        hasOrCountSel_ = SelFromStrings("has", description->name, NULL, NO);
-        setHasSel_ = SelFromStrings("setHas", description->name, NULL, YES);
+        hasOrCountSel_ = SelFromStrings("has", coreDesc->name, NULL, NO);
+        setHasSel_ = SelFromStrings("setHas", coreDesc->name, NULL, YES);
       }
     }
 
     // Extra type specific data.
     if (isMessage) {
-      const char *className = description->dataTypeSpecific.className;
+      const char *className = coreDesc->dataTypeSpecific.className;
       msgClass_ = objc_getClass(className);
       NSAssert(msgClass_, @"Class %s not defined", className);
     } else if (dataType == GPBDataTypeEnum) {
-      if ((description_->flags & GPBFieldHasEnumDescriptor) != 0) {
+      if ((coreDesc->flags & GPBFieldHasEnumDescriptor) != 0) {
         enumHandling_.enumDescriptor_ =
-            description->dataTypeSpecific.enumDescFunc();
+            coreDesc->dataTypeSpecific.enumDescFunc();
       } else {
         enumHandling_.enumVerifier_ =
-            description->dataTypeSpecific.enumVerifier;
+            coreDesc->dataTypeSpecific.enumVerifier;
       }
     }
 
-    // Non map<>/repeated fields can have defaults.
-    if (!isMapOrArray) {
-      defaultValue_ = description->defaultValue;
+    // Non map<>/repeated fields can have defaults in proto2 syntax.
+    if (!isMapOrArray && includesDefault) {
+      defaultValue_ = ((GPBMessageFieldDescriptionWithDefault *)description)->defaultValue;
       if (dataType == GPBDataTypeBytes) {
         // Data stored as a length prefixed (network byte order) c-string in
         // descriptor structure.
         const uint8_t *bytes = (const uint8_t *)defaultValue_.valueData;
         if (bytes) {
           uint32_t length = *((uint32_t *)bytes);
           length = ntohl(length);
           bytes += sizeof(length);
           defaultValue_.valueData =
               [[NSData alloc] initWithBytes:bytes length:length];
         }
       }
     }
-
-    // FieldOptions stored as a length prefixed (network byte order) c-escaped
-    // string in descriptor records.
-    if (description->fieldOptions) {
-      uint8_t *optionsBytes = (uint8_t *)description->fieldOptions;
-      uint32_t optionsLength = *((uint32_t *)optionsBytes);
-      optionsLength = ntohl(optionsLength);
-      if (optionsLength > 0) {
-        optionsBytes += sizeof(optionsLength);
-        NSData *optionsData = [NSData dataWithBytesNoCopy:optionsBytes
-                                                   length:optionsLength
-                                             freeWhenDone:NO];
-        GPBExtensionRegistry *registry = [rootClass extensionRegistry];
-        fieldOptions_ = [[GPBFieldOptions parseFromData:optionsData
-                                      extensionRegistry:registry
-                                                  error:NULL] retain];
-      }
-    }
   }
   return self;
 }
 
 - (void)dealloc {
   if (description_->dataType == GPBDataTypeBytes &&
       !(description_->flags & GPBFieldRepeated)) {
     [defaultValue_.valueData release];
   }
   [super dealloc];
@@ skipping 148 matching lines @@
       NSString *result =
           [name stringByReplacingCharactersInRange:NSMakeRange(0, 1)
                                         withString:firstCharString];
       return result;
     }
     return name;
 
   } else {
     // Undo the CamelCase.
     NSMutableString *result = [NSMutableString stringWithCapacity:len];
-    for (NSUInteger i = 0; i < len; i++) {
+    for (uint32_t i = 0; i < len; i++) {
       unichar c = [name characterAtIndex:i];
       if (c >= 'A' && c <= 'Z') {
         if (i > 0) {
           [result appendFormat:@"_%C", (unichar)(c - 'A' + 'a')];
         } else {
           [result appendFormat:@"%C", c];
         }
       } else {
         [result appendFormat:@"%C", c];
       }
     }
     return result;
   }
 }
 
 @end
 
 @implementation GPBEnumDescriptor {
   NSString *name_;
-  GPBMessageEnumValueDescription *valueDescriptions_;
-  NSUInteger valueDescriptionsCount_;
+  // valueNames_ is a single c string with all of the value names appended
+  // together, each null terminated.  -calcValueNameOffsets fills in
+  // nameOffsets_ with the offsets to allow quicker access to the individual
+  // names.
+  const char *valueNames_;
+  const int32_t *values_;
   GPBEnumValidationFunc enumVerifier_;
   const uint8_t *extraTextFormatInfo_;
+  uint32_t *nameOffsets_;
+  uint32_t valueCount_;
 }
 
 @synthesize name = name_;
 @synthesize enumVerifier = enumVerifier_;
 
 + (instancetype)
     allocDescriptorForName:(NSString *)name
-                    values:(GPBMessageEnumValueDescription *)valueDescriptions
-                valueCount:(NSUInteger)valueCount
+                valueNames:(const char *)valueNames
+                    values:(const int32_t *)values
+                     count:(uint32_t)valueCount
               enumVerifier:(GPBEnumValidationFunc)enumVerifier {
   GPBEnumDescriptor *descriptor = [[self alloc] initWithName:name
-                                                      values:valueDescriptions
-                                                  valueCount:valueCount
+                                                  valueNames:valueNames
+                                                      values:values
+                                                       count:valueCount
                                                 enumVerifier:enumVerifier];
   return descriptor;
 }
 
 + (instancetype)
     allocDescriptorForName:(NSString *)name
-                    values:(GPBMessageEnumValueDescription *)valueDescriptions
-                valueCount:(NSUInteger)valueCount
+                valueNames:(const char *)valueNames
+                    values:(const int32_t *)values
+                     count:(uint32_t)valueCount
               enumVerifier:(GPBEnumValidationFunc)enumVerifier
        extraTextFormatInfo:(const char *)extraTextFormatInfo {
   // Call the common case.
   GPBEnumDescriptor *descriptor = [self allocDescriptorForName:name
-                                                        values:valueDescriptions
-                                                    valueCount:valueCount
+                                                    valueNames:valueNames
+                                                        values:values
+                                                         count:valueCount
                                                   enumVerifier:enumVerifier];
   // Set the extra info.
   descriptor->extraTextFormatInfo_ = (const uint8_t *)extraTextFormatInfo;
   return descriptor;
 }
 
 - (instancetype)initWithName:(NSString *)name
-                      values:(GPBMessageEnumValueDescription *)valueDescriptions
-                  valueCount:(NSUInteger)valueCount
+                  valueNames:(const char *)valueNames
+                      values:(const int32_t *)values
+                       count:(uint32_t)valueCount
                 enumVerifier:(GPBEnumValidationFunc)enumVerifier {
   if ((self = [super init])) {
     name_ = [name copy];
-    valueDescriptions_ = valueDescriptions;
-    valueDescriptionsCount_ = valueCount;
+    valueNames_ = valueNames;
+    values_ = values;
+    valueCount_ = valueCount;
     enumVerifier_ = enumVerifier;
   }
   return self;
 }
 
+- (void)dealloc {
+  [name_ release];
+  if (nameOffsets_) free(nameOffsets_);
+  [super dealloc];
+}
+
+- (void)calcValueNameOffsets {
+  @synchronized(self) {
+    if (nameOffsets_ != NULL) {
+      return;
+    }
+    uint32_t *offsets = malloc(valueCount_ * sizeof(uint32_t));
+    const char *scan = valueNames_;
+    for (uint32_t i = 0; i < valueCount_; ++i) {
+      offsets[i] = (uint32_t)(scan - valueNames_);
+      while (*scan != '\0') ++scan;
+      ++scan;  // Step over the null.
+    }
+    nameOffsets_ = offsets;
+  }
+}
+
 - (NSString *)enumNameForValue:(int32_t)number {
-  for (NSUInteger i = 0; i < valueDescriptionsCount_; ++i) {
-    GPBMessageEnumValueDescription *scan = &valueDescriptions_[i];
-    if ((scan->number == number) && (scan->name != NULL)) {
-      NSString *fullName =
-          [NSString stringWithFormat:@"%@_%s", name_, scan->name];
+  if (nameOffsets_ == NULL) [self calcValueNameOffsets];
+
+  for (uint32_t i = 0; i < valueCount_; ++i) {
+    if (values_[i] == number) {
+      const char *valueName = valueNames_ + nameOffsets_[i];
+      NSString *fullName = [NSString stringWithFormat:@"%@_%s", name_, valueName];
       return fullName;
     }
   }
   return nil;
 }
 
 - (BOOL)getValue:(int32_t *)outValue forEnumName:(NSString *)name {
   // Must have the prefix.
   NSUInteger prefixLen = name_.length + 1;
   if ((name.length <= prefixLen) || ![name hasPrefix:name_] ||
       ([name characterAtIndex:prefixLen - 1] != '_')) {
     return NO;
   }
 
   // Skip over the prefix.
   const char *nameAsCStr = [name UTF8String];
   nameAsCStr += prefixLen;
 
+  if (nameOffsets_ == NULL) [self calcValueNameOffsets];
+
   // Find it.
-  for (NSUInteger i = 0; i < valueDescriptionsCount_; ++i) {
-    GPBMessageEnumValueDescription *scan = &valueDescriptions_[i];
-    if ((scan->name != NULL) && (strcmp(nameAsCStr, scan->name) == 0)) {
+  for (uint32_t i = 0; i < valueCount_; ++i) {
+    const char *valueName = valueNames_ + nameOffsets_[i];
+    if (strcmp(nameAsCStr, valueName) == 0) {
       if (outValue) {
-        *outValue = scan->number;
+        *outValue = values_[i];
       }
       return YES;
     }
   }
   return NO;
 }
 
-- (void)dealloc {
-  [name_ release];
-  [super dealloc];
-}
+- (NSString *)textFormatNameForValue:(int32_t)number {
+  if (nameOffsets_ == NULL) [self calcValueNameOffsets];
 
-- (NSString *)textFormatNameForValue:(int32_t)number {
   // Find the EnumValue descriptor and its index.
-  GPBMessageEnumValueDescription *valueDescriptor = NULL;
-  NSUInteger valueDescriptorIndex;
-  for (valueDescriptorIndex = 0; valueDescriptorIndex < valueDescriptionsCount_;
+  BOOL foundIt = NO;
+  uint32_t valueDescriptorIndex;
+  for (valueDescriptorIndex = 0; valueDescriptorIndex < valueCount_;
        ++valueDescriptorIndex) {
-    GPBMessageEnumValueDescription *scan =
-        &valueDescriptions_[valueDescriptorIndex];
-    if (scan->number == number) {
-      valueDescriptor = scan;
+    if (values_[valueDescriptorIndex] == number) {
+      foundIt = YES;
       break;
     }
   }
 
-  // If we didn't find it, or names were disable at proto compile time, nothing
-  // we can do.
-  if (!valueDescriptor || !valueDescriptor->name) {
+  if (!foundIt) {
     return nil;
   }
 
   NSString *result = nil;
   // Naming adds an underscore between enum name and value name, skip that also.
-  NSString *shortName = @(valueDescriptor->name);
+  const char *valueName = valueNames_ + nameOffsets_[valueDescriptorIndex];
+  NSString *shortName = @(valueName);
 
   // See if it is in the map of special format handling.
   if (extraTextFormatInfo_) {
     result = GPBDecodeTextFormatName(extraTextFormatInfo_,
                                      (int32_t)valueDescriptorIndex, shortName);
   }
   // Logic here needs to match what objectivec_enum.cc does in the proto
   // compiler.
   if (result == nil) {
     NSUInteger len = [shortName length];
@@ skipping 174 matching lines @@
   if (selfNumber < otherNumber) {
     return NSOrderedAscending;
   } else if (selfNumber == otherNumber) {
     return NSOrderedSame;
   } else {
     return NSOrderedDescending;
   }
 }
 
 @end