Method parseZoneFile

c++/src/Timezone.cc:869–946

* Parse the zone file to get the bits we need. * There are two versions of the timezone file: * * Version 1(version = 0x00): * Magic(version) * Header * TransitionTimes(4 byte) * TransitionRules * Rules * LeapSeconds(4 byte) * IsStd * IsGmt * * Version2: * Version1(0x32) = a version 1 copy of the data for old clients * Magic(0x32)

   *   FutureString
   */
  void TimezoneImpl::parseZoneFile(const unsigned char* ptr, uint64_t sectionOffset,
                                   uint64_t fileLength, const VersionParser& versionParser) {
    const uint64_t magicOffset = sectionOffset + 0;
    const uint64_t headerOffset = magicOffset + 20;

    // check for validity before we start parsing
    if (fileLength < headerOffset + 6 * 4 ||
        strncmp(reinterpret_cast<const char*>(ptr) + magicOffset, "TZif", 4) != 0) {
      std::stringstream buffer;
      buffer << "non-tzfile " << filename_;
      throw TimezoneError(buffer.str());
    }

    const uint64_t isGmtCount = decode32(ptr + headerOffset + 0);
    const uint64_t isStdCount = decode32(ptr + headerOffset + 4);
    const uint64_t leapCount = decode32(ptr + headerOffset + 8);
    const uint64_t timeCount = decode32(ptr + headerOffset + 12);
    const uint64_t variantCount = decode32(ptr + headerOffset + 16);
    const uint64_t nameCount = decode32(ptr + headerOffset + 20);

    const uint64_t timeOffset = headerOffset + 24;
    const uint64_t timeVariantOffset = timeOffset + versionParser.getTimeSize() * timeCount;
    const uint64_t variantOffset = timeVariantOffset + timeCount;
    const uint64_t nameOffset = variantOffset + variantCount * 6;
    const uint64_t sectionLength = nameOffset + nameCount +
                                   (versionParser.getTimeSize() + 4) * leapCount + isGmtCount +
                                   isStdCount;

    if (sectionLength > fileLength) {
      std::stringstream buffer;
      buffer << "tzfile too short " << filename_ << " needs " << sectionLength << " and has "
             << fileLength;
      throw TimezoneError(buffer.str());
    }

    // if it is version 2, skip over the old layout and read the new one.
    if (sectionOffset == 0 && ptr[magicOffset + 4] != 0) {
      parseZoneFile(ptr, sectionLength, fileLength, Version2Parser());
      return;
    }
    version_ = versionParser.getVersion();
    variants_.resize(variantCount);
    transitions_.resize(timeCount);
    currentVariant_.resize(timeCount);
    parseTimeVariants(ptr, variantOffset, variantCount, nameOffset, nameCount);
    bool foundAncient = false;
    for (uint64_t t = 0; t < timeCount; ++t) {
      transitions_[t] = versionParser.parseTime(ptr + timeOffset + t * versionParser.getTimeSize());
      currentVariant_[t] = ptr[timeVariantOffset + t];
      if (currentVariant_[t] >= variantCount) {
        std::stringstream buffer;
        buffer << "tzfile rule out of range " << filename_ << " references rule "
               << currentVariant_[t] << " of " << variantCount;
        throw TimezoneError(buffer.str());
      }
      // find the oldest standard time and use that as the ancient value
      if (!foundAncient && !variants_[currentVariant_[t]].isDst) {
        foundAncient = true;