iOS/Pods/Protobuf/objectivec/GPBDescriptor.m

   1 // Protocol Buffers - Google's data interchange format
   2 // Copyright 2008 Google Inc.  All rights reserved.
   3 // https://developers.google.com/protocol-buffers/
   4 //
   5 // Redistribution and use in source and binary forms, with or without
   6 // modification, are permitted provided that the following conditions are
   7 // met:
   8 //
   9 //     * Redistributions of source code must retain the above copyright
  10 // notice, this list of conditions and the following disclaimer.
  11 //     * Redistributions in binary form must reproduce the above
  12 // copyright notice, this list of conditions and the following disclaimer
  13 // in the documentation and/or other materials provided with the
  14 // distribution.
  15 //     * Neither the name of Google Inc. nor the names of its
  16 // contributors may be used to endorse or promote products derived from
  17 // this software without specific prior written permission.
  18 //
  19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30
  31 #import "GPBDescriptor_PackagePrivate.h"
  32
  33 #import <objc/runtime.h>
  34
  35 #import "GPBUtilities_PackagePrivate.h"
  36 #import "GPBWireFormat.h"
  37 #import "GPBMessage_PackagePrivate.h"
  38
  39 // Direct access is use for speed, to avoid even internally declaring things
  40 // read/write, etc. The warning is enabled in the project to ensure code calling
  41 // protos can turn on -Wdirect-ivar-access without issues.
  42 #pragma clang diagnostic push
  43 #pragma clang diagnostic ignored "-Wdirect-ivar-access"
  44
  45 // The addresses of these variables are used as keys for objc_getAssociatedObject.
  46 static const char kTextFormatExtraValueKey = 0;
  47 static const char kParentClassNameValueKey = 0;
  48 static const char kClassNameSuffixKey = 0;
  49
  50 // Utility function to generate selectors on the fly.
  51 static SEL SelFromStrings(const char *prefix, const char *middle,
  52                           const char *suffix, BOOL takesArg) {
  53   if (prefix == NULL && suffix == NULL && !takesArg) {
  54     return sel_getUid(middle);
  55   }
  56   const size_t prefixLen = prefix != NULL ? strlen(prefix) : 0;
  57   const size_t middleLen = strlen(middle);
  58   const size_t suffixLen = suffix != NULL ? strlen(suffix) : 0;
  59   size_t totalLen =
  60       prefixLen + middleLen + suffixLen + 1;  // include space for null on end.
  61   if (takesArg) {
  62     totalLen += 1;
  63   }
  64   char buffer[totalLen];
  65   if (prefix != NULL) {
  66     memcpy(buffer, prefix, prefixLen);
  67     memcpy(buffer + prefixLen, middle, middleLen);
  68     buffer[prefixLen] = (char)toupper(buffer[prefixLen]);
  69   } else {
  70     memcpy(buffer, middle, middleLen);
  71   }
  72   if (suffix != NULL) {
  73     memcpy(buffer + prefixLen + middleLen, suffix, suffixLen);
  74   }
  75   if (takesArg) {
  76     buffer[totalLen - 2] = ':';
  77   }
  78   // Always null terminate it.
  79   buffer[totalLen - 1] = 0;
  80
  81   SEL result = sel_getUid(buffer);
  82   return result;
  83 }
  84
  85 static NSArray *NewFieldsArrayForHasIndex(int hasIndex,
  86                                           NSArray *allMessageFields)
  87     __attribute__((ns_returns_retained));
  88
  89 static NSArray *NewFieldsArrayForHasIndex(int hasIndex,
  90                                           NSArray *allMessageFields) {
  91   NSMutableArray *result = [[NSMutableArray alloc] init];
  92   for (GPBFieldDescriptor *fieldDesc in allMessageFields) {
  93     if (fieldDesc->description_->hasIndex == hasIndex) {
  94       [result addObject:fieldDesc];
  95     }
  96   }
  97   return result;
  98 }
  99
 100 @implementation GPBDescriptor {
 101   Class messageClass_;
 102   GPBFileDescriptor *file_;
 103   BOOL wireFormat_;
 104 }
 105
 106 @synthesize messageClass = messageClass_;
 107 @synthesize fields = fields_;
 108 @synthesize oneofs = oneofs_;
 109 @synthesize extensionRanges = extensionRanges_;
 110 @synthesize extensionRangesCount = extensionRangesCount_;
 111 @synthesize file = file_;
 112 @synthesize wireFormat = wireFormat_;
 113
 114 + (instancetype)
 115     allocDescriptorForClass:(Class)messageClass
 116                   rootClass:(Class)rootClass
 117                        file:(GPBFileDescriptor *)file
 118                      fields:(void *)fieldDescriptions
 119                  fieldCount:(uint32_t)fieldCount
 120                 storageSize:(uint32_t)storageSize
 121                       flags:(GPBDescriptorInitializationFlags)flags {
 122   // The rootClass is no longer used, but it is passed in to ensure it
 123   // was started up during initialization also.
 124   (void)rootClass;
 125   NSMutableArray *fields = nil;
 126   GPBFileSyntax syntax = file.syntax;
 127   BOOL fieldsIncludeDefault =
 128       (flags & GPBDescriptorInitializationFlag_FieldsWithDefault) != 0;
 129
 130   void *desc;
 131   for (uint32_t i = 0; i < fieldCount; ++i) {
 132     if (fields == nil) {
 133       fields = [[NSMutableArray alloc] initWithCapacity:fieldCount];
 134     }
 135     // Need correctly typed pointer for array indexing below to work.
 136     if (fieldsIncludeDefault) {
 137       GPBMessageFieldDescriptionWithDefault *fieldDescWithDefault = fieldDescriptions;
 138       desc = &(fieldDescWithDefault[i]);
 139     } else {
 140       GPBMessageFieldDescription *fieldDesc = fieldDescriptions;
 141       desc = &(fieldDesc[i]);
 142     }
 143     GPBFieldDescriptor *fieldDescriptor =
 144         [[GPBFieldDescriptor alloc] initWithFieldDescription:desc
 145                                              includesDefault:fieldsIncludeDefault
 146                                                       syntax:syntax];
 147     [fields addObject:fieldDescriptor];
 148     [fieldDescriptor release];
 149   }
 150
 151   BOOL wireFormat = (flags & GPBDescriptorInitializationFlag_WireFormat) != 0;
 152   GPBDescriptor *descriptor = [[self alloc] initWithClass:messageClass
 153                                                      file:file
 154                                                    fields:fields
 155                                               storageSize:storageSize
 156                                                wireFormat:wireFormat];
 157   [fields release];
 158   return descriptor;
 159 }
 160
 161 - (instancetype)initWithClass:(Class)messageClass
 162                          file:(GPBFileDescriptor *)file
 163                        fields:(NSArray *)fields
 164                   storageSize:(uint32_t)storageSize
 165                    wireFormat:(BOOL)wireFormat {
 166   if ((self = [super init])) {
 167     messageClass_ = messageClass;
 168     file_ = file;
 169     fields_ = [fields retain];
 170     storageSize_ = storageSize;
 171     wireFormat_ = wireFormat;
 172   }
 173   return self;
 174 }
 175
 176 - (void)dealloc {
 177   [fields_ release];
 178   [oneofs_ release];
 179   [super dealloc];
 180 }
 181
 182 - (void)setupOneofs:(const char **)oneofNames
 183               count:(uint32_t)count
 184       firstHasIndex:(int32_t)firstHasIndex {
 185   NSCAssert(firstHasIndex < 0, @"Should always be <0");
 186   NSMutableArray *oneofs = [[NSMutableArray alloc] initWithCapacity:count];
 187   for (uint32_t i = 0, hasIndex = firstHasIndex; i < count; ++i, --hasIndex) {
 188     const char *name = oneofNames[i];
 189     NSArray *fieldsForOneof = NewFieldsArrayForHasIndex(hasIndex, fields_);
 190     NSCAssert(fieldsForOneof.count > 0,
 191               @"No fields for this oneof? (%s:%d)", name, hasIndex);
 192     GPBOneofDescriptor *oneofDescriptor =
 193         [[GPBOneofDescriptor alloc] initWithName:name fields:fieldsForOneof];
 194     [oneofs addObject:oneofDescriptor];
 195     [oneofDescriptor release];
 196     [fieldsForOneof release];
 197   }
 198   oneofs_ = oneofs;
 199 }
 200
 201 - (void)setupExtraTextInfo:(const char *)extraTextFormatInfo {
 202   // Extra info is a compile time option, so skip the work if not needed.
 203   if (extraTextFormatInfo) {
 204     NSValue *extraInfoValue = [NSValue valueWithPointer:extraTextFormatInfo];
 205     for (GPBFieldDescriptor *fieldDescriptor in fields_) {
 206       if (fieldDescriptor->description_->flags & GPBFieldTextFormatNameCustom) {
 207         objc_setAssociatedObject(fieldDescriptor, &kTextFormatExtraValueKey,
 208                                  extraInfoValue,
 209                                  OBJC_ASSOCIATION_RETAIN_NONATOMIC);
 210       }
 211     }
 212   }
 213 }
 214
 215 - (void)setupExtensionRanges:(const GPBExtensionRange *)ranges count:(int32_t)count {
 216   extensionRanges_ = ranges;
 217   extensionRangesCount_ = count;
 218 }
 219
 220 - (void)setupContainingMessageClassName:(const char *)msgClassName {
 221   // Note: Only fetch the class here, can't send messages to it because
 222   // that could cause cycles back to this class within +initialize if
 223   // two messages have each other in fields (i.e. - they build a graph).
 224   NSAssert(objc_getClass(msgClassName), @"Class %s not defined", msgClassName);
 225   NSValue *parentNameValue = [NSValue valueWithPointer:msgClassName];
 226   objc_setAssociatedObject(self, &kParentClassNameValueKey,
 227                            parentNameValue,
 228                            OBJC_ASSOCIATION_RETAIN_NONATOMIC);
 229 }
 230
 231 - (void)setupMessageClassNameSuffix:(NSString *)suffix {
 232   if (suffix.length) {
 233     objc_setAssociatedObject(self, &kClassNameSuffixKey,
 234                              suffix,
 235                              OBJC_ASSOCIATION_RETAIN_NONATOMIC);
 236   }
 237 }
 238
 239 - (NSString *)name {
 240   return NSStringFromClass(messageClass_);
 241 }
 242
 243 - (GPBDescriptor *)containingType {
 244   NSValue *parentNameValue =
 245       objc_getAssociatedObject(self, &kParentClassNameValueKey);
 246   if (!parentNameValue) {
 247     return nil;
 248   }
 249   const char *parentName = [parentNameValue pointerValue];
 250   Class parentClass = objc_getClass(parentName);
 251   NSAssert(parentClass, @"Class %s not defined", parentName);
 252   return [parentClass descriptor];
 253 }
 254
 255 - (NSString *)fullName {
 256   NSString *className = NSStringFromClass(self.messageClass);
 257   GPBFileDescriptor *file = self.file;
 258   NSString *objcPrefix = file.objcPrefix;
 259   if (objcPrefix && ![className hasPrefix:objcPrefix]) {
 260     NSAssert(0,
 261              @"Class didn't have correct prefix? (%@ - %@)",
 262              className, objcPrefix);
 263     return nil;
 264   }
 265   GPBDescriptor *parent = self.containingType;
 266
 267   NSString *name = nil;
 268   if (parent) {
 269     NSString *parentClassName = NSStringFromClass(parent.messageClass);
 270     // The generator will add _Class to avoid reserved words, drop it.
 271     NSString *suffix = objc_getAssociatedObject(parent, &kClassNameSuffixKey);
 272     if (suffix) {
 273       if (![parentClassName hasSuffix:suffix]) {
 274         NSAssert(0,
 275                  @"ParentMessage class didn't have correct suffix? (%@ - %@)",
 276                  className, suffix);
 277         return nil;
 278       }
 279       parentClassName =
 280           [parentClassName substringToIndex:(parentClassName.length - suffix.length)];
 281     }
 282     NSString *parentPrefix = [parentClassName stringByAppendingString:@"_"];
 283     if (![className hasPrefix:parentPrefix]) {
 284       NSAssert(0,
 285                @"Class didn't have the correct parent name prefix? (%@ - %@)",
 286                parentPrefix, className);
 287       return nil;
 288     }
 289     name = [className substringFromIndex:parentPrefix.length];
 290   } else {
 291     name = [className substringFromIndex:objcPrefix.length];
 292   }
 293
 294   // The generator will add _Class to avoid reserved words, drop it.
 295   NSString *suffix = objc_getAssociatedObject(self, &kClassNameSuffixKey);
 296   if (suffix) {
 297     if (![name hasSuffix:suffix]) {
 298       NSAssert(0,
 299                @"Message class didn't have correct suffix? (%@ - %@)",
 300                name, suffix);
 301       return nil;
 302     }
 303     name = [name substringToIndex:(name.length - suffix.length)];
 304   }
 305
 306   NSString *prefix = (parent != nil ? parent.fullName : file.package);
 307   NSString *result;
 308   if (prefix.length > 0) {
 309     result = [NSString stringWithFormat:@"%@.%@", prefix, name];
 310   } else {
 311     result = name;
 312   }
 313   return result;
 314 }
 315
 316 - (id)copyWithZone:(NSZone *)zone {
 317 #pragma unused(zone)
 318   return [self retain];
 319 }
 320
 321 - (GPBFieldDescriptor *)fieldWithNumber:(uint32_t)fieldNumber {
 322   for (GPBFieldDescriptor *descriptor in fields_) {
 323     if (GPBFieldNumber(descriptor) == fieldNumber) {
 324       return descriptor;
 325     }
 326   }
 327   return nil;
 328 }
 329
 330 - (GPBFieldDescriptor *)fieldWithName:(NSString *)name {
 331   for (GPBFieldDescriptor *descriptor in fields_) {
 332     if ([descriptor.name isEqual:name]) {
 333       return descriptor;
 334     }
 335   }
 336   return nil;
 337 }
 338
 339 - (GPBOneofDescriptor *)oneofWithName:(NSString *)name {
 340   for (GPBOneofDescriptor *descriptor in oneofs_) {
 341     if ([descriptor.name isEqual:name]) {
 342       return descriptor;
 343     }
 344   }
 345   return nil;
 346 }
 347
 348 @end
 349
 350 @implementation GPBFileDescriptor {
 351   NSString *package_;
 352   NSString *objcPrefix_;
 353   GPBFileSyntax syntax_;
 354 }
 355
 356 @synthesize package = package_;
 357 @synthesize objcPrefix = objcPrefix_;
 358 @synthesize syntax = syntax_;
 359
 360 - (instancetype)initWithPackage:(NSString *)package
 361                      objcPrefix:(NSString *)objcPrefix
 362                          syntax:(GPBFileSyntax)syntax {
 363   self = [super init];
 364   if (self) {
 365     package_ = [package copy];
 366     objcPrefix_ = [objcPrefix copy];
 367     syntax_ = syntax;
 368   }
 369   return self;
 370 }
 371
 372 - (instancetype)initWithPackage:(NSString *)package
 373                          syntax:(GPBFileSyntax)syntax {
 374   self = [super init];
 375   if (self) {
 376     package_ = [package copy];
 377     syntax_ = syntax;
 378   }
 379   return self;
 380 }
 381
 382 - (void)dealloc {
 383   [package_ release];
 384   [objcPrefix_ release];
 385   [super dealloc];
 386 }
 387
 388 @end
 389
 390 @implementation GPBOneofDescriptor
 391
 392 @synthesize fields = fields_;
 393
 394 - (instancetype)initWithName:(const char *)name fields:(NSArray *)fields {
 395   self = [super init];
 396   if (self) {
 397     name_ = name;
 398     fields_ = [fields retain];
 399     for (GPBFieldDescriptor *fieldDesc in fields) {
 400       fieldDesc->containingOneof_ = self;
 401     }
 402
 403     caseSel_ = SelFromStrings(NULL, name, "OneOfCase", NO);
 404   }
 405   return self;
 406 }
 407
 408 - (void)dealloc {
 409   [fields_ release];
 410   [super dealloc];
 411 }
 412
 413 - (NSString *)name {
 414   return (NSString * _Nonnull)@(name_);
 415 }
 416
 417 - (GPBFieldDescriptor *)fieldWithNumber:(uint32_t)fieldNumber {
 418   for (GPBFieldDescriptor *descriptor in fields_) {
 419     if (GPBFieldNumber(descriptor) == fieldNumber) {
 420       return descriptor;
 421     }
 422   }
 423   return nil;
 424 }
 425
 426 - (GPBFieldDescriptor *)fieldWithName:(NSString *)name {
 427   for (GPBFieldDescriptor *descriptor in fields_) {
 428     if ([descriptor.name isEqual:name]) {
 429       return descriptor;
 430     }
 431   }
 432   return nil;
 433 }
 434
 435 @end
 436
 437 uint32_t GPBFieldTag(GPBFieldDescriptor *self) {
 438   GPBMessageFieldDescription *description = self->description_;
 439   GPBWireFormat format;
 440   if ((description->flags & GPBFieldMapKeyMask) != 0) {
 441     // Maps are repeated messages on the wire.
 442     format = GPBWireFormatForType(GPBDataTypeMessage, NO);
 443   } else {
 444     format = GPBWireFormatForType(description->dataType,
 445                                   ((description->flags & GPBFieldPacked) != 0));
 446   }
 447   return GPBWireFormatMakeTag(description->number, format);
 448 }
 449
 450 uint32_t GPBFieldAlternateTag(GPBFieldDescriptor *self) {
 451   GPBMessageFieldDescription *description = self->description_;
 452   NSCAssert((description->flags & GPBFieldRepeated) != 0,
 453             @"Only valid on repeated fields");
 454   GPBWireFormat format =
 455       GPBWireFormatForType(description->dataType,
 456                            ((description->flags & GPBFieldPacked) == 0));
 457   return GPBWireFormatMakeTag(description->number, format);
 458 }
 459
 460 @implementation GPBFieldDescriptor {
 461   GPBGenericValue defaultValue_;
 462
 463   // Message ivars
 464   Class msgClass_;
 465
 466   // Enum ivars.
 467   // If protos are generated with GenerateEnumDescriptors on then it will
 468   // be a enumDescriptor, otherwise it will be a enumVerifier.
 469   union {
 470     GPBEnumDescriptor *enumDescriptor_;
 471     GPBEnumValidationFunc enumVerifier_;
 472   } enumHandling_;
 473 }
 474
 475 @synthesize msgClass = msgClass_;
 476 @synthesize containingOneof = containingOneof_;
 477
 478 - (instancetype)init {
 479   // Throw an exception if people attempt to not use the designated initializer.
 480   self = [super init];
 481   if (self != nil) {
 482     [self doesNotRecognizeSelector:_cmd];
 483     self = nil;
 484   }
 485   return self;
 486 }
 487
 488 - (instancetype)initWithFieldDescription:(void *)description
 489                          includesDefault:(BOOL)includesDefault
 490                                   syntax:(GPBFileSyntax)syntax {
 491   if ((self = [super init])) {
 492     GPBMessageFieldDescription *coreDesc;
 493     if (includesDefault) {
 494       coreDesc = &(((GPBMessageFieldDescriptionWithDefault *)description)->core);
 495     } else {
 496       coreDesc = description;
 497     }
 498     description_ = coreDesc;
 499     getSel_ = sel_getUid(coreDesc->name);
 500     setSel_ = SelFromStrings("set", coreDesc->name, NULL, YES);
 501
 502     GPBDataType dataType = coreDesc->dataType;
 503     BOOL isMessage = GPBDataTypeIsMessage(dataType);
 504     BOOL isMapOrArray = GPBFieldIsMapOrArray(self);
 505
 506     if (isMapOrArray) {
 507       // map<>/repeated fields get a *Count property (inplace of a has*) to
 508       // support checking if there are any entries without triggering
 509       // autocreation.
 510       hasOrCountSel_ = SelFromStrings(NULL, coreDesc->name, "_Count", NO);
 511     } else {
 512       // If there is a positive hasIndex, then:
 513       //   - All fields types for proto2 messages get has* selectors.
 514       //   - Only message fields for proto3 messages get has* selectors.
 515       // Note: the positive check is to handle oneOfs, we can't check
 516       // containingOneof_ because it isn't set until after initialization.
 517       if ((coreDesc->hasIndex >= 0) &&
 518           (coreDesc->hasIndex != GPBNoHasBit) &&
 519           ((syntax != GPBFileSyntaxProto3) || isMessage)) {
 520         hasOrCountSel_ = SelFromStrings("has", coreDesc->name, NULL, NO);
 521         setHasSel_ = SelFromStrings("setHas", coreDesc->name, NULL, YES);
 522       }
 523     }
 524
 525     // Extra type specific data.
 526     if (isMessage) {
 527       const char *className = coreDesc->dataTypeSpecific.className;
 528       // Note: Only fetch the class here, can't send messages to it because
 529       // that could cause cycles back to this class within +initialize if
 530       // two messages have each other in fields (i.e. - they build a graph).
 531       msgClass_ = objc_getClass(className);
 532       NSAssert(msgClass_, @"Class %s not defined", className);
 533     } else if (dataType == GPBDataTypeEnum) {
 534       if ((coreDesc->flags & GPBFieldHasEnumDescriptor) != 0) {
 535         enumHandling_.enumDescriptor_ =
 536             coreDesc->dataTypeSpecific.enumDescFunc();
 537       } else {
 538         enumHandling_.enumVerifier_ =
 539             coreDesc->dataTypeSpecific.enumVerifier;
 540       }
 541     }
 542
 543     // Non map<>/repeated fields can have defaults in proto2 syntax.
 544     if (!isMapOrArray && includesDefault) {
 545       defaultValue_ = ((GPBMessageFieldDescriptionWithDefault *)description)->defaultValue;
 546       if (dataType == GPBDataTypeBytes) {
 547         // Data stored as a length prefixed (network byte order) c-string in
 548         // descriptor structure.
 549         const uint8_t *bytes = (const uint8_t *)defaultValue_.valueData;
 550         if (bytes) {
 551           uint32_t length;
 552           memcpy(&length, bytes, sizeof(length));
 553           length = ntohl(length);
 554           bytes += sizeof(length);
 555           defaultValue_.valueData =
 556               [[NSData alloc] initWithBytes:bytes length:length];
 557         }
 558       }
 559     }
 560   }
 561   return self;
 562 }
 563
 564 - (void)dealloc {
 565   if (description_->dataType == GPBDataTypeBytes &&
 566       !(description_->flags & GPBFieldRepeated)) {
 567     [defaultValue_.valueData release];
 568   }
 569   [super dealloc];
 570 }
 571
 572 - (GPBDataType)dataType {
 573   return description_->dataType;
 574 }
 575
 576 - (BOOL)hasDefaultValue {
 577   return (description_->flags & GPBFieldHasDefaultValue) != 0;
 578 }
 579
 580 - (uint32_t)number {
 581   return description_->number;
 582 }
 583
 584 - (NSString *)name {
 585   return (NSString * _Nonnull)@(description_->name);
 586 }
 587
 588 - (BOOL)isRequired {
 589   return (description_->flags & GPBFieldRequired) != 0;
 590 }
 591
 592 - (BOOL)isOptional {
 593   return (description_->flags & GPBFieldOptional) != 0;
 594 }
 595
 596 - (GPBFieldType)fieldType {
 597   GPBFieldFlags flags = description_->flags;
 598   if ((flags & GPBFieldRepeated) != 0) {
 599     return GPBFieldTypeRepeated;
 600   } else if ((flags & GPBFieldMapKeyMask) != 0) {
 601     return GPBFieldTypeMap;
 602   } else {
 603     return GPBFieldTypeSingle;
 604   }
 605 }
 606
 607 - (GPBDataType)mapKeyDataType {
 608   switch (description_->flags & GPBFieldMapKeyMask) {
 609     case GPBFieldMapKeyInt32:
 610       return GPBDataTypeInt32;
 611     case GPBFieldMapKeyInt64:
 612       return GPBDataTypeInt64;
 613     case GPBFieldMapKeyUInt32:
 614       return GPBDataTypeUInt32;
 615     case GPBFieldMapKeyUInt64:
 616       return GPBDataTypeUInt64;
 617     case GPBFieldMapKeySInt32:
 618       return GPBDataTypeSInt32;
 619     case GPBFieldMapKeySInt64:
 620       return GPBDataTypeSInt64;
 621     case GPBFieldMapKeyFixed32:
 622       return GPBDataTypeFixed32;
 623     case GPBFieldMapKeyFixed64:
 624       return GPBDataTypeFixed64;
 625     case GPBFieldMapKeySFixed32:
 626       return GPBDataTypeSFixed32;
 627     case GPBFieldMapKeySFixed64:
 628       return GPBDataTypeSFixed64;
 629     case GPBFieldMapKeyBool:
 630       return GPBDataTypeBool;
 631     case GPBFieldMapKeyString:
 632       return GPBDataTypeString;
 633
 634     default:
 635       NSAssert(0, @"Not a map type");
 636       return GPBDataTypeInt32;  // For lack of anything better.
 637   }
 638 }
 639
 640 - (BOOL)isPackable {
 641   return (description_->flags & GPBFieldPacked) != 0;
 642 }
 643
 644 - (BOOL)isValidEnumValue:(int32_t)value {
 645   NSAssert(description_->dataType == GPBDataTypeEnum,
 646            @"Field Must be of type GPBDataTypeEnum");
 647   if (description_->flags & GPBFieldHasEnumDescriptor) {
 648     return enumHandling_.enumDescriptor_.enumVerifier(value);
 649   } else {
 650     return enumHandling_.enumVerifier_(value);
 651   }
 652 }
 653
 654 - (GPBEnumDescriptor *)enumDescriptor {
 655   if (description_->flags & GPBFieldHasEnumDescriptor) {
 656     return enumHandling_.enumDescriptor_;
 657   } else {
 658     return nil;
 659   }
 660 }
 661
 662 - (GPBGenericValue)defaultValue {
 663   // Depends on the fact that defaultValue_ is initialized either to "0/nil" or
 664   // to an actual defaultValue in our initializer.
 665   GPBGenericValue value = defaultValue_;
 666
 667   if (!(description_->flags & GPBFieldRepeated)) {
 668     // We special handle data and strings. If they are nil, we replace them
 669     // with empty string/empty data.
 670     GPBDataType type = description_->dataType;
 671     if (type == GPBDataTypeBytes && value.valueData == nil) {
 672       value.valueData = GPBEmptyNSData();
 673     } else if (type == GPBDataTypeString && value.valueString == nil) {
 674       value.valueString = @"";
 675     }
 676   }
 677   return value;
 678 }
 679
 680 - (NSString *)textFormatName {
 681   if ((description_->flags & GPBFieldTextFormatNameCustom) != 0) {
 682     NSValue *extraInfoValue =
 683         objc_getAssociatedObject(self, &kTextFormatExtraValueKey);
 684     // Support can be left out at generation time.
 685     if (!extraInfoValue) {
 686       return nil;
 687     }
 688     const uint8_t *extraTextFormatInfo = [extraInfoValue pointerValue];
 689     return GPBDecodeTextFormatName(extraTextFormatInfo, GPBFieldNumber(self),
 690                                    self.name);
 691   }
 692
 693   // The logic here has to match SetCommonFieldVariables() from
 694   // objectivec_field.cc in the proto compiler.
 695   NSString *name = self.name;
 696   NSUInteger len = [name length];
 697
 698   // Remove the "_p" added to reserved names.
 699   if ([name hasSuffix:@"_p"]) {
 700     name = [name substringToIndex:(len - 2)];
 701     len = [name length];
 702   }
 703
 704   // Remove "Array" from the end for repeated fields.
 705   if (((description_->flags & GPBFieldRepeated) != 0) &&
 706       [name hasSuffix:@"Array"]) {
 707     name = [name substringToIndex:(len - 5)];
 708     len = [name length];
 709   }
 710
 711   // Groups vs. other fields.
 712   if (description_->dataType == GPBDataTypeGroup) {
 713     // Just capitalize the first letter.
 714     unichar firstChar = [name characterAtIndex:0];
 715     if (firstChar >= 'a' && firstChar <= 'z') {
 716       NSString *firstCharString =
 717           [NSString stringWithFormat:@"%C", (unichar)(firstChar - 'a' + 'A')];
 718       NSString *result =
 719           [name stringByReplacingCharactersInRange:NSMakeRange(0, 1)
 720                                         withString:firstCharString];
 721       return result;
 722     }
 723     return name;
 724
 725   } else {
 726     // Undo the CamelCase.
 727     NSMutableString *result = [NSMutableString stringWithCapacity:len];
 728     for (uint32_t i = 0; i < len; i++) {
 729       unichar c = [name characterAtIndex:i];
 730       if (c >= 'A' && c <= 'Z') {
 731         if (i > 0) {
 732           [result appendFormat:@"_%C", (unichar)(c - 'A' + 'a')];
 733         } else {
 734           [result appendFormat:@"%C", c];
 735         }
 736       } else {
 737         [result appendFormat:@"%C", c];
 738       }
 739     }
 740     return result;
 741   }
 742 }
 743
 744 @end
 745
 746 @implementation GPBEnumDescriptor {
 747   NSString *name_;
 748   // valueNames_ is a single c string with all of the value names appended
 749   // together, each null terminated.  -calcValueNameOffsets fills in
 750   // nameOffsets_ with the offsets to allow quicker access to the individual
 751   // names.
 752   const char *valueNames_;
 753   const int32_t *values_;
 754   GPBEnumValidationFunc enumVerifier_;
 755   const uint8_t *extraTextFormatInfo_;
 756   uint32_t *nameOffsets_;
 757   uint32_t valueCount_;
 758 }
 759
 760 @synthesize name = name_;
 761 @synthesize enumVerifier = enumVerifier_;
 762
 763 + (instancetype)
 764     allocDescriptorForName:(NSString *)name
 765                 valueNames:(const char *)valueNames
 766                     values:(const int32_t *)values
 767                      count:(uint32_t)valueCount
 768               enumVerifier:(GPBEnumValidationFunc)enumVerifier {
 769   GPBEnumDescriptor *descriptor = [[self alloc] initWithName:name
 770                                                   valueNames:valueNames
 771                                                       values:values
 772                                                        count:valueCount
 773                                                 enumVerifier:enumVerifier];
 774   return descriptor;
 775 }
 776
 777 + (instancetype)
 778     allocDescriptorForName:(NSString *)name
 779                 valueNames:(const char *)valueNames
 780                     values:(const int32_t *)values
 781                      count:(uint32_t)valueCount
 782               enumVerifier:(GPBEnumValidationFunc)enumVerifier
 783        extraTextFormatInfo:(const char *)extraTextFormatInfo {
 784   // Call the common case.
 785   GPBEnumDescriptor *descriptor = [self allocDescriptorForName:name
 786                                                     valueNames:valueNames
 787                                                         values:values
 788                                                          count:valueCount
 789                                                   enumVerifier:enumVerifier];
 790   // Set the extra info.
 791   descriptor->extraTextFormatInfo_ = (const uint8_t *)extraTextFormatInfo;
 792   return descriptor;
 793 }
 794
 795 - (instancetype)initWithName:(NSString *)name
 796                   valueNames:(const char *)valueNames
 797                       values:(const int32_t *)values
 798                        count:(uint32_t)valueCount
 799                 enumVerifier:(GPBEnumValidationFunc)enumVerifier {
 800   if ((self = [super init])) {
 801     name_ = [name copy];
 802     valueNames_ = valueNames;
 803     values_ = values;
 804     valueCount_ = valueCount;
 805     enumVerifier_ = enumVerifier;
 806   }
 807   return self;
 808 }
 809
 810 - (void)dealloc {
 811   [name_ release];
 812   if (nameOffsets_) free(nameOffsets_);
 813   [super dealloc];
 814 }
 815
 816 - (void)calcValueNameOffsets {
 817   @synchronized(self) {
 818     if (nameOffsets_ != NULL) {
 819       return;
 820     }
 821     uint32_t *offsets = malloc(valueCount_ * sizeof(uint32_t));
 822     const char *scan = valueNames_;
 823     for (uint32_t i = 0; i < valueCount_; ++i) {
 824       offsets[i] = (uint32_t)(scan - valueNames_);
 825       while (*scan != '\0') ++scan;
 826       ++scan;  // Step over the null.
 827     }
 828     nameOffsets_ = offsets;
 829   }
 830 }
 831
 832 - (NSString *)enumNameForValue:(int32_t)number {
 833   if (nameOffsets_ == NULL) [self calcValueNameOffsets];
 834
 835   for (uint32_t i = 0; i < valueCount_; ++i) {
 836     if (values_[i] == number) {
 837       const char *valueName = valueNames_ + nameOffsets_[i];
 838       NSString *fullName = [NSString stringWithFormat:@"%@_%s", name_, valueName];
 839       return fullName;
 840     }
 841   }
 842   return nil;
 843 }
 844
 845 - (BOOL)getValue:(int32_t *)outValue forEnumName:(NSString *)name {
 846   // Must have the prefix.
 847   NSUInteger prefixLen = name_.length + 1;
 848   if ((name.length <= prefixLen) || ![name hasPrefix:name_] ||
 849       ([name characterAtIndex:prefixLen - 1] != '_')) {
 850     return NO;
 851   }
 852
 853   // Skip over the prefix.
 854   const char *nameAsCStr = [name UTF8String];
 855   nameAsCStr += prefixLen;
 856
 857   if (nameOffsets_ == NULL) [self calcValueNameOffsets];
 858
 859   // Find it.
 860   for (uint32_t i = 0; i < valueCount_; ++i) {
 861     const char *valueName = valueNames_ + nameOffsets_[i];
 862     if (strcmp(nameAsCStr, valueName) == 0) {
 863       if (outValue) {
 864         *outValue = values_[i];
 865       }
 866       return YES;
 867     }
 868   }
 869   return NO;
 870 }
 871
 872 - (BOOL)getValue:(int32_t *)outValue forEnumTextFormatName:(NSString *)textFormatName {
 873     if (nameOffsets_ == NULL) [self calcValueNameOffsets];
 874
 875     for (uint32_t i = 0; i < valueCount_; ++i) {
 876         int32_t value = values_[i];
 877         NSString *valueTextFormatName = [self textFormatNameForValue:value];
 878         if ([valueTextFormatName isEqual:textFormatName]) {
 879             if (outValue) {
 880                 *outValue = value;
 881             }
 882             return YES;
 883         }
 884     }
 885     return NO;
 886 }
 887
 888 - (NSString *)textFormatNameForValue:(int32_t)number {
 889   if (nameOffsets_ == NULL) [self calcValueNameOffsets];
 890
 891   // Find the EnumValue descriptor and its index.
 892   BOOL foundIt = NO;
 893   uint32_t valueDescriptorIndex;
 894   for (valueDescriptorIndex = 0; valueDescriptorIndex < valueCount_;
 895        ++valueDescriptorIndex) {
 896     if (values_[valueDescriptorIndex] == number) {
 897       foundIt = YES;
 898       break;
 899     }
 900   }
 901
 902   if (!foundIt) {
 903     return nil;
 904   }
 905
 906   NSString *result = nil;
 907   // Naming adds an underscore between enum name and value name, skip that also.
 908   const char *valueName = valueNames_ + nameOffsets_[valueDescriptorIndex];
 909   NSString *shortName = @(valueName);
 910
 911   // See if it is in the map of special format handling.
 912   if (extraTextFormatInfo_) {
 913     result = GPBDecodeTextFormatName(extraTextFormatInfo_,
 914                                      (int32_t)valueDescriptorIndex, shortName);
 915   }
 916   // Logic here needs to match what objectivec_enum.cc does in the proto
 917   // compiler.
 918   if (result == nil) {
 919     NSUInteger len = [shortName length];
 920     NSMutableString *worker = [NSMutableString stringWithCapacity:len];
 921     for (NSUInteger i = 0; i < len; i++) {
 922       unichar c = [shortName characterAtIndex:i];
 923       if (i > 0 && c >= 'A' && c <= 'Z') {
 924         [worker appendString:@"_"];
 925       }
 926       [worker appendFormat:@"%c", toupper((char)c)];
 927     }
 928     result = worker;
 929   }
 930   return result;
 931 }
 932
 933 @end
 934
 935 @implementation GPBExtensionDescriptor {
 936   GPBGenericValue defaultValue_;
 937 }
 938
 939 @synthesize containingMessageClass = containingMessageClass_;
 940
 941 - (instancetype)initWithExtensionDescription:
 942         (GPBExtensionDescription *)description {
 943   if ((self = [super init])) {
 944     description_ = description;
 945
 946 #if defined(DEBUG) && DEBUG
 947     const char *className = description->messageOrGroupClassName;
 948     if (className) {
 949       NSAssert(objc_lookUpClass(className) != Nil,
 950                @"Class %s not defined", className);
 951     }
 952 #endif
 953
 954     if (description->extendedClass) {
 955       Class containingClass = objc_lookUpClass(description->extendedClass);
 956       NSAssert(containingClass, @"Class %s not defined",
 957                description->extendedClass);
 958       containingMessageClass_ = containingClass;
 959     }
 960
 961     GPBDataType type = description_->dataType;
 962     if (type == GPBDataTypeBytes) {
 963       // Data stored as a length prefixed c-string in descriptor records.
 964       const uint8_t *bytes =
 965           (const uint8_t *)description->defaultValue.valueData;
 966       if (bytes) {
 967         uint32_t length;
 968         memcpy(&length, bytes, sizeof(length));
 969         // The length is stored in network byte order.
 970         length = ntohl(length);
 971         bytes += sizeof(length);
 972         defaultValue_.valueData =
 973             [[NSData alloc] initWithBytes:bytes length:length];
 974       }
 975     } else if (type == GPBDataTypeMessage || type == GPBDataTypeGroup) {
 976       // The default is looked up in -defaultValue instead since extensions
 977       // aren't common, we avoid the hit startup hit and it avoid initialization
 978       // order issues.
 979     } else {
 980       defaultValue_ = description->defaultValue;
 981     }
 982   }
 983   return self;
 984 }
 985
 986 - (void)dealloc {
 987   if ((description_->dataType == GPBDataTypeBytes) &&
 988       !GPBExtensionIsRepeated(description_)) {
 989     [defaultValue_.valueData release];
 990   }
 991   [super dealloc];
 992 }
 993
 994 - (instancetype)copyWithZone:(NSZone *)zone {
 995 #pragma unused(zone)
 996   // Immutable.
 997   return [self retain];
 998 }
 999
1000 - (NSString *)singletonName {
1001   return (NSString * _Nonnull)@(description_->singletonName);
1002 }
1003
1004 - (const char *)singletonNameC {
1005   return description_->singletonName;
1006 }
1007
1008 - (uint32_t)fieldNumber {
1009   return description_->fieldNumber;
1010 }
1011
1012 - (GPBDataType)dataType {
1013   return description_->dataType;
1014 }
1015
1016 - (GPBWireFormat)wireType {
1017   return GPBWireFormatForType(description_->dataType,
1018                               GPBExtensionIsPacked(description_));
1019 }
1020
1021 - (GPBWireFormat)alternateWireType {
1022   NSAssert(GPBExtensionIsRepeated(description_),
1023            @"Only valid on repeated extensions");
1024   return GPBWireFormatForType(description_->dataType,
1025                               !GPBExtensionIsPacked(description_));
1026 }
1027
1028 - (BOOL)isRepeated {
1029   return GPBExtensionIsRepeated(description_);
1030 }
1031
1032 - (BOOL)isPackable {
1033   return GPBExtensionIsPacked(description_);
1034 }
1035
1036 - (Class)msgClass {
1037   return objc_getClass(description_->messageOrGroupClassName);
1038 }
1039
1040 - (GPBEnumDescriptor *)enumDescriptor {
1041   if (description_->dataType == GPBDataTypeEnum) {
1042     GPBEnumDescriptor *enumDescriptor = description_->enumDescriptorFunc();
1043     return enumDescriptor;
1044   }
1045   return nil;
1046 }
1047
1048 - (id)defaultValue {
1049   if (GPBExtensionIsRepeated(description_)) {
1050     return nil;
1051   }
1052
1053   switch (description_->dataType) {
1054     case GPBDataTypeBool:
1055       return @(defaultValue_.valueBool);
1056     case GPBDataTypeFloat:
1057       return @(defaultValue_.valueFloat);
1058     case GPBDataTypeDouble:
1059       return @(defaultValue_.valueDouble);
1060     case GPBDataTypeInt32:
1061     case GPBDataTypeSInt32:
1062     case GPBDataTypeEnum:
1063     case GPBDataTypeSFixed32:
1064       return @(defaultValue_.valueInt32);
1065     case GPBDataTypeInt64:
1066     case GPBDataTypeSInt64:
1067     case GPBDataTypeSFixed64:
1068       return @(defaultValue_.valueInt64);
1069     case GPBDataTypeUInt32:
1070     case GPBDataTypeFixed32:
1071       return @(defaultValue_.valueUInt32);
1072     case GPBDataTypeUInt64:
1073     case GPBDataTypeFixed64:
1074       return @(defaultValue_.valueUInt64);
1075     case GPBDataTypeBytes:
1076       // Like message fields, the default is zero length data.
1077       return (defaultValue_.valueData ? defaultValue_.valueData
1078                                       : GPBEmptyNSData());
1079     case GPBDataTypeString:
1080       // Like message fields, the default is zero length string.
1081       return (defaultValue_.valueString ? defaultValue_.valueString : @"");
1082     case GPBDataTypeGroup:
1083     case GPBDataTypeMessage:
1084       return nil;
1085   }
1086 }
1087
1088 - (NSComparisonResult)compareByFieldNumber:(GPBExtensionDescriptor *)other {
1089   int32_t selfNumber = description_->fieldNumber;
1090   int32_t otherNumber = other->description_->fieldNumber;
1091   if (selfNumber < otherNumber) {
1092     return NSOrderedAscending;
1093   } else if (selfNumber == otherNumber) {
1094     return NSOrderedSame;
1095   } else {
1096     return NSOrderedDescending;
1097   }
1098 }
1099
1100 @end
1101
1102 #pragma clang diagnostic pop