libs/androidfw/ResourceTypes.cpp

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_TAG "ResourceType"
  18 //#define LOG_NDEBUG 0
  19
  20 #include <androidfw/ByteBucketArray.h>
  21 #include <androidfw/ResourceTypes.h>
  22 #include <androidfw/TypeWrappers.h>
  23 #include <utils/Atomic.h>
  24 #include <utils/ByteOrder.h>
  25 #include <utils/Debug.h>
  26 #include <utils/Log.h>
  27 #include <utils/String16.h>
  28 #include <utils/String8.h>
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <memory.h>
  33 #include <ctype.h>
  34 #include <stdint.h>
  35 #include <stddef.h>
  36
  37 #ifndef INT32_MAX
  38 #define INT32_MAX ((int32_t)(2147483647))
  39 #endif
  40
  41 #define STRING_POOL_NOISY(x) //x
  42 #define XML_NOISY(x) //x
  43 #define TABLE_NOISY(x) //x
  44 #define TABLE_GETENTRY(x) //x
  45 #define TABLE_SUPER_NOISY(x) //x
  46 #define LOAD_TABLE_NOISY(x) //x
  47 #define TABLE_THEME(x) //x
  48 #define LIB_NOISY(x) //x
  49
  50 namespace android {
  51
  52 #ifdef HAVE_WINSOCK
  53 #undef  nhtol
  54 #undef  htonl
  55
  56 #ifdef HAVE_LITTLE_ENDIAN
  57 #define ntohl(x)    ( ((x) << 24) | (((x) >> 24) & 255) | (((x) << 8) & 0xff0000) | (((x) >> 8) & 0xff00) )
  58 #define htonl(x)    ntohl(x)
  59 #define ntohs(x)    ( (((x) << 8) & 0xff00) | (((x) >> 8) & 255) )
  60 #define htons(x)    ntohs(x)
  61 #else
  62 #define ntohl(x)    (x)
  63 #define htonl(x)    (x)
  64 #define ntohs(x)    (x)
  65 #define htons(x)    (x)
  66 #endif
  67 #endif
  68
  69 #define IDMAP_MAGIC             0x504D4449
  70 #define IDMAP_CURRENT_VERSION   0x00000001
  71
  72 #define APP_PACKAGE_ID      0x7f
  73 #define SYS_PACKAGE_ID      0x01
  74
  75 // Standard C isspace() is only required to look at the low byte of its input, so
  76 // produces incorrect results for UTF-16 characters.  For safety's sake, assume that
  77 // any high-byte UTF-16 code point is not whitespace.
  78 inline int isspace16(char16_t c) {
  79     return (c < 0x0080 && isspace(c));
  80 }
  81
  82 template<typename T>
  83 inline static T max(T a, T b) {
  84     return a > b ? a : b;
  85 }
  86
  87 // range checked; guaranteed to NUL-terminate within the stated number of available slots
  88 // NOTE: if this truncates the dst string due to running out of space, no attempt is
  89 // made to avoid splitting surrogate pairs.
  90 static void strcpy16_dtoh(char16_t* dst, const uint16_t* src, size_t avail)
  91 {
  92     char16_t* last = dst + avail - 1;
  93     while (*src && (dst < last)) {
  94         char16_t s = dtohs(static_cast<char16_t>(*src));
  95         *dst++ = s;
  96         src++;
  97     }
  98     *dst = 0;
  99 }
 100
 101 static status_t validate_chunk(const ResChunk_header* chunk,
 102                                size_t minSize,
 103                                const uint8_t* dataEnd,
 104                                const char* name)
 105 {
 106     const uint16_t headerSize = dtohs(chunk->headerSize);
 107     const uint32_t size = dtohl(chunk->size);
 108
 109     if (headerSize >= minSize) {
 110         if (headerSize <= size) {
 111             if (((headerSize|size)&0x3) == 0) {
 112                 if ((size_t)size <= (size_t)(dataEnd-((const uint8_t*)chunk))) {
 113                     return NO_ERROR;
 114                 }
 115                 ALOGW("%s data size 0x%x extends beyond resource end %p.",
 116                      name, size, (void*)(dataEnd-((const uint8_t*)chunk)));
 117                 return BAD_TYPE;
 118             }
 119             ALOGW("%s size 0x%x or headerSize 0x%x is not on an integer boundary.",
 120                  name, (int)size, (int)headerSize);
 121             return BAD_TYPE;
 122         }
 123         ALOGW("%s size 0x%x is smaller than header size 0x%x.",
 124              name, size, headerSize);
 125         return BAD_TYPE;
 126     }
 127     ALOGW("%s header size 0x%04x is too small.",
 128          name, headerSize);
 129     return BAD_TYPE;
 130 }
 131
 132 static void fill9patchOffsets(Res_png_9patch* patch) {
 133     patch->xDivsOffset = sizeof(Res_png_9patch);
 134     patch->yDivsOffset = patch->xDivsOffset + (patch->numXDivs * sizeof(int32_t));
 135     patch->colorsOffset = patch->yDivsOffset + (patch->numYDivs * sizeof(int32_t));
 136 }
 137
 138 inline void Res_value::copyFrom_dtoh(const Res_value& src)
 139 {
 140     size = dtohs(src.size);
 141     res0 = src.res0;
 142     dataType = src.dataType;
 143     data = dtohl(src.data);
 144 }
 145
 146 void Res_png_9patch::deviceToFile()
 147 {
 148     int32_t* xDivs = getXDivs();
 149     for (int i = 0; i < numXDivs; i++) {
 150         xDivs[i] = htonl(xDivs[i]);
 151     }
 152     int32_t* yDivs = getYDivs();
 153     for (int i = 0; i < numYDivs; i++) {
 154         yDivs[i] = htonl(yDivs[i]);
 155     }
 156     paddingLeft = htonl(paddingLeft);
 157     paddingRight = htonl(paddingRight);
 158     paddingTop = htonl(paddingTop);
 159     paddingBottom = htonl(paddingBottom);
 160     uint32_t* colors = getColors();
 161     for (int i=0; i<numColors; i++) {
 162         colors[i] = htonl(colors[i]);
 163     }
 164 }
 165
 166 void Res_png_9patch::fileToDevice()
 167 {
 168     int32_t* xDivs = getXDivs();
 169     for (int i = 0; i < numXDivs; i++) {
 170         xDivs[i] = ntohl(xDivs[i]);
 171     }
 172     int32_t* yDivs = getYDivs();
 173     for (int i = 0; i < numYDivs; i++) {
 174         yDivs[i] = ntohl(yDivs[i]);
 175     }
 176     paddingLeft = ntohl(paddingLeft);
 177     paddingRight = ntohl(paddingRight);
 178     paddingTop = ntohl(paddingTop);
 179     paddingBottom = ntohl(paddingBottom);
 180     uint32_t* colors = getColors();
 181     for (int i=0; i<numColors; i++) {
 182         colors[i] = ntohl(colors[i]);
 183     }
 184 }
 185
 186 size_t Res_png_9patch::serializedSize() const
 187 {
 188     // The size of this struct is 32 bytes on the 32-bit target system
 189     // 4 * int8_t
 190     // 4 * int32_t
 191     // 3 * uint32_t
 192     return 32
 193             + numXDivs * sizeof(int32_t)
 194             + numYDivs * sizeof(int32_t)
 195             + numColors * sizeof(uint32_t);
 196 }
 197
 198 void* Res_png_9patch::serialize(const Res_png_9patch& patch, const int32_t* xDivs,
 199                                 const int32_t* yDivs, const uint32_t* colors)
 200 {
 201     // Use calloc since we're going to leave a few holes in the data
 202     // and want this to run cleanly under valgrind
 203     void* newData = calloc(1, patch.serializedSize());
 204     serialize(patch, xDivs, yDivs, colors, newData);
 205     return newData;
 206 }
 207
 208 void Res_png_9patch::serialize(const Res_png_9patch& patch, const int32_t* xDivs,
 209                                const int32_t* yDivs, const uint32_t* colors, void* outData)
 210 {
 211     uint8_t* data = (uint8_t*) outData;
 212     memcpy(data, &patch.wasDeserialized, 4);     // copy  wasDeserialized, numXDivs, numYDivs, numColors
 213     memcpy(data + 12, &patch.paddingLeft, 16);   // copy paddingXXXX
 214     data += 32;
 215
 216     memcpy(data, xDivs, patch.numXDivs * sizeof(int32_t));
 217     data +=  patch.numXDivs * sizeof(int32_t);
 218     memcpy(data, yDivs, patch.numYDivs * sizeof(int32_t));
 219     data +=  patch.numYDivs * sizeof(int32_t);
 220     memcpy(data, colors, patch.numColors * sizeof(uint32_t));
 221
 222     fill9patchOffsets(reinterpret_cast<Res_png_9patch*>(outData));
 223 }
 224
 225 static bool assertIdmapHeader(const void* idmap, size_t size) {
 226     if (reinterpret_cast<uintptr_t>(idmap) & 0x03) {
 227         ALOGE("idmap: header is not word aligned");
 228         return false;
 229     }
 230
 231     if (size < ResTable::IDMAP_HEADER_SIZE_BYTES) {
 232         ALOGW("idmap: header too small (%d bytes)", (uint32_t) size);
 233         return false;
 234     }
 235
 236     const uint32_t magic = htodl(*reinterpret_cast<const uint32_t*>(idmap));
 237     if (magic != IDMAP_MAGIC) {
 238         ALOGW("idmap: no magic found in header (is 0x%08x, expected 0x%08x)",
 239              magic, IDMAP_MAGIC);
 240         return false;
 241     }
 242
 243     const uint32_t version = htodl(*(reinterpret_cast<const uint32_t*>(idmap) + 1));
 244     if (version != IDMAP_CURRENT_VERSION) {
 245         // We are strict about versions because files with this format are
 246         // auto-generated and don't need backwards compatibility.
 247         ALOGW("idmap: version mismatch in header (is 0x%08x, expected 0x%08x)",
 248                 version, IDMAP_CURRENT_VERSION);
 249         return false;
 250     }
 251     return true;
 252 }
 253
 254 class IdmapEntries {
 255 public:
 256     IdmapEntries() : mData(NULL) {}
 257
 258     bool hasEntries() const {
 259         if (mData == NULL) {
 260             return false;
 261         }
 262
 263         return (dtohs(*mData) > 0);
 264     }
 265
 266     size_t byteSize() const {
 267         if (mData == NULL) {
 268             return 0;
 269         }
 270         uint16_t entryCount = dtohs(mData[2]);
 271         return (sizeof(uint16_t) * 4) + (sizeof(uint32_t) * static_cast<size_t>(entryCount));
 272     }
 273
 274     uint8_t targetTypeId() const {
 275         if (mData == NULL) {
 276             return 0;
 277         }
 278         return dtohs(mData[0]);
 279     }
 280
 281     uint8_t overlayTypeId() const {
 282         if (mData == NULL) {
 283             return 0;
 284         }
 285         return dtohs(mData[1]);
 286     }
 287
 288     status_t setTo(const void* entryHeader, size_t size) {
 289         if (reinterpret_cast<uintptr_t>(entryHeader) & 0x03) {
 290             ALOGE("idmap: entry header is not word aligned");
 291             return UNKNOWN_ERROR;
 292         }
 293
 294         if (size < sizeof(uint16_t) * 4) {
 295             ALOGE("idmap: entry header is too small (%u bytes)", (uint32_t) size);
 296             return UNKNOWN_ERROR;
 297         }
 298
 299         const uint16_t* header = reinterpret_cast<const uint16_t*>(entryHeader);
 300         const uint16_t targetTypeId = dtohs(header[0]);
 301         const uint16_t overlayTypeId = dtohs(header[1]);
 302         if (targetTypeId == 0 || overlayTypeId == 0 || targetTypeId > 255 || overlayTypeId > 255) {
 303             ALOGE("idmap: invalid type map (%u -> %u)", targetTypeId, overlayTypeId);
 304             return UNKNOWN_ERROR;
 305         }
 306
 307         uint16_t entryCount = dtohs(header[2]);
 308         if (size < sizeof(uint32_t) * (entryCount + 2)) {
 309             ALOGE("idmap: too small (%u bytes) for the number of entries (%u)",
 310                     (uint32_t) size, (uint32_t) entryCount);
 311             return UNKNOWN_ERROR;
 312         }
 313         mData = header;
 314         return NO_ERROR;
 315     }
 316
 317     status_t lookup(uint16_t entryId, uint16_t* outEntryId) const {
 318         uint16_t entryCount = dtohs(mData[2]);
 319         uint16_t offset = dtohs(mData[3]);
 320
 321         if (entryId < offset) {
 322             // The entry is not present in this idmap
 323             return BAD_INDEX;
 324         }
 325
 326         entryId -= offset;
 327
 328         if (entryId >= entryCount) {
 329             // The entry is not present in this idmap
 330             return BAD_INDEX;
 331         }
 332
 333         // It is safe to access the type here without checking the size because
 334         // we have checked this when it was first loaded.
 335         const uint32_t* entries = reinterpret_cast<const uint32_t*>(mData) + 2;
 336         uint32_t mappedEntry = dtohl(entries[entryId]);
 337         if (mappedEntry == 0xffffffff) {
 338             // This entry is not present in this idmap
 339             return BAD_INDEX;
 340         }
 341         *outEntryId = static_cast<uint16_t>(mappedEntry);
 342         return NO_ERROR;
 343     }
 344
 345 private:
 346     const uint16_t* mData;
 347 };
 348
 349 status_t parseIdmap(const void* idmap, size_t size, uint8_t* outPackageId, KeyedVector<uint8_t, IdmapEntries>* outMap) {
 350     if (!assertIdmapHeader(idmap, size)) {
 351         return UNKNOWN_ERROR;
 352     }
 353
 354     size -= ResTable::IDMAP_HEADER_SIZE_BYTES;
 355     if (size < sizeof(uint16_t) * 2) {
 356         ALOGE("idmap: too small to contain any mapping");
 357         return UNKNOWN_ERROR;
 358     }
 359
 360     const uint16_t* data = reinterpret_cast<const uint16_t*>(
 361             reinterpret_cast<const uint8_t*>(idmap) + ResTable::IDMAP_HEADER_SIZE_BYTES);
 362
 363     uint16_t targetPackageId = dtohs(*(data++));
 364     if (targetPackageId == 0 || targetPackageId > 255) {
 365         ALOGE("idmap: target package ID is invalid (%02x)", targetPackageId);
 366         return UNKNOWN_ERROR;
 367     }
 368
 369     uint16_t mapCount = dtohs(*(data++));
 370     if (mapCount == 0) {
 371         ALOGE("idmap: no mappings");
 372         return UNKNOWN_ERROR;
 373     }
 374
 375     if (mapCount > 255) {
 376         ALOGW("idmap: too many mappings. Only 255 are possible but %u are present", (uint32_t) mapCount);
 377     }
 378
 379     while (size > sizeof(uint16_t) * 4) {
 380         IdmapEntries entries;
 381         status_t err = entries.setTo(data, size);
 382         if (err != NO_ERROR) {
 383             return err;
 384         }
 385
 386         ssize_t index = outMap->add(entries.overlayTypeId(), entries);
 387         if (index < 0) {
 388             return NO_MEMORY;
 389         }
 390
 391         data += entries.byteSize() / sizeof(uint16_t);
 392         size -= entries.byteSize();
 393     }
 394
 395     if (outPackageId != NULL) {
 396         *outPackageId = static_cast<uint8_t>(targetPackageId);
 397     }
 398     return NO_ERROR;
 399 }
 400
 401 Res_png_9patch* Res_png_9patch::deserialize(void* inData)
 402 {
 403
 404     Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(inData);
 405     patch->wasDeserialized = true;
 406     fill9patchOffsets(patch);
 407
 408     return patch;
 409 }
 410
 411 // --------------------------------------------------------------------
 412 // --------------------------------------------------------------------
 413 // --------------------------------------------------------------------
 414
 415 ResStringPool::ResStringPool()
 416     : mError(NO_INIT), mOwnedData(NULL), mHeader(NULL), mCache(NULL)
 417 {
 418 }
 419
 420 ResStringPool::ResStringPool(const void* data, size_t size, bool copyData)
 421     : mError(NO_INIT), mOwnedData(NULL), mHeader(NULL), mCache(NULL)
 422 {
 423     setTo(data, size, copyData);
 424 }
 425
 426 ResStringPool::~ResStringPool()
 427 {
 428     uninit();
 429 }
 430
 431 void ResStringPool::setToEmpty()
 432 {
 433     uninit();
 434
 435     mOwnedData = calloc(1, sizeof(ResStringPool_header));
 436     ResStringPool_header* header = (ResStringPool_header*) mOwnedData;
 437     mSize = 0;
 438     mEntries = NULL;
 439     mStrings = NULL;
 440     mStringPoolSize = 0;
 441     mEntryStyles = NULL;
 442     mStyles = NULL;
 443     mStylePoolSize = 0;
 444     mHeader = (const ResStringPool_header*) header;
 445 }
 446
 447 status_t ResStringPool::setTo(const void* data, size_t size, bool copyData)
 448 {
 449     if (!data || !size) {
 450         return (mError=BAD_TYPE);
 451     }
 452
 453     uninit();
 454
 455     const bool notDeviceEndian = htods(0xf0) != 0xf0;
 456
 457     if (copyData || notDeviceEndian) {
 458         mOwnedData = malloc(size);
 459         if (mOwnedData == NULL) {
 460             return (mError=NO_MEMORY);
 461         }
 462         memcpy(mOwnedData, data, size);
 463         data = mOwnedData;
 464     }
 465
 466     mHeader = (const ResStringPool_header*)data;
 467
 468     if (notDeviceEndian) {
 469         ResStringPool_header* h = const_cast<ResStringPool_header*>(mHeader);
 470         h->header.headerSize = dtohs(mHeader->header.headerSize);
 471         h->header.type = dtohs(mHeader->header.type);
 472         h->header.size = dtohl(mHeader->header.size);
 473         h->stringCount = dtohl(mHeader->stringCount);
 474         h->styleCount = dtohl(mHeader->styleCount);
 475         h->flags = dtohl(mHeader->flags);
 476         h->stringsStart = dtohl(mHeader->stringsStart);
 477         h->stylesStart = dtohl(mHeader->stylesStart);
 478     }
 479
 480     if (mHeader->header.headerSize > mHeader->header.size
 481             || mHeader->header.size > size) {
 482         ALOGW("Bad string block: header size %d or total size %d is larger than data size %d\n",
 483                 (int)mHeader->header.headerSize, (int)mHeader->header.size, (int)size);
 484         return (mError=BAD_TYPE);
 485     }
 486     mSize = mHeader->header.size;
 487     mEntries = (const uint32_t*)
 488         (((const uint8_t*)data)+mHeader->header.headerSize);
 489
 490     if (mHeader->stringCount > 0) {
 491         if ((mHeader->stringCount*sizeof(uint32_t) < mHeader->stringCount)  // uint32 overflow?
 492             || (mHeader->header.headerSize+(mHeader->stringCount*sizeof(uint32_t)))
 493                 > size) {
 494             ALOGW("Bad string block: entry of %d items extends past data size %d\n",
 495                     (int)(mHeader->header.headerSize+(mHeader->stringCount*sizeof(uint32_t))),
 496                     (int)size);
 497             return (mError=BAD_TYPE);
 498         }
 499
 500         size_t charSize;
 501         if (mHeader->flags&ResStringPool_header::UTF8_FLAG) {
 502             charSize = sizeof(uint8_t);
 503         } else {
 504             charSize = sizeof(uint16_t);
 505         }
 506
 507         // There should be at least space for the smallest string
 508         // (2 bytes length, null terminator).
 509         if (mHeader->stringsStart >= (mSize - sizeof(uint16_t))) {
 510             ALOGW("Bad string block: string pool starts at %d, after total size %d\n",
 511                     (int)mHeader->stringsStart, (int)mHeader->header.size);
 512             return (mError=BAD_TYPE);
 513         }
 514
 515         mStrings = (const void*)
 516             (((const uint8_t*)data) + mHeader->stringsStart);
 517
 518         if (mHeader->styleCount == 0) {
 519             mStringPoolSize = (mSize - mHeader->stringsStart) / charSize;
 520         } else {
 521             // check invariant: styles starts before end of data
 522             if (mHeader->stylesStart >= (mSize - sizeof(uint16_t))) {
 523                 ALOGW("Bad style block: style block starts at %d past data size of %d\n",
 524                     (int)mHeader->stylesStart, (int)mHeader->header.size);
 525                 return (mError=BAD_TYPE);
 526             }
 527             // check invariant: styles follow the strings
 528             if (mHeader->stylesStart <= mHeader->stringsStart) {
 529                 ALOGW("Bad style block: style block starts at %d, before strings at %d\n",
 530                     (int)mHeader->stylesStart, (int)mHeader->stringsStart);
 531                 return (mError=BAD_TYPE);
 532             }
 533             mStringPoolSize =
 534                 (mHeader->stylesStart-mHeader->stringsStart)/charSize;
 535         }
 536
 537         // check invariant: stringCount > 0 requires a string pool to exist
 538         if (mStringPoolSize == 0) {
 539             ALOGW("Bad string block: stringCount is %d but pool size is 0\n", (int)mHeader->stringCount);
 540             return (mError=BAD_TYPE);
 541         }
 542
 543         if (notDeviceEndian) {
 544             size_t i;
 545             uint32_t* e = const_cast<uint32_t*>(mEntries);
 546             for (i=0; i<mHeader->stringCount; i++) {
 547                 e[i] = dtohl(mEntries[i]);
 548             }
 549             if (!(mHeader->flags&ResStringPool_header::UTF8_FLAG)) {
 550                 const uint16_t* strings = (const uint16_t*)mStrings;
 551                 uint16_t* s = const_cast<uint16_t*>(strings);
 552                 for (i=0; i<mStringPoolSize; i++) {
 553                     s[i] = dtohs(strings[i]);
 554                 }
 555             }
 556         }
 557
 558         if ((mHeader->flags&ResStringPool_header::UTF8_FLAG &&
 559                 ((uint8_t*)mStrings)[mStringPoolSize-1] != 0) ||
 560                 (!mHeader->flags&ResStringPool_header::UTF8_FLAG &&
 561                 ((uint16_t*)mStrings)[mStringPoolSize-1] != 0)) {
 562             ALOGW("Bad string block: last string is not 0-terminated\n");
 563             return (mError=BAD_TYPE);
 564         }
 565     } else {
 566         mStrings = NULL;
 567         mStringPoolSize = 0;
 568     }
 569
 570     if (mHeader->styleCount > 0) {
 571         mEntryStyles = mEntries + mHeader->stringCount;
 572         // invariant: integer overflow in calculating mEntryStyles
 573         if (mEntryStyles < mEntries) {
 574             ALOGW("Bad string block: integer overflow finding styles\n");
 575             return (mError=BAD_TYPE);
 576         }
 577
 578         if (((const uint8_t*)mEntryStyles-(const uint8_t*)mHeader) > (int)size) {
 579             ALOGW("Bad string block: entry of %d styles extends past data size %d\n",
 580                     (int)((const uint8_t*)mEntryStyles-(const uint8_t*)mHeader),
 581                     (int)size);
 582             return (mError=BAD_TYPE);
 583         }
 584         mStyles = (const uint32_t*)
 585             (((const uint8_t*)data)+mHeader->stylesStart);
 586         if (mHeader->stylesStart >= mHeader->header.size) {
 587             ALOGW("Bad string block: style pool starts %d, after total size %d\n",
 588                     (int)mHeader->stylesStart, (int)mHeader->header.size);
 589             return (mError=BAD_TYPE);
 590         }
 591         mStylePoolSize =
 592             (mHeader->header.size-mHeader->stylesStart)/sizeof(uint32_t);
 593
 594         if (notDeviceEndian) {
 595             size_t i;
 596             uint32_t* e = const_cast<uint32_t*>(mEntryStyles);
 597             for (i=0; i<mHeader->styleCount; i++) {
 598                 e[i] = dtohl(mEntryStyles[i]);
 599             }
 600             uint32_t* s = const_cast<uint32_t*>(mStyles);
 601             for (i=0; i<mStylePoolSize; i++) {
 602                 s[i] = dtohl(mStyles[i]);
 603             }
 604         }
 605
 606         const ResStringPool_span endSpan = {
 607             { htodl(ResStringPool_span::END) },
 608             htodl(ResStringPool_span::END), htodl(ResStringPool_span::END)
 609         };
 610         if (memcmp(&mStyles[mStylePoolSize-(sizeof(endSpan)/sizeof(uint32_t))],
 611                    &endSpan, sizeof(endSpan)) != 0) {
 612             ALOGW("Bad string block: last style is not 0xFFFFFFFF-terminated\n");
 613             return (mError=BAD_TYPE);
 614         }
 615     } else {
 616         mEntryStyles = NULL;
 617         mStyles = NULL;
 618         mStylePoolSize = 0;
 619     }
 620
 621     return (mError=NO_ERROR);
 622 }
 623
 624 status_t ResStringPool::getError() const
 625 {
 626     return mError;
 627 }
 628
 629 void ResStringPool::uninit()
 630 {
 631     mError = NO_INIT;
 632     if (mHeader != NULL && mCache != NULL) {
 633         for (size_t x = 0; x < mHeader->stringCount; x++) {
 634             if (mCache[x] != NULL) {
 635                 free(mCache[x]);
 636                 mCache[x] = NULL;
 637             }
 638         }
 639         free(mCache);
 640         mCache = NULL;
 641     }
 642     if (mOwnedData) {
 643         free(mOwnedData);
 644         mOwnedData = NULL;
 645     }
 646 }
 647
 648 /**
 649  * Strings in UTF-16 format have length indicated by a length encoded in the
 650  * stored data. It is either 1 or 2 characters of length data. This allows a
 651  * maximum length of 0x7FFFFFF (2147483647 bytes), but if you're storing that
 652  * much data in a string, you're abusing them.
 653  *
 654  * If the high bit is set, then there are two characters or 4 bytes of length
 655  * data encoded. In that case, drop the high bit of the first character and
 656  * add it together with the next character.
 657  */
 658 static inline size_t
 659 decodeLength(const uint16_t** str)
 660 {
 661     size_t len = **str;
 662     if ((len & 0x8000) != 0) {
 663         (*str)++;
 664         len = ((len & 0x7FFF) << 16) | **str;
 665     }
 666     (*str)++;
 667     return len;
 668 }
 669
 670 /**
 671  * Strings in UTF-8 format have length indicated by a length encoded in the
 672  * stored data. It is either 1 or 2 characters of length data. This allows a
 673  * maximum length of 0x7FFF (32767 bytes), but you should consider storing
 674  * text in another way if you're using that much data in a single string.
 675  *
 676  * If the high bit is set, then there are two characters or 2 bytes of length
 677  * data encoded. In that case, drop the high bit of the first character and
 678  * add it together with the next character.
 679  */
 680 static inline size_t
 681 decodeLength(const uint8_t** str)
 682 {
 683     size_t len = **str;
 684     if ((len & 0x80) != 0) {
 685         (*str)++;
 686         len = ((len & 0x7F) << 8) | **str;
 687     }
 688     (*str)++;
 689     return len;
 690 }
 691
 692 const char16_t* ResStringPool::stringAt(size_t idx, size_t* u16len) const
 693 {
 694     if (mError == NO_ERROR && idx < mHeader->stringCount) {
 695         const bool isUTF8 = (mHeader->flags&ResStringPool_header::UTF8_FLAG) != 0;
 696         const uint32_t off = mEntries[idx]/(isUTF8?sizeof(uint8_t):sizeof(uint16_t));
 697         if (off < (mStringPoolSize-1)) {
 698             if (!isUTF8) {
 699                 const uint16_t* strings = (uint16_t*)mStrings;
 700                 const uint16_t* str = strings+off;
 701
 702                 *u16len = decodeLength(&str);
 703                 if ((uint32_t)(str+*u16len-strings) < mStringPoolSize) {
 704                     return reinterpret_cast<const char16_t*>(str);
 705                 } else {
 706                     ALOGW("Bad string block: string #%d extends to %d, past end at %d\n",
 707                             (int)idx, (int)(str+*u16len-strings), (int)mStringPoolSize);
 708                 }
 709             } else {
 710                 const uint8_t* strings = (uint8_t*)mStrings;
 711                 const uint8_t* u8str = strings+off;
 712
 713                 *u16len = decodeLength(&u8str);
 714                 size_t u8len = decodeLength(&u8str);
 715
 716                 // encLen must be less than 0x7FFF due to encoding.
 717                 if ((uint32_t)(u8str+u8len-strings) < mStringPoolSize) {
 718                     AutoMutex lock(mDecodeLock);
 719
 720                     if (mCache == NULL) {
 721 #ifndef HAVE_ANDROID_OS
 722                         STRING_POOL_NOISY(ALOGI("CREATING STRING CACHE OF %d bytes",
 723                                 mHeader->stringCount*sizeof(char16_t**)));
 724 #else
 725                         // We do not want to be in this case when actually running Android.
 726                         ALOGW("CREATING STRING CACHE OF %d bytes",
 727                                 mHeader->stringCount*sizeof(char16_t**));
 728 #endif
 729                         mCache = (char16_t**)calloc(mHeader->stringCount, sizeof(char16_t**));
 730                         if (mCache == NULL) {
 731                             ALOGW("No memory trying to allocate decode cache table of %d bytes\n",
 732                                     (int)(mHeader->stringCount*sizeof(char16_t**)));
 733                             return NULL;
 734                         }
 735                     }
 736
 737                     if (mCache[idx] != NULL) {
 738                         return mCache[idx];
 739                     }
 740
 741                     ssize_t actualLen = utf8_to_utf16_length(u8str, u8len);
 742                     if (actualLen < 0 || (size_t)actualLen != *u16len) {
 743                         ALOGW("Bad string block: string #%lld decoded length is not correct "
 744                                 "%lld vs %llu\n",
 745                                 (long long)idx, (long long)actualLen, (long long)*u16len);
 746                         return NULL;
 747                     }
 748
 749                     char16_t *u16str = (char16_t *)calloc(*u16len+1, sizeof(char16_t));
 750                     if (!u16str) {
 751                         ALOGW("No memory when trying to allocate decode cache for string #%d\n",
 752                                 (int)idx);
 753                         return NULL;
 754                     }
 755
 756                     STRING_POOL_NOISY(ALOGI("Caching UTF8 string: %s", u8str));
 757                     utf8_to_utf16(u8str, u8len, u16str);
 758                     mCache[idx] = u16str;
 759                     return u16str;
 760                 } else {
 761                     ALOGW("Bad string block: string #%lld extends to %lld, past end at %lld\n",
 762                             (long long)idx, (long long)(u8str+u8len-strings),
 763                             (long long)mStringPoolSize);
 764                 }
 765             }
 766         } else {
 767             ALOGW("Bad string block: string #%d entry is at %d, past end at %d\n",
 768                     (int)idx, (int)(off*sizeof(uint16_t)),
 769                     (int)(mStringPoolSize*sizeof(uint16_t)));
 770         }
 771     }
 772     return NULL;
 773 }
 774
 775 const char* ResStringPool::string8At(size_t idx, size_t* outLen) const
 776 {
 777     if (mError == NO_ERROR && idx < mHeader->stringCount) {
 778         if ((mHeader->flags&ResStringPool_header::UTF8_FLAG) == 0) {
 779             return NULL;
 780         }
 781         const uint32_t off = mEntries[idx]/sizeof(char);
 782         if (off < (mStringPoolSize-1)) {
 783             const uint8_t* strings = (uint8_t*)mStrings;
 784             const uint8_t* str = strings+off;
 785             *outLen = decodeLength(&str);
 786             size_t encLen = decodeLength(&str);
 787             if ((uint32_t)(str+encLen-strings) < mStringPoolSize) {
 788                 return (const char*)str;
 789             } else {
 790                 ALOGW("Bad string block: string #%d extends to %d, past end at %d\n",
 791                         (int)idx, (int)(str+encLen-strings), (int)mStringPoolSize);
 792             }
 793         } else {
 794             ALOGW("Bad string block: string #%d entry is at %d, past end at %d\n",
 795                     (int)idx, (int)(off*sizeof(uint16_t)),
 796                     (int)(mStringPoolSize*sizeof(uint16_t)));
 797         }
 798     }
 799     return NULL;
 800 }
 801
 802 const String8 ResStringPool::string8ObjectAt(size_t idx) const
 803 {
 804     size_t len;
 805     const char *str = string8At(idx, &len);
 806     if (str != NULL) {
 807         return String8(str, len);
 808     }
 809
 810     const char16_t *str16 = stringAt(idx, &len);
 811     if (str16 != NULL) {
 812         return String8(str16, len);
 813     }
 814     return String8();
 815 }
 816
 817 const ResStringPool_span* ResStringPool::styleAt(const ResStringPool_ref& ref) const
 818 {
 819     return styleAt(ref.index);
 820 }
 821
 822 const ResStringPool_span* ResStringPool::styleAt(size_t idx) const
 823 {
 824     if (mError == NO_ERROR && idx < mHeader->styleCount) {
 825         const uint32_t off = (mEntryStyles[idx]/sizeof(uint32_t));
 826         if (off < mStylePoolSize) {
 827             return (const ResStringPool_span*)(mStyles+off);
 828         } else {
 829             ALOGW("Bad string block: style #%d entry is at %d, past end at %d\n",
 830                     (int)idx, (int)(off*sizeof(uint32_t)),
 831                     (int)(mStylePoolSize*sizeof(uint32_t)));
 832         }
 833     }
 834     return NULL;
 835 }
 836
 837 ssize_t ResStringPool::indexOfString(const char16_t* str, size_t strLen) const
 838 {
 839     if (mError != NO_ERROR) {
 840         return mError;
 841     }
 842
 843     size_t len;
 844
 845     if ((mHeader->flags&ResStringPool_header::UTF8_FLAG) != 0) {
 846         STRING_POOL_NOISY(ALOGI("indexOfString UTF-8: %s", String8(str, strLen).string()));
 847
 848         // The string pool contains UTF 8 strings; we don't want to cause
 849         // temporary UTF-16 strings to be created as we search.
 850         if (mHeader->flags&ResStringPool_header::SORTED_FLAG) {
 851             // Do a binary search for the string...  this is a little tricky,
 852             // because the strings are sorted with strzcmp16().  So to match
 853             // the ordering, we need to convert strings in the pool to UTF-16.
 854             // But we don't want to hit the cache, so instead we will have a
 855             // local temporary allocation for the conversions.
 856             char16_t* convBuffer = (char16_t*)malloc(strLen+4);
 857             ssize_t l = 0;
 858             ssize_t h = mHeader->stringCount-1;
 859
 860             ssize_t mid;
 861             while (l <= h) {
 862                 mid = l + (h - l)/2;
 863                 const uint8_t* s = (const uint8_t*)string8At(mid, &len);
 864                 int c;
 865                 if (s != NULL) {
 866                     char16_t* end = utf8_to_utf16_n(s, len, convBuffer, strLen+3);
 867                     *end = 0;
 868                     c = strzcmp16(convBuffer, end-convBuffer, str, strLen);
 869                 } else {
 870                     c = -1;
 871                 }
 872                 STRING_POOL_NOISY(ALOGI("Looking at %s, cmp=%d, l/mid/h=%d/%d/%d\n",
 873                              (const char*)s, c, (int)l, (int)mid, (int)h));
 874                 if (c == 0) {
 875                     STRING_POOL_NOISY(ALOGI("MATCH!"));
 876                     free(convBuffer);
 877                     return mid;
 878                 } else if (c < 0) {
 879                     l = mid + 1;
 880                 } else {
 881                     h = mid - 1;
 882                 }
 883             }
 884             free(convBuffer);
 885         } else {
 886             // It is unusual to get the ID from an unsorted string block...
 887             // most often this happens because we want to get IDs for style
 888             // span tags; since those always appear at the end of the string
 889             // block, start searching at the back.
 890             String8 str8(str, strLen);
 891             const size_t str8Len = str8.size();
 892             for (int i=mHeader->stringCount-1; i>=0; i--) {
 893                 const char* s = string8At(i, &len);
 894                 STRING_POOL_NOISY(ALOGI("Looking at %s, i=%d\n",
 895                              String8(s).string(),
 896                              i));
 897                 if (s && str8Len == len && memcmp(s, str8.string(), str8Len) == 0) {
 898                     STRING_POOL_NOISY(ALOGI("MATCH!"));
 899                     return i;
 900                 }
 901             }
 902         }
 903
 904     } else {
 905         STRING_POOL_NOISY(ALOGI("indexOfString UTF-16: %s", String8(str, strLen).string()));
 906
 907         if (mHeader->flags&ResStringPool_header::SORTED_FLAG) {
 908             // Do a binary search for the string...
 909             ssize_t l = 0;
 910             ssize_t h = mHeader->stringCount-1;
 911
 912             ssize_t mid;
 913             while (l <= h) {
 914                 mid = l + (h - l)/2;
 915                 const char16_t* s = stringAt(mid, &len);
 916                 int c = s ? strzcmp16(s, len, str, strLen) : -1;
 917                 STRING_POOL_NOISY(ALOGI("Looking at %s, cmp=%d, l/mid/h=%d/%d/%d\n",
 918                              String8(s).string(),
 919                              c, (int)l, (int)mid, (int)h));
 920                 if (c == 0) {
 921                     STRING_POOL_NOISY(ALOGI("MATCH!"));
 922                     return mid;
 923                 } else if (c < 0) {
 924                     l = mid + 1;
 925                 } else {
 926                     h = mid - 1;
 927                 }
 928             }
 929         } else {
 930             // It is unusual to get the ID from an unsorted string block...
 931             // most often this happens because we want to get IDs for style
 932             // span tags; since those always appear at the end of the string
 933             // block, start searching at the back.
 934             for (int i=mHeader->stringCount-1; i>=0; i--) {
 935                 const char16_t* s = stringAt(i, &len);
 936                 STRING_POOL_NOISY(ALOGI("Looking at %s, i=%d\n",
 937                              String8(s).string(),
 938                              i));
 939                 if (s && strLen == len && strzcmp16(s, len, str, strLen) == 0) {
 940                     STRING_POOL_NOISY(ALOGI("MATCH!"));
 941                     return i;
 942                 }
 943             }
 944         }
 945     }
 946
 947     return NAME_NOT_FOUND;
 948 }
 949
 950 size_t ResStringPool::size() const
 951 {
 952     return (mError == NO_ERROR) ? mHeader->stringCount : 0;
 953 }
 954
 955 size_t ResStringPool::styleCount() const
 956 {
 957     return (mError == NO_ERROR) ? mHeader->styleCount : 0;
 958 }
 959
 960 size_t ResStringPool::bytes() const
 961 {
 962     return (mError == NO_ERROR) ? mHeader->header.size : 0;
 963 }
 964
 965 bool ResStringPool::isSorted() const
 966 {
 967     return (mHeader->flags&ResStringPool_header::SORTED_FLAG)!=0;
 968 }
 969
 970 bool ResStringPool::isUTF8() const
 971 {
 972     return (mHeader->flags&ResStringPool_header::UTF8_FLAG)!=0;
 973 }
 974
 975 // --------------------------------------------------------------------
 976 // --------------------------------------------------------------------
 977 // --------------------------------------------------------------------
 978
 979 ResXMLParser::ResXMLParser(const ResXMLTree& tree)
 980     : mTree(tree), mEventCode(BAD_DOCUMENT)
 981 {
 982 }
 983
 984 void ResXMLParser::restart()
 985 {
 986     mCurNode = NULL;
 987     mEventCode = mTree.mError == NO_ERROR ? START_DOCUMENT : BAD_DOCUMENT;
 988 }
 989 const ResStringPool& ResXMLParser::getStrings() const
 990 {
 991     return mTree.mStrings;
 992 }
 993
 994 ResXMLParser::event_code_t ResXMLParser::getEventType() const
 995 {
 996     return mEventCode;
 997 }
 998
 999 ResXMLParser::event_code_t ResXMLParser::next()
1000 {
1001     if (mEventCode == START_DOCUMENT) {
1002         mCurNode = mTree.mRootNode;
1003         mCurExt = mTree.mRootExt;
1004         return (mEventCode=mTree.mRootCode);
1005     } else if (mEventCode >= FIRST_CHUNK_CODE) {
1006         return nextNode();
1007     }
1008     return mEventCode;
1009 }
1010
1011 int32_t ResXMLParser::getCommentID() const
1012 {
1013     return mCurNode != NULL ? dtohl(mCurNode->comment.index) : -1;
1014 }
1015
1016 const char16_t* ResXMLParser::getComment(size_t* outLen) const
1017 {
1018     int32_t id = getCommentID();
1019     return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
1020 }
1021
1022 uint32_t ResXMLParser::getLineNumber() const
1023 {
1024     return mCurNode != NULL ? dtohl(mCurNode->lineNumber) : -1;
1025 }
1026
1027 int32_t ResXMLParser::getTextID() const
1028 {
1029     if (mEventCode == TEXT) {
1030         return dtohl(((const ResXMLTree_cdataExt*)mCurExt)->data.index);
1031     }
1032     return -1;
1033 }
1034
1035 const char16_t* ResXMLParser::getText(size_t* outLen) const
1036 {
1037     int32_t id = getTextID();
1038     return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
1039 }
1040
1041 ssize_t ResXMLParser::getTextValue(Res_value* outValue) const
1042 {
1043     if (mEventCode == TEXT) {
1044         outValue->copyFrom_dtoh(((const ResXMLTree_cdataExt*)mCurExt)->typedData);
1045         return sizeof(Res_value);
1046     }
1047     return BAD_TYPE;
1048 }
1049
1050 int32_t ResXMLParser::getNamespacePrefixID() const
1051 {
1052     if (mEventCode == START_NAMESPACE || mEventCode == END_NAMESPACE) {
1053         return dtohl(((const ResXMLTree_namespaceExt*)mCurExt)->prefix.index);
1054     }
1055     return -1;
1056 }
1057
1058 const char16_t* ResXMLParser::getNamespacePrefix(size_t* outLen) const
1059 {
1060     int32_t id = getNamespacePrefixID();
1061     //printf("prefix=%d  event=%p\n", id, mEventCode);
1062     return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
1063 }
1064
1065 int32_t ResXMLParser::getNamespaceUriID() const
1066 {
1067     if (mEventCode == START_NAMESPACE || mEventCode == END_NAMESPACE) {
1068         return dtohl(((const ResXMLTree_namespaceExt*)mCurExt)->uri.index);
1069     }
1070     return -1;
1071 }
1072
1073 const char16_t* ResXMLParser::getNamespaceUri(size_t* outLen) const
1074 {
1075     int32_t id = getNamespaceUriID();
1076     //printf("uri=%d  event=%p\n", id, mEventCode);
1077     return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
1078 }
1079
1080 int32_t ResXMLParser::getElementNamespaceID() const
1081 {
1082     if (mEventCode == START_TAG) {
1083         return dtohl(((const ResXMLTree_attrExt*)mCurExt)->ns.index);
1084     }
1085     if (mEventCode == END_TAG) {
1086         return dtohl(((const ResXMLTree_endElementExt*)mCurExt)->ns.index);
1087     }
1088     return -1;
1089 }
1090
1091 const char16_t* ResXMLParser::getElementNamespace(size_t* outLen) const
1092 {
1093     int32_t id = getElementNamespaceID();
1094     return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
1095 }
1096
1097 int32_t ResXMLParser::getElementNameID() const
1098 {
1099     if (mEventCode == START_TAG) {
1100         return dtohl(((const ResXMLTree_attrExt*)mCurExt)->name.index);
1101     }
1102     if (mEventCode == END_TAG) {
1103         return dtohl(((const ResXMLTree_endElementExt*)mCurExt)->name.index);
1104     }
1105     return -1;
1106 }
1107
1108 const char16_t* ResXMLParser::getElementName(size_t* outLen) const
1109 {
1110     int32_t id = getElementNameID();
1111     return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
1112 }
1113
1114 size_t ResXMLParser::getAttributeCount() const
1115 {
1116     if (mEventCode == START_TAG) {
1117         return dtohs(((const ResXMLTree_attrExt*)mCurExt)->attributeCount);
1118     }
1119     return 0;
1120 }
1121
1122 int32_t ResXMLParser::getAttributeNamespaceID(size_t idx) const
1123 {
1124     if (mEventCode == START_TAG) {
1125         const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
1126         if (idx < dtohs(tag->attributeCount)) {
1127             const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
1128                 (((const uint8_t*)tag)
1129                  + dtohs(tag->attributeStart)
1130                  + (dtohs(tag->attributeSize)*idx));
1131             return dtohl(attr->ns.index);
1132         }
1133     }
1134     return -2;
1135 }
1136
1137 const char16_t* ResXMLParser::getAttributeNamespace(size_t idx, size_t* outLen) const
1138 {
1139     int32_t id = getAttributeNamespaceID(idx);
1140     //printf("attribute namespace=%d  idx=%d  event=%p\n", id, idx, mEventCode);
1141     //XML_NOISY(printf("getAttributeNamespace 0x%x=0x%x\n", idx, id));
1142     return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
1143 }
1144
1145 const char* ResXMLParser::getAttributeNamespace8(size_t idx, size_t* outLen) const
1146 {
1147     int32_t id = getAttributeNamespaceID(idx);
1148     //printf("attribute namespace=%d  idx=%d  event=%p\n", id, idx, mEventCode);
1149     //XML_NOISY(printf("getAttributeNamespace 0x%x=0x%x\n", idx, id));
1150     return id >= 0 ? mTree.mStrings.string8At(id, outLen) : NULL;
1151 }
1152
1153 int32_t ResXMLParser::getAttributeNameID(size_t idx) const
1154 {
1155     if (mEventCode == START_TAG) {
1156         const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
1157         if (idx < dtohs(tag->attributeCount)) {
1158             const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
1159                 (((const uint8_t*)tag)
1160                  + dtohs(tag->attributeStart)
1161                  + (dtohs(tag->attributeSize)*idx));
1162             return dtohl(attr->name.index);
1163         }
1164     }
1165     return -1;
1166 }
1167
1168 const char16_t* ResXMLParser::getAttributeName(size_t idx, size_t* outLen) const
1169 {
1170     int32_t id = getAttributeNameID(idx);
1171     //printf("attribute name=%d  idx=%d  event=%p\n", id, idx, mEventCode);
1172     //XML_NOISY(printf("getAttributeName 0x%x=0x%x\n", idx, id));
1173     return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
1174 }
1175
1176 const char* ResXMLParser::getAttributeName8(size_t idx, size_t* outLen) const
1177 {
1178     int32_t id = getAttributeNameID(idx);
1179     //printf("attribute name=%d  idx=%d  event=%p\n", id, idx, mEventCode);
1180     //XML_NOISY(printf("getAttributeName 0x%x=0x%x\n", idx, id));
1181     return id >= 0 ? mTree.mStrings.string8At(id, outLen) : NULL;
1182 }
1183
1184 uint32_t ResXMLParser::getAttributeNameResID(size_t idx) const
1185 {
1186     int32_t id = getAttributeNameID(idx);
1187     if (id >= 0 && (size_t)id < mTree.mNumResIds) {
1188         uint32_t resId = dtohl(mTree.mResIds[id]);
1189         if (mTree.mDynamicRefTable != NULL) {
1190             mTree.mDynamicRefTable->lookupResourceId(&resId);
1191         }
1192         return resId;
1193     }
1194     return 0;
1195 }
1196
1197 int32_t ResXMLParser::getAttributeValueStringID(size_t idx) const
1198 {
1199     if (mEventCode == START_TAG) {
1200         const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
1201         if (idx < dtohs(tag->attributeCount)) {
1202             const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
1203                 (((const uint8_t*)tag)
1204                  + dtohs(tag->attributeStart)
1205                  + (dtohs(tag->attributeSize)*idx));
1206             return dtohl(attr->rawValue.index);
1207         }
1208     }
1209     return -1;
1210 }
1211
1212 const char16_t* ResXMLParser::getAttributeStringValue(size_t idx, size_t* outLen) const
1213 {
1214     int32_t id = getAttributeValueStringID(idx);
1215     //XML_NOISY(printf("getAttributeValue 0x%x=0x%x\n", idx, id));
1216     return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
1217 }
1218
1219 int32_t ResXMLParser::getAttributeDataType(size_t idx) const
1220 {
1221     if (mEventCode == START_TAG) {
1222         const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
1223         if (idx < dtohs(tag->attributeCount)) {
1224             const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
1225                 (((const uint8_t*)tag)
1226                  + dtohs(tag->attributeStart)
1227                  + (dtohs(tag->attributeSize)*idx));
1228             uint8_t type = attr->typedValue.dataType;
1229             if (type != Res_value::TYPE_DYNAMIC_REFERENCE) {
1230                 return type;
1231             }
1232
1233             // This is a dynamic reference. We adjust those references
1234             // to regular references at this level, so lie to the caller.
1235             return Res_value::TYPE_REFERENCE;
1236         }
1237     }
1238     return Res_value::TYPE_NULL;
1239 }
1240
1241 int32_t ResXMLParser::getAttributeData(size_t idx) const
1242 {
1243     if (mEventCode == START_TAG) {
1244         const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
1245         if (idx < dtohs(tag->attributeCount)) {
1246             const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
1247                 (((const uint8_t*)tag)
1248                  + dtohs(tag->attributeStart)
1249                  + (dtohs(tag->attributeSize)*idx));
1250             if (attr->typedValue.dataType != Res_value::TYPE_DYNAMIC_REFERENCE ||
1251                     mTree.mDynamicRefTable == NULL) {
1252                 return dtohl(attr->typedValue.data);
1253             }
1254
1255             uint32_t data = dtohl(attr->typedValue.data);
1256             if (mTree.mDynamicRefTable->lookupResourceId(&data) == NO_ERROR) {
1257                 return data;
1258             }
1259         }
1260     }
1261     return 0;
1262 }
1263
1264 ssize_t ResXMLParser::getAttributeValue(size_t idx, Res_value* outValue) const
1265 {
1266     if (mEventCode == START_TAG) {
1267         const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
1268         if (idx < dtohs(tag->attributeCount)) {
1269             const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
1270                 (((const uint8_t*)tag)
1271                  + dtohs(tag->attributeStart)
1272                  + (dtohs(tag->attributeSize)*idx));
1273             outValue->copyFrom_dtoh(attr->typedValue);
1274             if (mTree.mDynamicRefTable != NULL &&
1275                     mTree.mDynamicRefTable->lookupResourceValue(outValue) != NO_ERROR) {
1276                 return BAD_TYPE;
1277             }
1278             return sizeof(Res_value);
1279         }
1280     }
1281     return BAD_TYPE;
1282 }
1283
1284 ssize_t ResXMLParser::indexOfAttribute(const char* ns, const char* attr) const
1285 {
1286     String16 nsStr(ns != NULL ? ns : "");
1287     String16 attrStr(attr);
1288     return indexOfAttribute(ns ? nsStr.string() : NULL, ns ? nsStr.size() : 0,
1289                             attrStr.string(), attrStr.size());
1290 }
1291
1292 ssize_t ResXMLParser::indexOfAttribute(const char16_t* ns, size_t nsLen,
1293                                        const char16_t* attr, size_t attrLen) const
1294 {
1295     if (mEventCode == START_TAG) {
1296         if (attr == NULL) {
1297             return NAME_NOT_FOUND;
1298         }
1299         const size_t N = getAttributeCount();
1300         if (mTree.mStrings.isUTF8()) {
1301             String8 ns8, attr8;
1302             if (ns != NULL) {
1303                 ns8 = String8(ns, nsLen);
1304             }
1305             attr8 = String8(attr, attrLen);
1306             STRING_POOL_NOISY(ALOGI("indexOfAttribute UTF8 %s (%d) / %s (%d)", ns8.string(), nsLen,
1307                     attr8.string(), attrLen));
1308             for (size_t i=0; i<N; i++) {
1309                 size_t curNsLen = 0, curAttrLen = 0;
1310                 const char* curNs = getAttributeNamespace8(i, &curNsLen);
1311                 const char* curAttr = getAttributeName8(i, &curAttrLen);
1312                 STRING_POOL_NOISY(ALOGI("  curNs=%s (%d), curAttr=%s (%d)", curNs, curNsLen,
1313                         curAttr, curAttrLen));
1314                 if (curAttr != NULL && curNsLen == nsLen && curAttrLen == attrLen
1315                         && memcmp(attr8.string(), curAttr, attrLen) == 0) {
1316                     if (ns == NULL) {
1317                         if (curNs == NULL) {
1318                             STRING_POOL_NOISY(ALOGI("  FOUND!"));
1319                             return i;
1320                         }
1321                     } else if (curNs != NULL) {
1322                         //printf(" --> ns=%s, curNs=%s\n",
1323                         //       String8(ns).string(), String8(curNs).string());
1324                         if (memcmp(ns8.string(), curNs, nsLen) == 0) {
1325                             STRING_POOL_NOISY(ALOGI("  FOUND!"));
1326                             return i;
1327                         }
1328                     }
1329                 }
1330             }
1331         } else {
1332             STRING_POOL_NOISY(ALOGI("indexOfAttribute UTF16 %s (%d) / %s (%d)",
1333                     String8(ns, nsLen).string(), nsLen,
1334                     String8(attr, attrLen).string(), attrLen));
1335             for (size_t i=0; i<N; i++) {
1336                 size_t curNsLen = 0, curAttrLen = 0;
1337                 const char16_t* curNs = getAttributeNamespace(i, &curNsLen);
1338                 const char16_t* curAttr = getAttributeName(i, &curAttrLen);
1339                 STRING_POOL_NOISY(ALOGI("  curNs=%s (%d), curAttr=%s (%d)",
1340                         String8(curNs, curNsLen).string(), curNsLen,
1341                         String8(curAttr, curAttrLen).string(), curAttrLen));
1342                 if (curAttr != NULL && curNsLen == nsLen && curAttrLen == attrLen
1343                         && (memcmp(attr, curAttr, attrLen*sizeof(char16_t)) == 0)) {
1344                     if (ns == NULL) {
1345                         if (curNs == NULL) {
1346                             STRING_POOL_NOISY(ALOGI("  FOUND!"));
1347                             return i;
1348                         }
1349                     } else if (curNs != NULL) {
1350                         //printf(" --> ns=%s, curNs=%s\n",
1351                         //       String8(ns).string(), String8(curNs).string());
1352                         if (memcmp(ns, curNs, nsLen*sizeof(char16_t)) == 0) {
1353                             STRING_POOL_NOISY(ALOGI("  FOUND!"));
1354                             return i;
1355                         }
1356                     }
1357                 }
1358             }
1359         }
1360     }
1361
1362     return NAME_NOT_FOUND;
1363 }
1364
1365 ssize_t ResXMLParser::indexOfID() const
1366 {
1367     if (mEventCode == START_TAG) {
1368         const ssize_t idx = dtohs(((const ResXMLTree_attrExt*)mCurExt)->idIndex);
1369         if (idx > 0) return (idx-1);
1370     }
1371     return NAME_NOT_FOUND;
1372 }
1373
1374 ssize_t ResXMLParser::indexOfClass() const
1375 {
1376     if (mEventCode == START_TAG) {
1377         const ssize_t idx = dtohs(((const ResXMLTree_attrExt*)mCurExt)->classIndex);
1378         if (idx > 0) return (idx-1);
1379     }
1380     return NAME_NOT_FOUND;
1381 }
1382
1383 ssize_t ResXMLParser::indexOfStyle() const
1384 {
1385     if (mEventCode == START_TAG) {
1386         const ssize_t idx = dtohs(((const ResXMLTree_attrExt*)mCurExt)->styleIndex);
1387         if (idx > 0) return (idx-1);
1388     }
1389     return NAME_NOT_FOUND;
1390 }
1391
1392 ResXMLParser::event_code_t ResXMLParser::nextNode()
1393 {
1394     if (mEventCode < 0) {
1395         return mEventCode;
1396     }
1397
1398     do {
1399         const ResXMLTree_node* next = (const ResXMLTree_node*)
1400             (((const uint8_t*)mCurNode) + dtohl(mCurNode->header.size));
1401         //ALOGW("Next node: prev=%p, next=%p\n", mCurNode, next);
1402
1403         if (((const uint8_t*)next) >= mTree.mDataEnd) {
1404             mCurNode = NULL;
1405             return (mEventCode=END_DOCUMENT);
1406         }
1407
1408         if (mTree.validateNode(next) != NO_ERROR) {
1409             mCurNode = NULL;
1410             return (mEventCode=BAD_DOCUMENT);
1411         }
1412
1413         mCurNode = next;
1414         const uint16_t headerSize = dtohs(next->header.headerSize);
1415         const uint32_t totalSize = dtohl(next->header.size);
1416         mCurExt = ((const uint8_t*)next) + headerSize;
1417         size_t minExtSize = 0;
1418         event_code_t eventCode = (event_code_t)dtohs(next->header.type);
1419         switch ((mEventCode=eventCode)) {
1420             case RES_XML_START_NAMESPACE_TYPE:
1421             case RES_XML_END_NAMESPACE_TYPE:
1422                 minExtSize = sizeof(ResXMLTree_namespaceExt);
1423                 break;
1424             case RES_XML_START_ELEMENT_TYPE:
1425                 minExtSize = sizeof(ResXMLTree_attrExt);
1426                 break;
1427             case RES_XML_END_ELEMENT_TYPE:
1428                 minExtSize = sizeof(ResXMLTree_endElementExt);
1429                 break;
1430             case RES_XML_CDATA_TYPE:
1431                 minExtSize = sizeof(ResXMLTree_cdataExt);
1432                 break;
1433             default:
1434                 ALOGW("Unknown XML block: header type %d in node at %d\n",
1435                      (int)dtohs(next->header.type),
1436                      (int)(((const uint8_t*)next)-((const uint8_t*)mTree.mHeader)));
1437                 continue;
1438         }
1439
1440         if ((totalSize-headerSize) < minExtSize) {
1441             ALOGW("Bad XML block: header type 0x%x in node at 0x%x has size %d, need %d\n",
1442                  (int)dtohs(next->header.type),
1443                  (int)(((const uint8_t*)next)-((const uint8_t*)mTree.mHeader)),
1444                  (int)(totalSize-headerSize), (int)minExtSize);
1445             return (mEventCode=BAD_DOCUMENT);
1446         }
1447
1448         //printf("CurNode=%p, CurExt=%p, headerSize=%d, minExtSize=%d\n",
1449         //       mCurNode, mCurExt, headerSize, minExtSize);
1450
1451         return eventCode;
1452     } while (true);
1453 }
1454
1455 void ResXMLParser::getPosition(ResXMLParser::ResXMLPosition* pos) const
1456 {
1457     pos->eventCode = mEventCode;
1458     pos->curNode = mCurNode;
1459     pos->curExt = mCurExt;
1460 }
1461
1462 void ResXMLParser::setPosition(const ResXMLParser::ResXMLPosition& pos)
1463 {
1464     mEventCode = pos.eventCode;
1465     mCurNode = pos.curNode;
1466     mCurExt = pos.curExt;
1467 }
1468
1469 // --------------------------------------------------------------------
1470
1471 static volatile int32_t gCount = 0;
1472
1473 ResXMLTree::ResXMLTree(const DynamicRefTable* dynamicRefTable)
1474     : ResXMLParser(*this)
1475     , mDynamicRefTable(dynamicRefTable)
1476     , mError(NO_INIT), mOwnedData(NULL)
1477 {
1478     //ALOGI("Creating ResXMLTree %p #%d\n", this, android_atomic_inc(&gCount)+1);
1479     restart();
1480 }
1481
1482 ResXMLTree::ResXMLTree()
1483     : ResXMLParser(*this)
1484     , mDynamicRefTable(NULL)
1485     , mError(NO_INIT), mOwnedData(NULL)
1486 {
1487     //ALOGI("Creating ResXMLTree %p #%d\n", this, android_atomic_inc(&gCount)+1);
1488     restart();
1489 }
1490
1491 ResXMLTree::~ResXMLTree()
1492 {
1493     //ALOGI("Destroying ResXMLTree in %p #%d\n", this, android_atomic_dec(&gCount)-1);
1494     uninit();
1495 }
1496
1497 status_t ResXMLTree::setTo(const void* data, size_t size, bool copyData)
1498 {
1499     uninit();
1500     mEventCode = START_DOCUMENT;
1501
1502     if (!data || !size) {
1503         return (mError=BAD_TYPE);
1504     }
1505
1506     if (copyData) {
1507         mOwnedData = malloc(size);
1508         if (mOwnedData == NULL) {
1509             return (mError=NO_MEMORY);
1510         }
1511         memcpy(mOwnedData, data, size);
1512         data = mOwnedData;
1513     }
1514
1515     mHeader = (const ResXMLTree_header*)data;
1516     mSize = dtohl(mHeader->header.size);
1517     if (dtohs(mHeader->header.headerSize) > mSize || mSize > size) {
1518         ALOGW("Bad XML block: header size %d or total size %d is larger than data size %d\n",
1519              (int)dtohs(mHeader->header.headerSize),
1520              (int)dtohl(mHeader->header.size), (int)size);
1521         mError = BAD_TYPE;
1522         restart();
1523         return mError;
1524     }
1525     mDataEnd = ((const uint8_t*)mHeader) + mSize;
1526
1527     mStrings.uninit();
1528     mRootNode = NULL;
1529     mResIds = NULL;
1530     mNumResIds = 0;
1531
1532     // First look for a couple interesting chunks: the string block
1533     // and first XML node.
1534     const ResChunk_header* chunk =
1535         (const ResChunk_header*)(((const uint8_t*)mHeader) + dtohs(mHeader->header.headerSize));
1536     const ResChunk_header* lastChunk = chunk;
1537     while (((const uint8_t*)chunk) < (mDataEnd-sizeof(ResChunk_header)) &&
1538            ((const uint8_t*)chunk) < (mDataEnd-dtohl(chunk->size))) {
1539         status_t err = validate_chunk(chunk, sizeof(ResChunk_header), mDataEnd, "XML");
1540         if (err != NO_ERROR) {
1541             mError = err;
1542             goto done;
1543         }
1544         const uint16_t type = dtohs(chunk->type);
1545         const size_t size = dtohl(chunk->size);
1546         XML_NOISY(printf("Scanning @ %p: type=0x%x, size=0x%x\n",
1547                      (void*)(((uint32_t)chunk)-((uint32_t)mHeader)), type, size));
1548         if (type == RES_STRING_POOL_TYPE) {
1549             mStrings.setTo(chunk, size);
1550         } else if (type == RES_XML_RESOURCE_MAP_TYPE) {
1551             mResIds = (const uint32_t*)
1552                 (((const uint8_t*)chunk)+dtohs(chunk->headerSize));
1553             mNumResIds = (dtohl(chunk->size)-dtohs(chunk->headerSize))/sizeof(uint32_t);
1554         } else if (type >= RES_XML_FIRST_CHUNK_TYPE
1555                    && type <= RES_XML_LAST_CHUNK_TYPE) {
1556             if (validateNode((const ResXMLTree_node*)chunk) != NO_ERROR) {
1557                 mError = BAD_TYPE;
1558                 goto done;
1559             }
1560             mCurNode = (const ResXMLTree_node*)lastChunk;
1561             if (nextNode() == BAD_DOCUMENT) {
1562                 mError = BAD_TYPE;
1563                 goto done;
1564             }
1565             mRootNode = mCurNode;
1566             mRootExt = mCurExt;
1567             mRootCode = mEventCode;
1568             break;
1569         } else {
1570             XML_NOISY(printf("Skipping unknown chunk!\n"));
1571         }
1572         lastChunk = chunk;
1573         chunk = (const ResChunk_header*)
1574             (((const uint8_t*)chunk) + size);
1575     }
1576
1577     if (mRootNode == NULL) {
1578         ALOGW("Bad XML block: no root element node found\n");
1579         mError = BAD_TYPE;
1580         goto done;
1581     }
1582
1583     mError = mStrings.getError();
1584
1585 done:
1586     restart();
1587     return mError;
1588 }
1589
1590 status_t ResXMLTree::getError() const
1591 {
1592     return mError;
1593 }
1594
1595 void ResXMLTree::uninit()
1596 {
1597     mError = NO_INIT;
1598     mStrings.uninit();
1599     if (mOwnedData) {
1600         free(mOwnedData);
1601         mOwnedData = NULL;
1602     }
1603     restart();
1604 }
1605
1606 status_t ResXMLTree::validateNode(const ResXMLTree_node* node) const
1607 {
1608     const uint16_t eventCode = dtohs(node->header.type);
1609
1610     status_t err = validate_chunk(
1611         &node->header, sizeof(ResXMLTree_node),
1612         mDataEnd, "ResXMLTree_node");
1613
1614     if (err >= NO_ERROR) {
1615         // Only perform additional validation on START nodes
1616         if (eventCode != RES_XML_START_ELEMENT_TYPE) {
1617             return NO_ERROR;
1618         }
1619
1620         const uint16_t headerSize = dtohs(node->header.headerSize);
1621         const uint32_t size = dtohl(node->header.size);
1622         const ResXMLTree_attrExt* attrExt = (const ResXMLTree_attrExt*)
1623             (((const uint8_t*)node) + headerSize);
1624         // check for sensical values pulled out of the stream so far...
1625         if ((size >= headerSize + sizeof(ResXMLTree_attrExt))
1626                 && ((void*)attrExt > (void*)node)) {
1627             const size_t attrSize = ((size_t)dtohs(attrExt->attributeSize))
1628                 * dtohs(attrExt->attributeCount);
1629             if ((dtohs(attrExt->attributeStart)+attrSize) <= (size-headerSize)) {
1630                 return NO_ERROR;
1631             }
1632             ALOGW("Bad XML block: node attributes use 0x%x bytes, only have 0x%x bytes\n",
1633                     (unsigned int)(dtohs(attrExt->attributeStart)+attrSize),
1634                     (unsigned int)(size-headerSize));
1635         }
1636         else {
1637             ALOGW("Bad XML start block: node header size 0x%x, size 0x%x\n",
1638                 (unsigned int)headerSize, (unsigned int)size);
1639         }
1640         return BAD_TYPE;
1641     }
1642
1643     return err;
1644
1645 #if 0
1646     const bool isStart = dtohs(node->header.type) == RES_XML_START_ELEMENT_TYPE;
1647
1648     const uint16_t headerSize = dtohs(node->header.headerSize);
1649     const uint32_t size = dtohl(node->header.size);
1650
1651     if (headerSize >= (isStart ? sizeof(ResXMLTree_attrNode) : sizeof(ResXMLTree_node))) {
1652         if (size >= headerSize) {
1653             if (((const uint8_t*)node) <= (mDataEnd-size)) {
1654                 if (!isStart) {
1655                     return NO_ERROR;
1656                 }
1657                 if ((((size_t)dtohs(node->attributeSize))*dtohs(node->attributeCount))
1658                         <= (size-headerSize)) {
1659                     return NO_ERROR;
1660                 }
1661                 ALOGW("Bad XML block: node attributes use 0x%x bytes, only have 0x%x bytes\n",
1662                         ((int)dtohs(node->attributeSize))*dtohs(node->attributeCount),
1663                         (int)(size-headerSize));
1664                 return BAD_TYPE;
1665             }
1666             ALOGW("Bad XML block: node at 0x%x extends beyond data end 0x%x\n",
1667                     (int)(((const uint8_t*)node)-((const uint8_t*)mHeader)), (int)mSize);
1668             return BAD_TYPE;
1669         }
1670         ALOGW("Bad XML block: node at 0x%x header size 0x%x smaller than total size 0x%x\n",
1671                 (int)(((const uint8_t*)node)-((const uint8_t*)mHeader)),
1672                 (int)headerSize, (int)size);
1673         return BAD_TYPE;
1674     }
1675     ALOGW("Bad XML block: node at 0x%x header size 0x%x too small\n",
1676             (int)(((const uint8_t*)node)-((const uint8_t*)mHeader)),
1677             (int)headerSize);
1678     return BAD_TYPE;
1679 #endif
1680 }
1681
1682 // --------------------------------------------------------------------
1683 // --------------------------------------------------------------------
1684 // --------------------------------------------------------------------
1685
1686 void ResTable_config::copyFromDeviceNoSwap(const ResTable_config& o) {
1687     const size_t size = dtohl(o.size);
1688     if (size >= sizeof(ResTable_config)) {
1689         *this = o;
1690     } else {
1691         memcpy(this, &o, size);
1692         memset(((uint8_t*)this)+size, 0, sizeof(ResTable_config)-size);
1693     }
1694 }
1695
1696 /* static */ size_t unpackLanguageOrRegion(const char in[2], const char base,
1697         char out[4]) {
1698   if (in[0] & 0x80) {
1699       // The high bit is "1", which means this is a packed three letter
1700       // language code.
1701
1702       // The smallest 5 bits of the second char are the first alphabet.
1703       const uint8_t first = in[1] & 0x1f;
1704       // The last three bits of the second char and the first two bits
1705       // of the first char are the second alphabet.
1706       const uint8_t second = ((in[1] & 0xe0) >> 5) + ((in[0] & 0x03) << 3);
1707       // Bits 3 to 7 (inclusive) of the first char are the third alphabet.
1708       const uint8_t third = (in[0] & 0x7c) >> 2;
1709
1710       out[0] = first + base;
1711       out[1] = second + base;
1712       out[2] = third + base;
1713       out[3] = 0;
1714
1715       return 3;
1716   }
1717
1718   if (in[0]) {
1719       memcpy(out, in, 2);
1720       memset(out + 2, 0, 2);
1721       return 2;
1722   }
1723
1724   memset(out, 0, 4);
1725   return 0;
1726 }
1727
1728 /* static */ void packLanguageOrRegion(const char* in, const char base,
1729         char out[2]) {
1730   if (in[2] == 0 || in[2] == '-') {
1731       out[0] = in[0];
1732       out[1] = in[1];
1733   } else {
1734       uint8_t first = (in[0] - base) & 0x007f;
1735       uint8_t second = (in[1] - base) & 0x007f;
1736       uint8_t third = (in[2] - base) & 0x007f;
1737
1738       out[0] = (0x80 | (third << 2) | (second >> 3));
1739       out[1] = ((second << 5) | first);
1740   }
1741 }
1742
1743
1744 void ResTable_config::packLanguage(const char* language) {
1745     packLanguageOrRegion(language, 'a', this->language);
1746 }
1747
1748 void ResTable_config::packRegion(const char* region) {
1749     packLanguageOrRegion(region, '0', this->country);
1750 }
1751
1752 size_t ResTable_config::unpackLanguage(char language[4]) const {
1753     return unpackLanguageOrRegion(this->language, 'a', language);
1754 }
1755
1756 size_t ResTable_config::unpackRegion(char region[4]) const {
1757     return unpackLanguageOrRegion(this->country, '0', region);
1758 }
1759
1760
1761 void ResTable_config::copyFromDtoH(const ResTable_config& o) {
1762     copyFromDeviceNoSwap(o);
1763     size = sizeof(ResTable_config);
1764     mcc = dtohs(mcc);
1765     mnc = dtohs(mnc);
1766     density = dtohs(density);
1767     screenWidth = dtohs(screenWidth);
1768     screenHeight = dtohs(screenHeight);
1769     sdkVersion = dtohs(sdkVersion);
1770     minorVersion = dtohs(minorVersion);
1771     smallestScreenWidthDp = dtohs(smallestScreenWidthDp);
1772     screenWidthDp = dtohs(screenWidthDp);
1773     screenHeightDp = dtohs(screenHeightDp);
1774 }
1775
1776 void ResTable_config::swapHtoD() {
1777     size = htodl(size);
1778     mcc = htods(mcc);
1779     mnc = htods(mnc);
1780     density = htods(density);
1781     screenWidth = htods(screenWidth);
1782     screenHeight = htods(screenHeight);
1783     sdkVersion = htods(sdkVersion);
1784     minorVersion = htods(minorVersion);
1785     smallestScreenWidthDp = htods(smallestScreenWidthDp);
1786     screenWidthDp = htods(screenWidthDp);
1787     screenHeightDp = htods(screenHeightDp);
1788 }
1789
1790 /* static */ inline int compareLocales(const ResTable_config &l, const ResTable_config &r) {
1791     if (l.locale != r.locale) {
1792         // NOTE: This is the old behaviour with respect to comparison orders.
1793         // The diff value here doesn't make much sense (given our bit packing scheme)
1794         // but it's stable, and that's all we need.
1795         return l.locale - r.locale;
1796     }
1797
1798     // The language & region are equal, so compare the scripts and variants.
1799     int script = memcmp(l.localeScript, r.localeScript, sizeof(l.localeScript));
1800     if (script) {
1801         return script;
1802     }
1803
1804     // The language, region and script are equal, so compare variants.
1805     //
1806     // This should happen very infrequently (if at all.)
1807     return memcmp(l.localeVariant, r.localeVariant, sizeof(l.localeVariant));
1808 }
1809
1810 int ResTable_config::compare(const ResTable_config& o) const {
1811     int32_t diff = (int32_t)(imsi - o.imsi);
1812     if (diff != 0) return diff;
1813     diff = compareLocales(*this, o);
1814     if (diff != 0) return diff;
1815     diff = (int32_t)(screenType - o.screenType);
1816     if (diff != 0) return diff;
1817     diff = (int32_t)(input - o.input);
1818     if (diff != 0) return diff;
1819     diff = (int32_t)(screenSize - o.screenSize);
1820     if (diff != 0) return diff;
1821     diff = (int32_t)(version - o.version);
1822     if (diff != 0) return diff;
1823     diff = (int32_t)(screenLayout - o.screenLayout);
1824     if (diff != 0) return diff;
1825     diff = (int32_t)(uiMode - o.uiMode);
1826     if (diff != 0) return diff;
1827     diff = (int32_t)(smallestScreenWidthDp - o.smallestScreenWidthDp);
1828     if (diff != 0) return diff;
1829     diff = (int32_t)(screenSizeDp - o.screenSizeDp);
1830     return (int)diff;
1831 }
1832
1833 int ResTable_config::compareLogical(const ResTable_config& o) const {
1834     if (mcc != o.mcc) {
1835         return mcc < o.mcc ? -1 : 1;
1836     }
1837     if (mnc != o.mnc) {
1838         return mnc < o.mnc ? -1 : 1;
1839     }
1840
1841     int diff = compareLocales(*this, o);
1842     if (diff < 0) {
1843         return -1;
1844     }
1845     if (diff > 0) {
1846         return 1;
1847     }
1848
1849     if ((screenLayout & MASK_LAYOUTDIR) != (o.screenLayout & MASK_LAYOUTDIR)) {
1850         return (screenLayout & MASK_LAYOUTDIR) < (o.screenLayout & MASK_LAYOUTDIR) ? -1 : 1;
1851     }
1852     if (smallestScreenWidthDp != o.smallestScreenWidthDp) {
1853         return smallestScreenWidthDp < o.smallestScreenWidthDp ? -1 : 1;
1854     }
1855     if (screenWidthDp != o.screenWidthDp) {
1856         return screenWidthDp < o.screenWidthDp ? -1 : 1;
1857     }
1858     if (screenHeightDp != o.screenHeightDp) {
1859         return screenHeightDp < o.screenHeightDp ? -1 : 1;
1860     }
1861     if (screenWidth != o.screenWidth) {
1862         return screenWidth < o.screenWidth ? -1 : 1;
1863     }
1864     if (screenHeight != o.screenHeight) {
1865         return screenHeight < o.screenHeight ? -1 : 1;
1866     }
1867     if (density != o.density) {
1868         return density < o.density ? -1 : 1;
1869     }
1870     if (orientation != o.orientation) {
1871         return orientation < o.orientation ? -1 : 1;
1872     }
1873     if (touchscreen != o.touchscreen) {
1874         return touchscreen < o.touchscreen ? -1 : 1;
1875     }
1876     if (input != o.input) {
1877         return input < o.input ? -1 : 1;
1878     }
1879     if (screenLayout != o.screenLayout) {
1880         return screenLayout < o.screenLayout ? -1 : 1;
1881     }
1882     if (uiMode != o.uiMode) {
1883         return uiMode < o.uiMode ? -1 : 1;
1884     }
1885     if (version != o.version) {
1886         return version < o.version ? -1 : 1;
1887     }
1888     return 0;
1889 }
1890
1891 int ResTable_config::diff(const ResTable_config& o) const {
1892     int diffs = 0;
1893     if (mcc != o.mcc) diffs |= CONFIG_MCC;
1894     if (mnc != o.mnc) diffs |= CONFIG_MNC;
1895     if (orientation != o.orientation) diffs |= CONFIG_ORIENTATION;
1896     if (density != o.density) diffs |= CONFIG_DENSITY;
1897     if (touchscreen != o.touchscreen) diffs |= CONFIG_TOUCHSCREEN;
1898     if (((inputFlags^o.inputFlags)&(MASK_KEYSHIDDEN|MASK_NAVHIDDEN)) != 0)
1899             diffs |= CONFIG_KEYBOARD_HIDDEN;
1900     if (keyboard != o.keyboard) diffs |= CONFIG_KEYBOARD;
1901     if (navigation != o.navigation) diffs |= CONFIG_NAVIGATION;
1902     if (screenSize != o.screenSize) diffs |= CONFIG_SCREEN_SIZE;
1903     if (version != o.version) diffs |= CONFIG_VERSION;
1904     if ((screenLayout & MASK_LAYOUTDIR) != (o.screenLayout & MASK_LAYOUTDIR)) diffs |= CONFIG_LAYOUTDIR;
1905     if ((screenLayout & ~MASK_LAYOUTDIR) != (o.screenLayout & ~MASK_LAYOUTDIR)) diffs |= CONFIG_SCREEN_LAYOUT;
1906     if (uiMode != o.uiMode) diffs |= CONFIG_UI_MODE;
1907     if (smallestScreenWidthDp != o.smallestScreenWidthDp) diffs |= CONFIG_SMALLEST_SCREEN_SIZE;
1908     if (screenSizeDp != o.screenSizeDp) diffs |= CONFIG_SCREEN_SIZE;
1909
1910     const int diff = compareLocales(*this, o);
1911     if (diff) diffs |= CONFIG_LOCALE;
1912
1913     return diffs;
1914 }
1915
1916 int ResTable_config::isLocaleMoreSpecificThan(const ResTable_config& o) const {
1917     if (locale || o.locale) {
1918         if (language[0] != o.language[0]) {
1919             if (!language[0]) return -1;
1920             if (!o.language[0]) return 1;
1921         }
1922
1923         if (country[0] != o.country[0]) {
1924             if (!country[0]) return -1;
1925             if (!o.country[0]) return 1;
1926         }
1927     }
1928
1929     // There isn't a well specified "importance" order between variants and
1930     // scripts. We can't easily tell whether, say "en-Latn-US" is more or less
1931     // specific than "en-US-POSIX".
1932     //
1933     // We therefore arbitrarily decide to give priority to variants over
1934     // scripts since it seems more useful to do so. We will consider
1935     // "en-US-POSIX" to be more specific than "en-Latn-US".
1936
1937     const int score = ((localeScript[0] != 0) ? 1 : 0) +
1938         ((localeVariant[0] != 0) ? 2 : 0);
1939
1940     const int oScore = ((o.localeScript[0] != 0) ? 1 : 0) +
1941         ((o.localeVariant[0] != 0) ? 2 : 0);
1942
1943     return score - oScore;
1944
1945 }
1946
1947 bool ResTable_config::isMoreSpecificThan(const ResTable_config& o) const {
1948     // The order of the following tests defines the importance of one
1949     // configuration parameter over another.  Those tests first are more
1950     // important, trumping any values in those following them.
1951     if (imsi || o.imsi) {
1952         if (mcc != o.mcc) {
1953             if (!mcc) return false;
1954             if (!o.mcc) return true;
1955         }
1956
1957         if (mnc != o.mnc) {
1958             if (!mnc) return false;
1959             if (!o.mnc) return true;
1960         }
1961     }
1962
1963     if (locale || o.locale) {
1964         const int diff = isLocaleMoreSpecificThan(o);
1965         if (diff < 0) {
1966             return false;
1967         }
1968
1969         if (diff > 0) {
1970             return true;
1971         }
1972     }
1973
1974     if (screenLayout || o.screenLayout) {
1975         if (((screenLayout^o.screenLayout) & MASK_LAYOUTDIR) != 0) {
1976             if (!(screenLayout & MASK_LAYOUTDIR)) return false;
1977             if (!(o.screenLayout & MASK_LAYOUTDIR)) return true;
1978         }
1979     }
1980
1981     if (smallestScreenWidthDp || o.smallestScreenWidthDp) {
1982         if (smallestScreenWidthDp != o.smallestScreenWidthDp) {
1983             if (!smallestScreenWidthDp) return false;
1984             if (!o.smallestScreenWidthDp) return true;
1985         }
1986     }
1987
1988     if (screenSizeDp || o.screenSizeDp) {
1989         if (screenWidthDp != o.screenWidthDp) {
1990             if (!screenWidthDp) return false;
1991             if (!o.screenWidthDp) return true;
1992         }
1993
1994         if (screenHeightDp != o.screenHeightDp) {
1995             if (!screenHeightDp) return false;
1996             if (!o.screenHeightDp) return true;
1997         }
1998     }
1999
2000     if (screenLayout || o.screenLayout) {
2001         if (((screenLayout^o.screenLayout) & MASK_SCREENSIZE) != 0) {
2002             if (!(screenLayout & MASK_SCREENSIZE)) return false;
2003             if (!(o.screenLayout & MASK_SCREENSIZE)) return true;
2004         }
2005         if (((screenLayout^o.screenLayout) & MASK_SCREENLONG) != 0) {
2006             if (!(screenLayout & MASK_SCREENLONG)) return false;
2007             if (!(o.screenLayout & MASK_SCREENLONG)) return true;
2008         }
2009     }
2010
2011     if (orientation != o.orientation) {
2012         if (!orientation) return false;
2013         if (!o.orientation) return true;
2014     }
2015
2016     if (uiMode || o.uiMode) {
2017         if (((uiMode^o.uiMode) & MASK_UI_MODE_TYPE) != 0) {
2018             if (!(uiMode & MASK_UI_MODE_TYPE)) return false;
2019             if (!(o.uiMode & MASK_UI_MODE_TYPE)) return true;
2020         }
2021         if (((uiMode^o.uiMode) & MASK_UI_MODE_NIGHT) != 0) {
2022             if (!(uiMode & MASK_UI_MODE_NIGHT)) return false;
2023             if (!(o.uiMode & MASK_UI_MODE_NIGHT)) return true;
2024         }
2025     }
2026
2027     // density is never 'more specific'
2028     // as the default just equals 160
2029
2030     if (touchscreen != o.touchscreen) {
2031         if (!touchscreen) return false;
2032         if (!o.touchscreen) return true;
2033     }
2034
2035     if (input || o.input) {
2036         if (((inputFlags^o.inputFlags) & MASK_KEYSHIDDEN) != 0) {
2037             if (!(inputFlags & MASK_KEYSHIDDEN)) return false;
2038             if (!(o.inputFlags & MASK_KEYSHIDDEN)) return true;
2039         }
2040
2041         if (((inputFlags^o.inputFlags) & MASK_NAVHIDDEN) != 0) {
2042             if (!(inputFlags & MASK_NAVHIDDEN)) return false;
2043             if (!(o.inputFlags & MASK_NAVHIDDEN)) return true;
2044         }
2045
2046         if (keyboard != o.keyboard) {
2047             if (!keyboard) return false;
2048             if (!o.keyboard) return true;
2049         }
2050
2051         if (navigation != o.navigation) {
2052             if (!navigation) return false;
2053             if (!o.navigation) return true;
2054         }
2055     }
2056
2057     if (screenSize || o.screenSize) {
2058         if (screenWidth != o.screenWidth) {
2059             if (!screenWidth) return false;
2060             if (!o.screenWidth) return true;
2061         }
2062
2063         if (screenHeight != o.screenHeight) {
2064             if (!screenHeight) return false;
2065             if (!o.screenHeight) return true;
2066         }
2067     }
2068
2069     if (version || o.version) {
2070         if (sdkVersion != o.sdkVersion) {
2071             if (!sdkVersion) return false;
2072             if (!o.sdkVersion) return true;
2073         }
2074
2075         if (minorVersion != o.minorVersion) {
2076             if (!minorVersion) return false;
2077             if (!o.minorVersion) return true;
2078         }
2079     }
2080     return false;
2081 }
2082
2083 bool ResTable_config::isBetterThan(const ResTable_config& o,
2084         const ResTable_config* requested) const {
2085     if (requested) {
2086         if (imsi || o.imsi) {
2087             if ((mcc != o.mcc) && requested->mcc) {
2088                 return (mcc);
2089             }
2090
2091             if ((mnc != o.mnc) && requested->mnc) {
2092                 return (mnc);
2093             }
2094         }
2095
2096         if (locale || o.locale) {
2097             if ((language[0] != o.language[0]) && requested->language[0]) {
2098                 return (language[0]);
2099             }
2100
2101             if ((country[0] != o.country[0]) && requested->country[0]) {
2102                 return (country[0]);
2103             }
2104         }
2105
2106         if (localeScript[0] || o.localeScript[0]) {
2107             if (localeScript[0] != o.localeScript[0] && requested->localeScript[0]) {
2108                 return localeScript[0];
2109             }
2110         }
2111
2112         if (localeVariant[0] || o.localeVariant[0]) {
2113             if (localeVariant[0] != o.localeVariant[0] && requested->localeVariant[0]) {
2114                 return localeVariant[0];
2115             }
2116         }
2117
2118         if (screenLayout || o.screenLayout) {
2119             if (((screenLayout^o.screenLayout) & MASK_LAYOUTDIR) != 0
2120                     && (requested->screenLayout & MASK_LAYOUTDIR)) {
2121                 int myLayoutDir = screenLayout & MASK_LAYOUTDIR;
2122                 int oLayoutDir = o.screenLayout & MASK_LAYOUTDIR;
2123                 return (myLayoutDir > oLayoutDir);
2124             }
2125         }
2126
2127         if (smallestScreenWidthDp || o.smallestScreenWidthDp) {
2128             // The configuration closest to the actual size is best.
2129             // We assume that larger configs have already been filtered
2130             // out at this point.  That means we just want the largest one.
2131             if (smallestScreenWidthDp != o.smallestScreenWidthDp) {
2132                 return smallestScreenWidthDp > o.smallestScreenWidthDp;
2133             }
2134         }
2135
2136         if (screenSizeDp || o.screenSizeDp) {
2137             // "Better" is based on the sum of the difference between both
2138             // width and height from the requested dimensions.  We are
2139             // assuming the invalid configs (with smaller dimens) have
2140             // already been filtered.  Note that if a particular dimension
2141             // is unspecified, we will end up with a large value (the
2142             // difference between 0 and the requested dimension), which is
2143             // good since we will prefer a config that has specified a
2144             // dimension value.
2145             int myDelta = 0, otherDelta = 0;
2146             if (requested->screenWidthDp) {
2147                 myDelta += requested->screenWidthDp - screenWidthDp;
2148                 otherDelta += requested->screenWidthDp - o.screenWidthDp;
2149             }
2150             if (requested->screenHeightDp) {
2151                 myDelta += requested->screenHeightDp - screenHeightDp;
2152                 otherDelta += requested->screenHeightDp - o.screenHeightDp;
2153             }
2154             //ALOGI("Comparing this %dx%d to other %dx%d in %dx%d: myDelta=%d otherDelta=%d",
2155             //    screenWidthDp, screenHeightDp, o.screenWidthDp, o.screenHeightDp,
2156             //    requested->screenWidthDp, requested->screenHeightDp, myDelta, otherDelta);
2157             if (myDelta != otherDelta) {
2158                 return myDelta < otherDelta;
2159             }
2160         }
2161
2162         if (screenLayout || o.screenLayout) {
2163             if (((screenLayout^o.screenLayout) & MASK_SCREENSIZE) != 0
2164                     && (requested->screenLayout & MASK_SCREENSIZE)) {
2165                 // A little backwards compatibility here: undefined is
2166                 // considered equivalent to normal.  But only if the
2167                 // requested size is at least normal; otherwise, small
2168                 // is better than the default.
2169                 int mySL = (screenLayout & MASK_SCREENSIZE);
2170                 int oSL = (o.screenLayout & MASK_SCREENSIZE);
2171                 int fixedMySL = mySL;
2172                 int fixedOSL = oSL;
2173                 if ((requested->screenLayout & MASK_SCREENSIZE) >= SCREENSIZE_NORMAL) {
2174                     if (fixedMySL == 0) fixedMySL = SCREENSIZE_NORMAL;
2175                     if (fixedOSL == 0) fixedOSL = SCREENSIZE_NORMAL;
2176                 }
2177                 // For screen size, the best match is the one that is
2178                 // closest to the requested screen size, but not over
2179                 // (the not over part is dealt with in match() below).
2180                 if (fixedMySL == fixedOSL) {
2181                     // If the two are the same, but 'this' is actually
2182                     // undefined, then the other is really a better match.
2183                     if (mySL == 0) return false;
2184                     return true;
2185                 }
2186                 if (fixedMySL != fixedOSL) {
2187                     return fixedMySL > fixedOSL;
2188                 }
2189             }
2190             if (((screenLayout^o.screenLayout) & MASK_SCREENLONG) != 0
2191                     && (requested->screenLayout & MASK_SCREENLONG)) {
2192                 return (screenLayout & MASK_SCREENLONG);
2193             }
2194         }
2195
2196         if ((orientation != o.orientation) && requested->orientation) {
2197             return (orientation);
2198         }
2199
2200         if (uiMode || o.uiMode) {
2201             if (((uiMode^o.uiMode) & MASK_UI_MODE_TYPE) != 0
2202                     && (requested->uiMode & MASK_UI_MODE_TYPE)) {
2203                 return (uiMode & MASK_UI_MODE_TYPE);
2204             }
2205             if (((uiMode^o.uiMode) & MASK_UI_MODE_NIGHT) != 0
2206                     && (requested->uiMode & MASK_UI_MODE_NIGHT)) {
2207                 return (uiMode & MASK_UI_MODE_NIGHT);
2208             }
2209         }
2210
2211         if (screenType || o.screenType) {
2212             if (density != o.density) {
2213                 // Use the system default density (DENSITY_MEDIUM, 160dpi) if none specified.
2214                 const int thisDensity = density ? density : int(ResTable_config::DENSITY_MEDIUM);
2215                 const int otherDensity = o.density ? o.density : int(ResTable_config::DENSITY_MEDIUM);
2216
2217                 // We always prefer DENSITY_ANY over scaling a density bucket.
2218                 if (thisDensity == ResTable_config::DENSITY_ANY) {
2219                     return true;
2220                 } else if (otherDensity == ResTable_config::DENSITY_ANY) {
2221                     return false;
2222                 }
2223
2224                 int requestedDensity = requested->density;
2225                 if (requested->density == 0 ||
2226                         requested->density == ResTable_config::DENSITY_ANY) {
2227                     requestedDensity = ResTable_config::DENSITY_MEDIUM;
2228                 }
2229
2230                 // DENSITY_ANY is now dealt with. We should look to
2231                 // pick a density bucket and potentially scale it.
2232                 // Any density is potentially useful
2233                 // because the system will scale it.  Scaling down
2234                 // is generally better than scaling up.
2235                 int h = thisDensity;
2236                 int l = otherDensity;
2237                 bool bImBigger = true;
2238                 if (l > h) {
2239                     int t = h;
2240                     h = l;
2241                     l = t;
2242                     bImBigger = false;
2243                 }
2244
2245                 if (requestedDensity >= h) {
2246                     // requested value higher than both l and h, give h
2247                     return bImBigger;
2248                 }
2249                 if (l >= requestedDensity) {
2250                     // requested value lower than both l and h, give l
2251                     return !bImBigger;
2252                 }
2253                 // saying that scaling down is 2x better than up
2254                 if (((2 * l) - requestedDensity) * h > requestedDensity * requestedDensity) {
2255                     return !bImBigger;
2256                 } else {
2257                     return bImBigger;
2258                 }
2259             }
2260
2261             if ((touchscreen != o.touchscreen) && requested->touchscreen) {
2262                 return (touchscreen);
2263             }
2264         }
2265
2266         if (input || o.input) {
2267             const int keysHidden = inputFlags & MASK_KEYSHIDDEN;
2268             const int oKeysHidden = o.inputFlags & MASK_KEYSHIDDEN;
2269             if (keysHidden != oKeysHidden) {
2270                 const int reqKeysHidden =
2271                         requested->inputFlags & MASK_KEYSHIDDEN;
2272                 if (reqKeysHidden) {
2273
2274                     if (!keysHidden) return false;
2275                     if (!oKeysHidden) return true;
2276                     // For compatibility, we count KEYSHIDDEN_NO as being
2277                     // the same as KEYSHIDDEN_SOFT.  Here we disambiguate
2278                     // these by making an exact match more specific.
2279                     if (reqKeysHidden == keysHidden) return true;
2280                     if (reqKeysHidden == oKeysHidden) return false;
2281                 }
2282             }
2283
2284             const int navHidden = inputFlags & MASK_NAVHIDDEN;
2285             const int oNavHidden = o.inputFlags & MASK_NAVHIDDEN;
2286             if (navHidden != oNavHidden) {
2287                 const int reqNavHidden =
2288                         requested->inputFlags & MASK_NAVHIDDEN;
2289                 if (reqNavHidden) {
2290
2291                     if (!navHidden) return false;
2292                     if (!oNavHidden) return true;
2293                 }
2294             }
2295
2296             if ((keyboard != o.keyboard) && requested->keyboard) {
2297                 return (keyboard);
2298             }
2299
2300             if ((navigation != o.navigation) && requested->navigation) {
2301                 return (navigation);
2302             }
2303         }
2304
2305         if (screenSize || o.screenSize) {
2306             // "Better" is based on the sum of the difference between both
2307             // width and height from the requested dimensions.  We are
2308             // assuming the invalid configs (with smaller sizes) have
2309             // already been filtered.  Note that if a particular dimension
2310             // is unspecified, we will end up with a large value (the
2311             // difference between 0 and the requested dimension), which is
2312             // good since we will prefer a config that has specified a
2313             // size value.
2314             int myDelta = 0, otherDelta = 0;
2315             if (requested->screenWidth) {
2316                 myDelta += requested->screenWidth - screenWidth;
2317                 otherDelta += requested->screenWidth - o.screenWidth;
2318             }
2319             if (requested->screenHeight) {
2320                 myDelta += requested->screenHeight - screenHeight;
2321                 otherDelta += requested->screenHeight - o.screenHeight;
2322             }
2323             if (myDelta != otherDelta) {
2324                 return myDelta < otherDelta;
2325             }
2326         }
2327
2328         if (version || o.version) {
2329             if ((sdkVersion != o.sdkVersion) && requested->sdkVersion) {
2330                 return (sdkVersion > o.sdkVersion);
2331             }
2332
2333             if ((minorVersion != o.minorVersion) &&
2334                     requested->minorVersion) {
2335                 return (minorVersion);
2336             }
2337         }
2338
2339         return false;
2340     }
2341     return isMoreSpecificThan(o);
2342 }
2343
2344 bool ResTable_config::match(const ResTable_config& settings) const {
2345     if (imsi != 0) {
2346         if (mcc != 0 && mcc != settings.mcc) {
2347             return false;
2348         }
2349         if (mnc != 0 && mnc != settings.mnc) {
2350             return false;
2351         }
2352     }
2353     if (locale != 0) {
2354         // Don't consider the script & variants when deciding matches.
2355         //
2356         // If we two configs differ only in their script or language, they
2357         // can be weeded out in the isMoreSpecificThan test.
2358         if (language[0] != 0
2359             && (language[0] != settings.language[0]
2360                 || language[1] != settings.language[1])) {
2361             return false;
2362         }
2363
2364         if (country[0] != 0
2365             && (country[0] != settings.country[0]
2366                 || country[1] != settings.country[1])) {
2367             return false;
2368         }
2369     }
2370
2371     if (screenConfig != 0) {
2372         const int layoutDir = screenLayout&MASK_LAYOUTDIR;
2373         const int setLayoutDir = settings.screenLayout&MASK_LAYOUTDIR;
2374         if (layoutDir != 0 && layoutDir != setLayoutDir) {
2375             return false;
2376         }
2377
2378         const int screenSize = screenLayout&MASK_SCREENSIZE;
2379         const int setScreenSize = settings.screenLayout&MASK_SCREENSIZE;
2380         // Any screen sizes for larger screens than the setting do not
2381         // match.
2382         if (screenSize != 0 && screenSize > setScreenSize) {
2383             return false;
2384         }
2385
2386         const int screenLong = screenLayout&MASK_SCREENLONG;
2387         const int setScreenLong = settings.screenLayout&MASK_SCREENLONG;
2388         if (screenLong != 0 && screenLong != setScreenLong) {
2389             return false;
2390         }
2391
2392         const int uiModeType = uiMode&MASK_UI_MODE_TYPE;
2393         const int setUiModeType = settings.uiMode&MASK_UI_MODE_TYPE;
2394         if (uiModeType != 0 && uiModeType != setUiModeType) {
2395             return false;
2396         }
2397
2398         const int uiModeNight = uiMode&MASK_UI_MODE_NIGHT;
2399         const int setUiModeNight = settings.uiMode&MASK_UI_MODE_NIGHT;
2400         if (uiModeNight != 0 && uiModeNight != setUiModeNight) {
2401             return false;
2402         }
2403
2404         if (smallestScreenWidthDp != 0
2405                 && smallestScreenWidthDp > settings.smallestScreenWidthDp) {
2406             return false;
2407         }
2408     }
2409     if (screenSizeDp != 0) {
2410         if (screenWidthDp != 0 && screenWidthDp > settings.screenWidthDp) {
2411             //ALOGI("Filtering out width %d in requested %d", screenWidthDp, settings.screenWidthDp);
2412             return false;
2413         }
2414         if (screenHeightDp != 0 && screenHeightDp > settings.screenHeightDp) {
2415             //ALOGI("Filtering out height %d in requested %d", screenHeightDp, settings.screenHeightDp);
2416             return false;
2417         }
2418     }
2419     if (screenType != 0) {
2420         if (orientation != 0 && orientation != settings.orientation) {
2421             return false;
2422         }
2423         // density always matches - we can scale it.  See isBetterThan
2424         if (touchscreen != 0 && touchscreen != settings.touchscreen) {
2425             return false;
2426         }
2427     }
2428     if (input != 0) {
2429         const int keysHidden = inputFlags&MASK_KEYSHIDDEN;
2430         const int setKeysHidden = settings.inputFlags&MASK_KEYSHIDDEN;
2431         if (keysHidden != 0 && keysHidden != setKeysHidden) {
2432             // For compatibility, we count a request for KEYSHIDDEN_NO as also
2433             // matching the more recent KEYSHIDDEN_SOFT.  Basically
2434             // KEYSHIDDEN_NO means there is some kind of keyboard available.
2435             //ALOGI("Matching keysHidden: have=%d, config=%d\n", keysHidden, setKeysHidden);
2436             if (keysHidden != KEYSHIDDEN_NO || setKeysHidden != KEYSHIDDEN_SOFT) {
2437                 //ALOGI("No match!");
2438                 return false;
2439             }
2440         }
2441         const int navHidden = inputFlags&MASK_NAVHIDDEN;
2442         const int setNavHidden = settings.inputFlags&MASK_NAVHIDDEN;
2443         if (navHidden != 0 && navHidden != setNavHidden) {
2444             return false;
2445         }
2446         if (keyboard != 0 && keyboard != settings.keyboard) {
2447             return false;
2448         }
2449         if (navigation != 0 && navigation != settings.navigation) {
2450             return false;
2451         }
2452     }
2453     if (screenSize != 0) {
2454         if (screenWidth != 0 && screenWidth > settings.screenWidth) {
2455             return false;
2456         }
2457         if (screenHeight != 0 && screenHeight > settings.screenHeight) {
2458             return false;
2459         }
2460     }
2461     if (version != 0) {
2462         if (sdkVersion != 0 && sdkVersion > settings.sdkVersion) {
2463             return false;
2464         }
2465         if (minorVersion != 0 && minorVersion != settings.minorVersion) {
2466             return false;
2467         }
2468     }
2469     return true;
2470 }
2471
2472 void ResTable_config::getBcp47Locale(char str[RESTABLE_MAX_LOCALE_LEN]) const {
2473     memset(str, 0, RESTABLE_MAX_LOCALE_LEN);
2474
2475     // This represents the "any" locale value, which has traditionally been
2476     // represented by the empty string.
2477     if (!language[0] && !country[0]) {
2478         return;
2479     }
2480
2481     size_t charsWritten = 0;
2482     if (language[0]) {
2483         charsWritten += unpackLanguage(str);
2484     }
2485
2486     if (localeScript[0]) {
2487         if (charsWritten) {
2488             str[charsWritten++] = '-';
2489         }
2490         memcpy(str + charsWritten, localeScript, sizeof(localeScript));
2491         charsWritten += sizeof(localeScript);
2492     }
2493
2494     if (country[0]) {
2495         if (charsWritten) {
2496             str[charsWritten++] = '-';
2497         }
2498         charsWritten += unpackRegion(str + charsWritten);
2499     }
2500
2501     if (localeVariant[0]) {
2502         if (charsWritten) {
2503             str[charsWritten++] = '-';
2504         }
2505         memcpy(str + charsWritten, localeVariant, sizeof(localeVariant));
2506     }
2507 }
2508
2509 /* static */ inline bool assignLocaleComponent(ResTable_config* config,
2510         const char* start, size_t size) {
2511
2512   switch (size) {
2513        case 0:
2514            return false;
2515        case 2:
2516        case 3:
2517            config->language[0] ? config->packRegion(start) : config->packLanguage(start);
2518            break;
2519        case 4:
2520            config->localeScript[0] = toupper(start[0]);
2521            for (size_t i = 1; i < 4; ++i) {
2522                config->localeScript[i] = tolower(start[i]);
2523            }
2524            break;
2525        case 5:
2526        case 6:
2527        case 7:
2528        case 8:
2529            for (size_t i = 0; i < size; ++i) {
2530                config->localeVariant[i] = tolower(start[i]);
2531            }
2532            break;
2533        default:
2534            return false;
2535   }
2536
2537   return true;
2538 }
2539
2540 void ResTable_config::setBcp47Locale(const char* in) {
2541     locale = 0;
2542     memset(localeScript, 0, sizeof(localeScript));
2543     memset(localeVariant, 0, sizeof(localeVariant));
2544
2545     const char* separator = in;
2546     const char* start = in;
2547     while ((separator = strchr(start, '-')) != NULL) {
2548         const size_t size = separator - start;
2549         if (!assignLocaleComponent(this, start, size)) {
2550             fprintf(stderr, "Invalid BCP-47 locale string: %s", in);
2551         }
2552
2553         start = (separator + 1);
2554     }
2555
2556     const size_t size = in + strlen(in) - start;
2557     assignLocaleComponent(this, start, size);
2558 }
2559
2560 String8 ResTable_config::toString() const {
2561     String8 res;
2562
2563     if (mcc != 0) {
2564         if (res.size() > 0) res.append("-");
2565         res.appendFormat("mcc%d", dtohs(mcc));
2566     }
2567     if (mnc != 0) {
2568         if (res.size() > 0) res.append("-");
2569         res.appendFormat("mnc%d", dtohs(mnc));
2570     }
2571
2572     char localeStr[RESTABLE_MAX_LOCALE_LEN];
2573     getBcp47Locale(localeStr);
2574     if (strlen(localeStr) > 0) {
2575         if (res.size() > 0) res.append("-");
2576         res.append(localeStr);
2577     }
2578
2579     if ((screenLayout&MASK_LAYOUTDIR) != 0) {
2580         if (res.size() > 0) res.append("-");
2581         switch (screenLayout&ResTable_config::MASK_LAYOUTDIR) {
2582             case ResTable_config::LAYOUTDIR_LTR:
2583                 res.append("ldltr");
2584                 break;
2585             case ResTable_config::LAYOUTDIR_RTL:
2586                 res.append("ldrtl");
2587                 break;
2588             default:
2589                 res.appendFormat("layoutDir=%d",
2590                         dtohs(screenLayout&ResTable_config::MASK_LAYOUTDIR));
2591                 break;
2592         }
2593     }
2594     if (smallestScreenWidthDp != 0) {
2595         if (res.size() > 0) res.append("-");
2596         res.appendFormat("sw%ddp", dtohs(smallestScreenWidthDp));
2597     }
2598     if (screenWidthDp != 0) {
2599         if (res.size() > 0) res.append("-");
2600         res.appendFormat("w%ddp", dtohs(screenWidthDp));
2601     }
2602     if (screenHeightDp != 0) {
2603         if (res.size() > 0) res.append("-");
2604         res.appendFormat("h%ddp", dtohs(screenHeightDp));
2605     }
2606     if ((screenLayout&MASK_SCREENSIZE) != SCREENSIZE_ANY) {
2607         if (res.size() > 0) res.append("-");
2608         switch (screenLayout&ResTable_config::MASK_SCREENSIZE) {
2609             case ResTable_config::SCREENSIZE_SMALL:
2610                 res.append("small");
2611                 break;
2612             case ResTable_config::SCREENSIZE_NORMAL:
2613                 res.append("normal");
2614                 break;
2615             case ResTable_config::SCREENSIZE_LARGE:
2616                 res.append("large");
2617                 break;
2618             case ResTable_config::SCREENSIZE_XLARGE:
2619                 res.append("xlarge");
2620                 break;
2621             default:
2622                 res.appendFormat("screenLayoutSize=%d",
2623                         dtohs(screenLayout&ResTable_config::MASK_SCREENSIZE));
2624                 break;
2625         }
2626     }
2627     if ((screenLayout&MASK_SCREENLONG) != 0) {
2628         if (res.size() > 0) res.append("-");
2629         switch (screenLayout&ResTable_config::MASK_SCREENLONG) {
2630             case ResTable_config::SCREENLONG_NO:
2631                 res.append("notlong");
2632                 break;
2633             case ResTable_config::SCREENLONG_YES:
2634                 res.append("long");
2635                 break;
2636             default:
2637                 res.appendFormat("screenLayoutLong=%d",
2638                         dtohs(screenLayout&ResTable_config::MASK_SCREENLONG));
2639                 break;
2640         }
2641     }
2642     if (orientation != ORIENTATION_ANY) {
2643         if (res.size() > 0) res.append("-");
2644         switch (orientation) {
2645             case ResTable_config::ORIENTATION_PORT:
2646                 res.append("port");
2647                 break;
2648             case ResTable_config::ORIENTATION_LAND:
2649                 res.append("land");
2650                 break;
2651             case ResTable_config::ORIENTATION_SQUARE:
2652                 res.append("square");
2653                 break;
2654             default:
2655                 res.appendFormat("orientation=%d", dtohs(orientation));
2656                 break;
2657         }
2658     }
2659     if ((uiMode&MASK_UI_MODE_TYPE) != UI_MODE_TYPE_ANY) {
2660         if (res.size() > 0) res.append("-");
2661         switch (uiMode&ResTable_config::MASK_UI_MODE_TYPE) {
2662             case ResTable_config::UI_MODE_TYPE_DESK:
2663                 res.append("desk");
2664                 break;
2665             case ResTable_config::UI_MODE_TYPE_CAR:
2666                 res.append("car");
2667                 break;
2668             case ResTable_config::UI_MODE_TYPE_TELEVISION:
2669                 res.append("television");
2670                 break;
2671             case ResTable_config::UI_MODE_TYPE_APPLIANCE:
2672                 res.append("appliance");
2673                 break;
2674             case ResTable_config::UI_MODE_TYPE_WATCH:
2675                 res.append("watch");
2676                 break;
2677             default:
2678                 res.appendFormat("uiModeType=%d",
2679                         dtohs(screenLayout&ResTable_config::MASK_UI_MODE_TYPE));
2680                 break;
2681         }
2682     }
2683     if ((uiMode&MASK_UI_MODE_NIGHT) != 0) {
2684         if (res.size() > 0) res.append("-");
2685         switch (uiMode&ResTable_config::MASK_UI_MODE_NIGHT) {
2686             case ResTable_config::UI_MODE_NIGHT_NO:
2687                 res.append("notnight");
2688                 break;
2689             case ResTable_config::UI_MODE_NIGHT_YES:
2690                 res.append("night");
2691                 break;
2692             default:
2693                 res.appendFormat("uiModeNight=%d",
2694                         dtohs(uiMode&MASK_UI_MODE_NIGHT));
2695                 break;
2696         }
2697     }
2698     if (density != DENSITY_DEFAULT) {
2699         if (res.size() > 0) res.append("-");
2700         switch (density) {
2701             case ResTable_config::DENSITY_LOW:
2702                 res.append("ldpi");
2703                 break;
2704             case ResTable_config::DENSITY_MEDIUM:
2705                 res.append("mdpi");
2706                 break;
2707             case ResTable_config::DENSITY_TV:
2708                 res.append("tvdpi");
2709                 break;
2710             case ResTable_config::DENSITY_HIGH:
2711                 res.append("hdpi");
2712                 break;
2713             case ResTable_config::DENSITY_XHIGH:
2714                 res.append("xhdpi");
2715                 break;
2716             case ResTable_config::DENSITY_XXHIGH:
2717                 res.append("xxhdpi");
2718                 break;
2719             case ResTable_config::DENSITY_XXXHIGH:
2720                 res.append("xxxhdpi");
2721                 break;
2722             case ResTable_config::DENSITY_NONE:
2723                 res.append("nodpi");
2724                 break;
2725             case ResTable_config::DENSITY_ANY:
2726                 res.append("anydpi");
2727                 break;
2728             default:
2729                 res.appendFormat("%ddpi", dtohs(density));
2730                 break;
2731         }
2732     }
2733     if (touchscreen != TOUCHSCREEN_ANY) {
2734         if (res.size() > 0) res.append("-");
2735         switch (touchscreen) {
2736             case ResTable_config::TOUCHSCREEN_NOTOUCH:
2737                 res.append("notouch");
2738                 break;
2739             case ResTable_config::TOUCHSCREEN_FINGER:
2740                 res.append("finger");
2741                 break;
2742             case ResTable_config::TOUCHSCREEN_STYLUS:
2743                 res.append("stylus");
2744                 break;
2745             default:
2746                 res.appendFormat("touchscreen=%d", dtohs(touchscreen));
2747                 break;
2748         }
2749     }
2750     if ((inputFlags&MASK_KEYSHIDDEN) != 0) {
2751         if (res.size() > 0) res.append("-");
2752         switch (inputFlags&MASK_KEYSHIDDEN) {
2753             case ResTable_config::KEYSHIDDEN_NO:
2754                 res.append("keysexposed");
2755                 break;
2756             case ResTable_config::KEYSHIDDEN_YES:
2757                 res.append("keyshidden");
2758                 break;
2759             case ResTable_config::KEYSHIDDEN_SOFT:
2760                 res.append("keyssoft");
2761                 break;
2762         }
2763     }
2764     if (keyboard != KEYBOARD_ANY) {
2765         if (res.size() > 0) res.append("-");
2766         switch (keyboard) {
2767             case ResTable_config::KEYBOARD_NOKEYS:
2768                 res.append("nokeys");
2769                 break;
2770             case ResTable_config::KEYBOARD_QWERTY:
2771                 res.append("qwerty");
2772                 break;
2773             case ResTable_config::KEYBOARD_12KEY:
2774                 res.append("12key");
2775                 break;
2776             default:
2777                 res.appendFormat("keyboard=%d", dtohs(keyboard));
2778                 break;
2779         }
2780     }
2781     if ((inputFlags&MASK_NAVHIDDEN) != 0) {
2782         if (res.size() > 0) res.append("-");
2783         switch (inputFlags&MASK_NAVHIDDEN) {
2784             case ResTable_config::NAVHIDDEN_NO:
2785                 res.append("navexposed");
2786                 break;
2787             case ResTable_config::NAVHIDDEN_YES:
2788                 res.append("navhidden");
2789                 break;
2790             default:
2791                 res.appendFormat("inputFlagsNavHidden=%d",
2792                         dtohs(inputFlags&MASK_NAVHIDDEN));
2793                 break;
2794         }
2795     }
2796     if (navigation != NAVIGATION_ANY) {
2797         if (res.size() > 0) res.append("-");
2798         switch (navigation) {
2799             case ResTable_config::NAVIGATION_NONAV:
2800                 res.append("nonav");
2801                 break;
2802             case ResTable_config::NAVIGATION_DPAD:
2803                 res.append("dpad");
2804                 break;
2805             case ResTable_config::NAVIGATION_TRACKBALL:
2806                 res.append("trackball");
2807                 break;
2808             case ResTable_config::NAVIGATION_WHEEL:
2809                 res.append("wheel");
2810                 break;
2811             default:
2812                 res.appendFormat("navigation=%d", dtohs(navigation));
2813                 break;
2814         }
2815     }
2816     if (screenSize != 0) {
2817         if (res.size() > 0) res.append("-");
2818         res.appendFormat("%dx%d", dtohs(screenWidth), dtohs(screenHeight));
2819     }
2820     if (version != 0) {
2821         if (res.size() > 0) res.append("-");
2822         res.appendFormat("v%d", dtohs(sdkVersion));
2823         if (minorVersion != 0) {
2824             res.appendFormat(".%d", dtohs(minorVersion));
2825         }
2826     }
2827
2828     return res;
2829 }
2830
2831 // --------------------------------------------------------------------
2832 // --------------------------------------------------------------------
2833 // --------------------------------------------------------------------
2834
2835 struct ResTable::Header
2836 {
2837     Header(ResTable* _owner) : owner(_owner), ownedData(NULL), header(NULL),
2838         resourceIDMap(NULL), resourceIDMapSize(0) { }
2839
2840     ~Header()
2841     {
2842         free(resourceIDMap);
2843     }
2844
2845     const ResTable* const           owner;
2846     void*                           ownedData;
2847     const ResTable_header*          header;
2848     size_t                          size;
2849     const uint8_t*                  dataEnd;
2850     size_t                          index;
2851     int32_t                         cookie;
2852
2853     ResStringPool                   values;
2854     uint32_t*                       resourceIDMap;
2855     size_t                          resourceIDMapSize;
2856 };
2857
2858 struct ResTable::Entry {
2859     ResTable_config config;
2860     const ResTable_entry* entry;
2861     const ResTable_type* type;
2862     uint32_t specFlags;
2863     const Package* package;
2864
2865     StringPoolRef typeStr;
2866     StringPoolRef keyStr;
2867 };
2868
2869 struct ResTable::Type
2870 {
2871     Type(const Header* _header, const Package* _package, size_t count)
2872         : header(_header), package(_package), entryCount(count),
2873           typeSpec(NULL), typeSpecFlags(NULL) { }
2874     const Header* const             header;
2875     const Package* const            package;
2876     const size_t                    entryCount;
2877     const ResTable_typeSpec*        typeSpec;
2878     const uint32_t*                 typeSpecFlags;
2879     IdmapEntries                    idmapEntries;
2880     Vector<const ResTable_type*>    configs;
2881 };
2882
2883 struct ResTable::Package
2884 {
2885     Package(ResTable* _owner, const Header* _header, const ResTable_package* _package)
2886         : owner(_owner), header(_header), package(_package), typeIdOffset(0) {
2887         if (dtohs(package->header.headerSize) == sizeof(package)) {
2888             // The package structure is the same size as the definition.
2889             // This means it contains the typeIdOffset field.
2890             typeIdOffset = package->typeIdOffset;
2891         }
2892     }
2893
2894     const ResTable* const           owner;
2895     const Header* const             header;
2896     const ResTable_package* const   package;
2897
2898     ResStringPool                   typeStrings;
2899     ResStringPool                   keyStrings;
2900
2901     size_t                          typeIdOffset;
2902 };
2903
2904 // A group of objects describing a particular resource package.
2905 // The first in 'package' is always the root object (from the resource
2906 // table that defined the package); the ones after are skins on top of it.
2907 struct ResTable::PackageGroup
2908 {
2909     PackageGroup(ResTable* _owner, const String16& _name, uint32_t _id)
2910         : owner(_owner)
2911         , name(_name)
2912         , id(_id)
2913         , largestTypeId(0)
2914         , bags(NULL)
2915         , dynamicRefTable(static_cast<uint8_t>(_id))
2916     { }
2917
2918     ~PackageGroup() {
2919         clearBagCache();
2920         const size_t numTypes = types.size();
2921         for (size_t i = 0; i < numTypes; i++) {
2922             const TypeList& typeList = types[i];
2923             const size_t numInnerTypes = typeList.size();
2924             for (size_t j = 0; j < numInnerTypes; j++) {
2925                 if (typeList[j]->package->owner == owner) {
2926                     delete typeList[j];
2927                 }
2928             }
2929         }
2930
2931         const size_t N = packages.size();
2932         for (size_t i=0; i<N; i++) {
2933             Package* pkg = packages[i];
2934             if (pkg->owner == owner) {
2935                 delete pkg;
2936             }
2937         }
2938     }
2939
2940     void clearBagCache() {
2941         if (bags) {
2942             TABLE_NOISY(printf("bags=%p\n", bags));
2943             for (size_t i = 0; i < bags->size(); i++) {
2944                 TABLE_NOISY(printf("type=%d\n", i));
2945                 const TypeList& typeList = types[i];
2946                 if (!typeList.isEmpty()) {
2947                     bag_set** typeBags = bags->get(i);
2948                     TABLE_NOISY(printf("typeBags=%p\n", typeBags));
2949                     if (typeBags) {
2950                         const size_t N = typeList[0]->entryCount;
2951                         TABLE_NOISY(printf("type->entryCount=%x\n", N));
2952                         for (size_t j=0; j<N; j++) {
2953                             if (typeBags[j] && typeBags[j] != (bag_set*)0xFFFFFFFF)
2954                                 free(typeBags[j]);
2955                         }
2956                         free(typeBags);
2957                     }
2958                 }
2959             }
2960             delete bags;
2961             bags = NULL;
2962         }
2963     }
2964
2965     ssize_t findType16(const char16_t* type, size_t len) const {
2966         const size_t N = packages.size();
2967         for (size_t i = 0; i < N; i++) {
2968             ssize_t index = packages[i]->typeStrings.indexOfString(type, len);
2969             if (index >= 0) {
2970                 return index + packages[i]->typeIdOffset;
2971             }
2972         }
2973         return -1;
2974     }
2975
2976     const ResTable* const           owner;
2977     String16 const                  name;
2978     uint32_t const                  id;
2979
2980     // This is mainly used to keep track of the loaded packages
2981     // and to clean them up properly. Accessing resources happens from
2982     // the 'types' array.
2983     Vector<Package*>                packages;
2984
2985     ByteBucketArray<TypeList>       types;
2986
2987     uint8_t                         largestTypeId;
2988
2989     // Computed attribute bags, first indexed by the type and second
2990     // by the entry in that type.
2991     ByteBucketArray<bag_set**>*     bags;
2992
2993     // The table mapping dynamic references to resolved references for
2994     // this package group.
2995     // TODO: We may be able to support dynamic references in overlays
2996     // by having these tables in a per-package scope rather than
2997     // per-package-group.
2998     DynamicRefTable                 dynamicRefTable;
2999 };
3000
3001 struct ResTable::bag_set
3002 {
3003     size_t numAttrs;    // number in array
3004     size_t availAttrs;  // total space in array
3005     uint32_t typeSpecFlags;
3006     // Followed by 'numAttr' bag_entry structures.
3007 };
3008
3009 ResTable::Theme::Theme(const ResTable& table)
3010     : mTable(table)
3011 {
3012     memset(mPackages, 0, sizeof(mPackages));
3013 }
3014
3015 ResTable::Theme::~Theme()
3016 {
3017     for (size_t i=0; i<Res_MAXPACKAGE; i++) {
3018         package_info* pi = mPackages[i];
3019         if (pi != NULL) {
3020             free_package(pi);
3021         }
3022     }
3023 }
3024
3025 void ResTable::Theme::free_package(package_info* pi)
3026 {
3027     for (size_t j = 0; j <= Res_MAXTYPE; j++) {
3028         theme_entry* te = pi->types[j].entries;
3029         if (te != NULL) {
3030             free(te);
3031         }
3032     }
3033     free(pi);
3034 }
3035
3036 ResTable::Theme::package_info* ResTable::Theme::copy_package(package_info* pi)
3037 {
3038     package_info* newpi = (package_info*)malloc(sizeof(package_info));
3039     for (size_t j = 0; j <= Res_MAXTYPE; j++) {
3040         size_t cnt = pi->types[j].numEntries;
3041         newpi->types[j].numEntries = cnt;
3042         theme_entry* te = pi->types[j].entries;
3043         if (te != NULL) {
3044             theme_entry* newte = (theme_entry*)malloc(cnt*sizeof(theme_entry));
3045             newpi->types[j].entries = newte;
3046             memcpy(newte, te, cnt*sizeof(theme_entry));
3047         } else {
3048             newpi->types[j].entries = NULL;
3049         }
3050     }
3051     return newpi;
3052 }
3053
3054 status_t ResTable::Theme::applyStyle(uint32_t resID, bool force)
3055 {
3056     const bag_entry* bag;
3057     uint32_t bagTypeSpecFlags = 0;
3058     mTable.lock();
3059     const ssize_t N = mTable.getBagLocked(resID, &bag, &bagTypeSpecFlags);
3060     TABLE_NOISY(ALOGV("Applying style 0x%08x to theme %p, count=%d", resID, this, N));
3061     if (N < 0) {
3062         mTable.unlock();
3063         return N;
3064     }
3065
3066     uint32_t curPackage = 0xffffffff;
3067     ssize_t curPackageIndex = 0;
3068     package_info* curPI = NULL;
3069     uint32_t curType = 0xffffffff;
3070     size_t numEntries = 0;
3071     theme_entry* curEntries = NULL;
3072
3073     const bag_entry* end = bag + N;
3074     while (bag < end) {
3075         const uint32_t attrRes = bag->map.name.ident;
3076         const uint32_t p = Res_GETPACKAGE(attrRes);
3077         const uint32_t t = Res_GETTYPE(attrRes);
3078         const uint32_t e = Res_GETENTRY(attrRes);
3079
3080         if (curPackage != p) {
3081             const ssize_t pidx = mTable.getResourcePackageIndex(attrRes);
3082             if (pidx < 0) {
3083                 ALOGE("Style contains key with bad package: 0x%08x\n", attrRes);
3084                 bag++;
3085                 continue;
3086             }
3087             curPackage = p;
3088             curPackageIndex = pidx;
3089             curPI = mPackages[pidx];
3090             if (curPI == NULL) {
3091                 PackageGroup* const grp = mTable.mPackageGroups[pidx];
3092                 curPI = (package_info*)malloc(sizeof(package_info));
3093                 memset(curPI, 0, sizeof(*curPI));
3094                 mPackages[pidx] = curPI;
3095             }
3096             curType = 0xffffffff;
3097         }
3098         if (curType != t) {
3099             if (t > Res_MAXTYPE) {
3100                 ALOGE("Style contains key with bad type: 0x%08x\n", attrRes);
3101                 bag++;
3102                 continue;
3103             }
3104             curType = t;
3105             curEntries = curPI->types[t].entries;
3106             if (curEntries == NULL) {
3107                 PackageGroup* const grp = mTable.mPackageGroups[curPackageIndex];
3108                 const TypeList& typeList = grp->types[t];
3109                 int cnt = typeList.isEmpty() ? 0 : typeList[0]->entryCount;
3110                 curEntries = (theme_entry*)malloc(cnt*sizeof(theme_entry));
3111                 memset(curEntries, Res_value::TYPE_NULL, cnt*sizeof(theme_entry));
3112                 curPI->types[t].numEntries = cnt;
3113                 curPI->types[t].entries = curEntries;
3114             }
3115             numEntries = curPI->types[t].numEntries;
3116         }
3117         if (e >= numEntries) {
3118             ALOGE("Style contains key with bad entry: 0x%08x\n", attrRes);
3119             bag++;
3120             continue;
3121         }
3122         theme_entry* curEntry = curEntries + e;
3123         TABLE_NOISY(ALOGV("Attr 0x%08x: type=0x%x, data=0x%08x; curType=0x%x",
3124                 attrRes, bag->map.value.dataType, bag->map.value.data,
3125                 curEntry->value.dataType));
3126         if (force || curEntry->value.dataType == Res_value::TYPE_NULL) {
3127             curEntry->stringBlock = bag->stringBlock;
3128             curEntry->typeSpecFlags |= bagTypeSpecFlags;
3129             curEntry->value = bag->map.value;
3130         }
3131
3132         bag++;
3133     }
3134
3135     mTable.unlock();
3136
3137     //ALOGI("Applying style 0x%08x (force=%d)  theme %p...\n", resID, force, this);
3138     //dumpToLog();
3139
3140     return NO_ERROR;
3141 }
3142
3143 status_t ResTable::Theme::setTo(const Theme& other)
3144 {
3145     //ALOGI("Setting theme %p from theme %p...\n", this, &other);
3146     //dumpToLog();
3147     //other.dumpToLog();
3148
3149     if (&mTable == &other.mTable) {
3150         for (size_t i=0; i<Res_MAXPACKAGE; i++) {
3151             if (mPackages[i] != NULL) {
3152                 free_package(mPackages[i]);
3153             }
3154             if (other.mPackages[i] != NULL) {
3155                 mPackages[i] = copy_package(other.mPackages[i]);
3156             } else {
3157                 mPackages[i] = NULL;
3158             }
3159         }
3160     } else {
3161         // @todo: need to really implement this, not just copy
3162         // the system package (which is still wrong because it isn't
3163         // fixing up resource references).
3164         for (size_t i=0; i<Res_MAXPACKAGE; i++) {
3165             if (mPackages[i] != NULL) {
3166                 free_package(mPackages[i]);
3167             }
3168             if (i == 0 && other.mPackages[i] != NULL) {
3169                 mPackages[i] = copy_package(other.mPackages[i]);
3170             } else {
3171                 mPackages[i] = NULL;
3172             }
3173         }
3174     }
3175
3176     //ALOGI("Final theme:");
3177     //dumpToLog();
3178
3179     return NO_ERROR;
3180 }
3181
3182 ssize_t ResTable::Theme::getAttribute(uint32_t resID, Res_value* outValue,
3183         uint32_t* outTypeSpecFlags) const
3184 {
3185     int cnt = 20;
3186
3187     if (outTypeSpecFlags != NULL) *outTypeSpecFlags = 0;
3188
3189     do {
3190         const ssize_t p = mTable.getResourcePackageIndex(resID);
3191         const uint32_t t = Res_GETTYPE(resID);
3192         const uint32_t e = Res_GETENTRY(resID);
3193
3194         TABLE_THEME(ALOGI("Looking up attr 0x%08x in theme %p", resID, this));
3195
3196         if (p >= 0) {
3197             const package_info* const pi = mPackages[p];
3198             TABLE_THEME(ALOGI("Found package: %p", pi));
3199             if (pi != NULL) {
3200                 TABLE_THEME(ALOGI("Desired type index is %ld in avail %d", t, Res_MAXTYPE + 1));
3201                 if (t <= Res_MAXTYPE) {
3202                     const type_info& ti = pi->types[t];
3203                     TABLE_THEME(ALOGI("Desired entry index is %ld in avail %d", e, ti.numEntries));
3204                     if (e < ti.numEntries) {
3205                         const theme_entry& te = ti.entries[e];
3206                         if (outTypeSpecFlags != NULL) {
3207                             *outTypeSpecFlags |= te.typeSpecFlags;
3208                         }
3209                         TABLE_THEME(ALOGI("Theme value: type=0x%x, data=0x%08x",
3210                                 te.value.dataType, te.value.data));
3211                         const uint8_t type = te.value.dataType;
3212                         if (type == Res_value::TYPE_ATTRIBUTE) {
3213                             if (cnt > 0) {
3214                                 cnt--;
3215                                 resID = te.value.data;
3216                                 continue;
3217                             }
3218                             ALOGW("Too many attribute references, stopped at: 0x%08x\n", resID);
3219                             return BAD_INDEX;
3220                         } else if (type != Res_value::TYPE_NULL) {
3221                             *outValue = te.value;
3222                             return te.stringBlock;
3223                         }
3224                         return BAD_INDEX;
3225                     }
3226                 }
3227             }
3228         }
3229         break;
3230
3231     } while (true);
3232
3233     return BAD_INDEX;
3234 }
3235
3236 ssize_t ResTable::Theme::resolveAttributeReference(Res_value* inOutValue,
3237         ssize_t blockIndex, uint32_t* outLastRef,
3238         uint32_t* inoutTypeSpecFlags, ResTable_config* inoutConfig) const
3239 {
3240     //printf("Resolving type=0x%x\n", inOutValue->dataType);
3241     if (inOutValue->dataType == Res_value::TYPE_ATTRIBUTE) {
3242         uint32_t newTypeSpecFlags;
3243         blockIndex = getAttribute(inOutValue->data, inOutValue, &newTypeSpecFlags);
3244         TABLE_THEME(ALOGI("Resolving attr reference: blockIndex=%d, type=0x%x, data=%p\n",
3245              (int)blockIndex, (int)inOutValue->dataType, (void*)inOutValue->data));
3246         if (inoutTypeSpecFlags != NULL) *inoutTypeSpecFlags |= newTypeSpecFlags;
3247         //printf("Retrieved attribute new type=0x%x\n", inOutValue->dataType);
3248         if (blockIndex < 0) {
3249             return blockIndex;
3250         }
3251     }
3252     return mTable.resolveReference(inOutValue, blockIndex, outLastRef,
3253             inoutTypeSpecFlags, inoutConfig);
3254 }
3255
3256 void ResTable::Theme::dumpToLog() const
3257 {
3258     ALOGI("Theme %p:\n", this);
3259     for (size_t i=0; i<Res_MAXPACKAGE; i++) {
3260         package_info* pi = mPackages[i];
3261         if (pi == NULL) continue;
3262
3263         ALOGI("  Package #0x%02x:\n", (int)(i + 1));
3264         for (size_t j = 0; j <= Res_MAXTYPE; j++) {
3265             type_info& ti = pi->types[j];
3266             if (ti.numEntries == 0) continue;
3267             ALOGI("    Type #0x%02x:\n", (int)(j + 1));
3268             for (size_t k = 0; k < ti.numEntries; k++) {
3269                 const theme_entry& te = ti.entries[k];
3270                 if (te.value.dataType == Res_value::TYPE_NULL) continue;
3271                 ALOGI("      0x%08x: t=0x%x, d=0x%08x (block=%d)\n",
3272                      (int)Res_MAKEID(i, j, k),
3273                      te.value.dataType, (int)te.value.data, (int)te.stringBlock);
3274             }
3275         }
3276     }
3277 }
3278
3279 ResTable::ResTable()
3280     : mError(NO_INIT), mNextPackageId(2)
3281 {
3282     memset(&mParams, 0, sizeof(mParams));
3283     memset(mPackageMap, 0, sizeof(mPackageMap));
3284     //ALOGI("Creating ResTable %p\n", this);
3285 }
3286
3287 ResTable::ResTable(const void* data, size_t size, const int32_t cookie, bool copyData)
3288     : mError(NO_INIT), mNextPackageId(2)
3289 {
3290     memset(&mParams, 0, sizeof(mParams));
3291     memset(mPackageMap, 0, sizeof(mPackageMap));
3292     addInternal(data, size, NULL, 0, cookie, copyData);
3293     LOG_FATAL_IF(mError != NO_ERROR, "Error parsing resource table");
3294     //ALOGI("Creating ResTable %p\n", this);
3295 }
3296
3297 ResTable::~ResTable()
3298 {
3299     //ALOGI("Destroying ResTable in %p\n", this);
3300     uninit();
3301 }
3302
3303 inline ssize_t ResTable::getResourcePackageIndex(uint32_t resID) const
3304 {
3305     return ((ssize_t)mPackageMap[Res_GETPACKAGE(resID)+1])-1;
3306 }
3307
3308 status_t ResTable::add(const void* data, size_t size, const int32_t cookie, bool copyData) {
3309     return addInternal(data, size, NULL, 0, cookie, copyData);
3310 }
3311
3312 status_t ResTable::add(const void* data, size_t size, const void* idmapData, size_t idmapDataSize,
3313         const int32_t cookie, bool copyData) {
3314     return addInternal(data, size, idmapData, idmapDataSize, cookie, copyData);
3315 }
3316
3317 status_t ResTable::add(Asset* asset, const int32_t cookie, bool copyData) {
3318     const void* data = asset->getBuffer(true);
3319     if (data == NULL) {
3320         ALOGW("Unable to get buffer of resource asset file");
3321         return UNKNOWN_ERROR;
3322     }
3323
3324     return addInternal(data, static_cast<size_t>(asset->getLength()), NULL, 0, cookie, copyData);
3325 }
3326
3327 status_t ResTable::add(Asset* asset, Asset* idmapAsset, const int32_t cookie, bool copyData) {
3328     const void* data = asset->getBuffer(true);
3329     if (data == NULL) {
3330         ALOGW("Unable to get buffer of resource asset file");
3331         return UNKNOWN_ERROR;
3332     }
3333
3334     size_t idmapSize = 0;
3335     const void* idmapData = NULL;
3336     if (idmapAsset != NULL) {
3337         idmapData = idmapAsset->getBuffer(true);
3338         if (idmapData == NULL) {
3339             ALOGW("Unable to get buffer of idmap asset file");
3340             return UNKNOWN_ERROR;
3341         }
3342         idmapSize = static_cast<size_t>(idmapAsset->getLength());
3343     }
3344
3345     return addInternal(data, static_cast<size_t>(asset->getLength()),
3346             idmapData, idmapSize, cookie, copyData);
3347 }
3348
3349 status_t ResTable::add(ResTable* src)
3350 {
3351     mError = src->mError;
3352
3353     for (size_t i=0; i<src->mHeaders.size(); i++) {
3354         mHeaders.add(src->mHeaders[i]);
3355     }
3356
3357     for (size_t i=0; i<src->mPackageGroups.size(); i++) {
3358         PackageGroup* srcPg = src->mPackageGroups[i];
3359         PackageGroup* pg = new PackageGroup(this, srcPg->name, srcPg->id);
3360         for (size_t j=0; j<srcPg->packages.size(); j++) {
3361             pg->packages.add(srcPg->packages[j]);
3362         }
3363
3364         for (size_t j = 0; j < srcPg->types.size(); j++) {
3365             if (srcPg->types[j].isEmpty()) {
3366                 continue;
3367             }
3368
3369             TypeList& typeList = pg->types.editItemAt(j);
3370             typeList.appendVector(srcPg->types[j]);
3371         }
3372         pg->dynamicRefTable.addMappings(srcPg->dynamicRefTable);
3373         pg->largestTypeId = max(pg->largestTypeId, srcPg->largestTypeId);
3374         mPackageGroups.add(pg);
3375     }
3376
3377     memcpy(mPackageMap, src->mPackageMap, sizeof(mPackageMap));
3378
3379     return mError;
3380 }
3381
3382 status_t ResTable::addEmpty(const int32_t cookie) {
3383     Header* header = new Header(this);
3384     header->index = mHeaders.size();
3385     header->cookie = cookie;
3386     header->values.setToEmpty();
3387     header->ownedData = calloc(1, sizeof(ResTable_header));
3388
3389     ResTable_header* resHeader = (ResTable_header*) header->ownedData;
3390     resHeader->header.type = RES_TABLE_TYPE;
3391     resHeader->header.headerSize = sizeof(ResTable_header);
3392     resHeader->header.size = sizeof(ResTable_header);
3393
3394     header->header = (const ResTable_header*) resHeader;
3395     mHeaders.add(header);
3396     return (mError=NO_ERROR);
3397 }
3398
3399 status_t ResTable::addInternal(const void* data, size_t dataSize, const void* idmapData, size_t idmapDataSize,
3400         const int32_t cookie, bool copyData)
3401 {
3402     if (!data) {
3403         return NO_ERROR;
3404     }
3405
3406     if (dataSize < sizeof(ResTable_header)) {
3407         ALOGE("Invalid data. Size(%d) is smaller than a ResTable_header(%d).",
3408                 (int) dataSize, (int) sizeof(ResTable_header));
3409         return UNKNOWN_ERROR;
3410     }
3411
3412     Header* header = new Header(this);
3413     header->index = mHeaders.size();
3414     header->cookie = cookie;
3415     if (idmapData != NULL) {
3416         header->resourceIDMap = (uint32_t*) malloc(idmapDataSize);
3417         if (header->resourceIDMap == NULL) {
3418             delete header;
3419             return (mError = NO_MEMORY);
3420         }
3421         memcpy(header->resourceIDMap, idmapData, idmapDataSize);
3422         header->resourceIDMapSize = idmapDataSize;
3423     }
3424     mHeaders.add(header);
3425
3426     const bool notDeviceEndian = htods(0xf0) != 0xf0;
3427
3428     LOAD_TABLE_NOISY(
3429         ALOGV("Adding resources to ResTable: data=%p, size=0x%x, cookie=%d, copy=%d "
3430              "idmap=%p\n", data, dataSize, cookie, copyData, idmap));
3431
3432     if (copyData || notDeviceEndian) {
3433         header->ownedData = malloc(dataSize);
3434         if (header->ownedData == NULL) {
3435             return (mError=NO_MEMORY);
3436         }
3437         memcpy(header->ownedData, data, dataSize);
3438         data = header->ownedData;
3439     }
3440
3441     header->header = (const ResTable_header*)data;
3442     header->size = dtohl(header->header->header.size);
3443     //ALOGI("Got size 0x%x, again size 0x%x, raw size 0x%x\n", header->size,
3444     //     dtohl(header->header->header.size), header->header->header.size);
3445     LOAD_TABLE_NOISY(ALOGV("Loading ResTable @%p:\n", header->header));
3446     if (dtohs(header->header->header.headerSize) > header->size
3447             || header->size > dataSize) {
3448         ALOGW("Bad resource table: header size 0x%x or total size 0x%x is larger than data size 0x%x\n",
3449              (int)dtohs(header->header->header.headerSize),
3450              (int)header->size, (int)dataSize);
3451         return (mError=BAD_TYPE);
3452     }
3453     if (((dtohs(header->header->header.headerSize)|header->size)&0x3) != 0) {
3454         ALOGW("Bad resource table: header size 0x%x or total size 0x%x is not on an integer boundary\n",
3455              (int)dtohs(header->header->header.headerSize),
3456              (int)header->size);
3457         return (mError=BAD_TYPE);
3458     }
3459     header->dataEnd = ((const uint8_t*)header->header) + header->size;
3460
3461     // Iterate through all chunks.
3462     size_t curPackage = 0;
3463
3464     const ResChunk_header* chunk =
3465         (const ResChunk_header*)(((const uint8_t*)header->header)
3466                                  + dtohs(header->header->header.headerSize));
3467     while (((const uint8_t*)chunk) <= (header->dataEnd-sizeof(ResChunk_header)) &&
3468            ((const uint8_t*)chunk) <= (header->dataEnd-dtohl(chunk->size))) {
3469         status_t err = validate_chunk(chunk, sizeof(ResChunk_header), header->dataEnd, "ResTable");
3470         if (err != NO_ERROR) {
3471             return (mError=err);
3472         }
3473         TABLE_NOISY(ALOGV("Chunk: type=0x%x, headerSize=0x%x, size=0x%x, pos=%p\n",
3474                      dtohs(chunk->type), dtohs(chunk->headerSize), dtohl(chunk->size),
3475                      (void*)(((const uint8_t*)chunk) - ((const uint8_t*)header->header))));
3476         const size_t csize = dtohl(chunk->size);
3477         const uint16_t ctype = dtohs(chunk->type);
3478         if (ctype == RES_STRING_POOL_TYPE) {
3479             if (header->values.getError() != NO_ERROR) {
3480                 // Only use the first string chunk; ignore any others that
3481                 // may appear.
3482                 status_t err = header->values.setTo(chunk, csize);
3483                 if (err != NO_ERROR) {
3484                     return (mError=err);
3485                 }
3486             } else {
3487                 ALOGW("Multiple string chunks found in resource table.");
3488             }
3489         } else if (ctype == RES_TABLE_PACKAGE_TYPE) {
3490             if (curPackage >= dtohl(header->header->packageCount)) {
3491                 ALOGW("More package chunks were found than the %d declared in the header.",
3492                      dtohl(header->header->packageCount));
3493                 return (mError=BAD_TYPE);
3494             }
3495
3496             if (parsePackage((ResTable_package*)chunk, header) != NO_ERROR) {
3497                 return mError;
3498             }
3499             curPackage++;
3500         } else {
3501             ALOGW("Unknown chunk type 0x%x in table at %p.\n",
3502                  ctype,
3503                  (void*)(((const uint8_t*)chunk) - ((const uint8_t*)header->header)));
3504         }
3505         chunk = (const ResChunk_header*)
3506             (((const uint8_t*)chunk) + csize);
3507     }
3508
3509     if (curPackage < dtohl(header->header->packageCount)) {
3510         ALOGW("Fewer package chunks (%d) were found than the %d declared in the header.",
3511              (int)curPackage, dtohl(header->header->packageCount));
3512         return (mError=BAD_TYPE);
3513     }
3514     mError = header->values.getError();
3515     if (mError != NO_ERROR) {
3516         ALOGW("No string values found in resource table!");
3517     }
3518
3519     TABLE_NOISY(ALOGV("Returning from add with mError=%d\n", mError));
3520     return mError;
3521 }
3522
3523 status_t ResTable::getError() const
3524 {
3525     return mError;
3526 }
3527
3528 void ResTable::uninit()
3529 {
3530     mError = NO_INIT;
3531     size_t N = mPackageGroups.size();
3532     for (size_t i=0; i<N; i++) {
3533         PackageGroup* g = mPackageGroups[i];
3534         delete g;
3535     }
3536     N = mHeaders.size();
3537     for (size_t i=0; i<N; i++) {
3538         Header* header = mHeaders[i];
3539         if (header->owner == this) {
3540             if (header->ownedData) {
3541                 free(header->ownedData);
3542             }
3543             delete header;
3544         }
3545     }
3546
3547     mPackageGroups.clear();
3548     mHeaders.clear();
3549 }
3550
3551 bool ResTable::getResourceName(uint32_t resID, bool allowUtf8, resource_name* outName) const
3552 {
3553     if (mError != NO_ERROR) {
3554         return false;
3555     }
3556
3557     const ssize_t p = getResourcePackageIndex(resID);
3558     const int t = Res_GETTYPE(resID);
3559     const int e = Res_GETENTRY(resID);
3560
3561     if (p < 0) {
3562         if (Res_GETPACKAGE(resID)+1 == 0) {
3563             ALOGW("No package identifier when getting name for resource number 0x%08x", resID);
3564         } else {
3565             ALOGW("No known package when getting name for resource number 0x%08x", resID);
3566         }
3567         return false;
3568     }
3569     if (t < 0) {
3570         ALOGW("No type identifier when getting name for resource number 0x%08x", resID);
3571         return false;
3572     }
3573
3574     const PackageGroup* const grp = mPackageGroups[p];
3575     if (grp == NULL) {
3576         ALOGW("Bad identifier when getting name for resource number 0x%08x", resID);
3577         return false;
3578     }
3579
3580     Entry entry;
3581     status_t err = getEntry(grp, t, e, NULL, &entry);
3582     if (err != NO_ERROR) {
3583         return false;
3584     }
3585
3586     outName->package = grp->name.string();
3587     outName->packageLen = grp->name.size();
3588     if (allowUtf8) {
3589         outName->type8 = entry.typeStr.string8(&outName->typeLen);
3590         outName->name8 = entry.keyStr.string8(&outName->nameLen);
3591     } else {
3592         outName->type8 = NULL;
3593         outName->name8 = NULL;
3594     }
3595     if (outName->type8 == NULL) {
3596         outName->type = entry.typeStr.string16(&outName->typeLen);
3597         // If we have a bad index for some reason, we should abort.
3598         if (outName->type == NULL) {
3599             return false;
3600         }
3601     }
3602     if (outName->name8 == NULL) {
3603         outName->name = entry.keyStr.string16(&outName->nameLen);
3604         // If we have a bad index for some reason, we should abort.
3605         if (outName->name == NULL) {
3606             return false;
3607         }
3608     }
3609
3610     return true;
3611 }
3612
3613 ssize_t ResTable::getResource(uint32_t resID, Res_value* outValue, bool mayBeBag, uint16_t density,
3614         uint32_t* outSpecFlags, ResTable_config* outConfig) const
3615 {
3616     if (mError != NO_ERROR) {
3617         return mError;
3618     }
3619
3620     const ssize_t p = getResourcePackageIndex(resID);
3621     const int t = Res_GETTYPE(resID);
3622     const int e = Res_GETENTRY(resID);
3623
3624     if (p < 0) {
3625         if (Res_GETPACKAGE(resID)+1 == 0) {
3626             ALOGW("No package identifier when getting value for resource number 0x%08x", resID);
3627         } else {
3628             ALOGW("No known package when getting value for resource number 0x%08x", resID);
3629         }
3630         return BAD_INDEX;
3631     }
3632     if (t < 0) {
3633         ALOGW("No type identifier when getting value for resource number 0x%08x", resID);
3634         return BAD_INDEX;
3635     }
3636
3637     const PackageGroup* const grp = mPackageGroups[p];
3638     if (grp == NULL) {
3639         ALOGW("Bad identifier when getting value for resource number 0x%08x", resID);
3640         return BAD_INDEX;
3641     }
3642
3643     // Allow overriding density
3644     ResTable_config desiredConfig = mParams;
3645     if (density > 0) {
3646         desiredConfig.density = density;
3647     }
3648
3649     Entry entry;
3650     status_t err = getEntry(grp, t, e, &desiredConfig, &entry);
3651     if (err != NO_ERROR) {
3652         // Only log the failure when we're not running on the host as
3653         // part of a tool. The caller will do its own logging.
3654 #ifndef STATIC_ANDROIDFW_FOR_TOOLS
3655         ALOGW("Failure getting entry for 0x%08x (t=%d e=%d) (error %d)\n",
3656                 resID, t, e, err);
3657 #endif
3658         return err;
3659     }
3660
3661     if ((dtohs(entry.entry->flags) & ResTable_entry::FLAG_COMPLEX) != 0) {
3662         if (!mayBeBag) {
3663             ALOGW("Requesting resource 0x%08x failed because it is complex\n", resID);
3664         }
3665         return BAD_VALUE;
3666     }
3667
3668     const Res_value* value = reinterpret_cast<const Res_value*>(
3669             reinterpret_cast<const uint8_t*>(entry.entry) + entry.entry->size);
3670
3671     outValue->size = dtohs(value->size);
3672     outValue->res0 = value->res0;
3673     outValue->dataType = value->dataType;
3674     outValue->data = dtohl(value->data);
3675
3676     // The reference may be pointing to a resource in a shared library. These
3677     // references have build-time generated package IDs. These ids may not match
3678     // the actual package IDs of the corresponding packages in this ResTable.
3679     // We need to fix the package ID based on a mapping.
3680     if (grp->dynamicRefTable.lookupResourceValue(outValue) != NO_ERROR) {
3681         ALOGW("Failed to resolve referenced package: 0x%08x", outValue->data);
3682         return BAD_VALUE;
3683     }
3684
3685     TABLE_NOISY(size_t len;
3686           printf("Found value: pkg=%d, type=%d, str=%s, int=%d\n",
3687                  entry.package->header->index,
3688                  outValue->dataType,
3689                  outValue->dataType == Res_value::TYPE_STRING
3690                  ? String8(entry.package->header->values.stringAt(
3691                      outValue->data, &len)).string()
3692                  : "",
3693                  outValue->data));
3694
3695     if (outSpecFlags != NULL) {
3696         *outSpecFlags = entry.specFlags;
3697     }
3698
3699     if (outConfig != NULL) {
3700         *outConfig = entry.config;
3701     }
3702
3703     return entry.package->header->index;
3704 }
3705
3706 ssize_t ResTable::resolveReference(Res_value* value, ssize_t blockIndex,
3707         uint32_t* outLastRef, uint32_t* inoutTypeSpecFlags,
3708         ResTable_config* outConfig) const
3709 {
3710     int count=0;
3711     while (blockIndex >= 0 && value->dataType == Res_value::TYPE_REFERENCE
3712             && value->data != 0 && count < 20) {
3713         if (outLastRef) *outLastRef = value->data;
3714         uint32_t lastRef = value->data;
3715         uint32_t newFlags = 0;
3716         const ssize_t newIndex = getResource(value->data, value, true, 0, &newFlags,
3717                 outConfig);
3718         if (newIndex == BAD_INDEX) {
3719             return BAD_INDEX;
3720         }
3721         TABLE_THEME(ALOGI("Resolving reference %p: newIndex=%d, type=0x%x, data=%p\n",
3722              (void*)lastRef, (int)newIndex, (int)value->dataType, (void*)value->data));
3723         //printf("Getting reference 0x%08x: newIndex=%d\n", value->data, newIndex);
3724         if (inoutTypeSpecFlags != NULL) *inoutTypeSpecFlags |= newFlags;
3725         if (newIndex < 0) {
3726             // This can fail if the resource being referenced is a style...
3727             // in this case, just return the reference, and expect the
3728             // caller to deal with.
3729             return blockIndex;
3730         }
3731         blockIndex = newIndex;
3732         count++;
3733     }
3734     return blockIndex;
3735 }
3736
3737 const char16_t* ResTable::valueToString(
3738     const Res_value* value, size_t stringBlock,
3739     char16_t /*tmpBuffer*/ [TMP_BUFFER_SIZE], size_t* outLen) const
3740 {
3741     if (!value) {
3742         return NULL;
3743     }
3744     if (value->dataType == value->TYPE_STRING) {
3745         return getTableStringBlock(stringBlock)->stringAt(value->data, outLen);
3746     }
3747     // XXX do int to string conversions.
3748     return NULL;
3749 }
3750
3751 ssize_t ResTable::lockBag(uint32_t resID, const bag_entry** outBag) const
3752 {
3753     mLock.lock();
3754     ssize_t err = getBagLocked(resID, outBag);
3755     if (err < NO_ERROR) {
3756         //printf("*** get failed!  unlocking\n");
3757         mLock.unlock();
3758     }
3759     return err;
3760 }
3761
3762 void ResTable::unlockBag(const bag_entry* /*bag*/) const
3763 {
3764     //printf("<<< unlockBag %p\n", this);
3765     mLock.unlock();
3766 }
3767
3768 void ResTable::lock() const
3769 {
3770     mLock.lock();
3771 }
3772
3773 void ResTable::unlock() const
3774 {
3775     mLock.unlock();
3776 }
3777
3778 ssize_t ResTable::getBagLocked(uint32_t resID, const bag_entry** outBag,
3779         uint32_t* outTypeSpecFlags) const
3780 {
3781     if (mError != NO_ERROR) {
3782         return mError;
3783     }
3784
3785     const ssize_t p = getResourcePackageIndex(resID);
3786     const int t = Res_GETTYPE(resID);
3787     const int e = Res_GETENTRY(resID);
3788
3789     if (p < 0) {
3790         ALOGW("Invalid package identifier when getting bag for resource number 0x%08x", resID);
3791         return BAD_INDEX;
3792     }
3793     if (t < 0) {
3794         ALOGW("No type identifier when getting bag for resource number 0x%08x", resID);
3795         return BAD_INDEX;
3796     }
3797
3798     //printf("Get bag: id=0x%08x, p=%d, t=%d\n", resID, p, t);
3799     PackageGroup* const grp = mPackageGroups[p];
3800     if (grp == NULL) {
3801         ALOGW("Bad identifier when getting bag for resource number 0x%08x", resID);
3802         return BAD_INDEX;
3803     }
3804
3805     const TypeList& typeConfigs = grp->types[t];
3806     if (typeConfigs.isEmpty()) {
3807         ALOGW("Type identifier 0x%x does not exist.", t+1);
3808         return BAD_INDEX;
3809     }
3810
3811     const size_t NENTRY = typeConfigs[0]->entryCount;
3812     if (e >= (int)NENTRY) {
3813         ALOGW("Entry identifier 0x%x is larger than entry count 0x%x",
3814              e, (int)typeConfigs[0]->entryCount);
3815         return BAD_INDEX;
3816     }
3817
3818     // First see if we've already computed this bag...
3819     if (grp->bags) {
3820         bag_set** typeSet = grp->bags->get(t);
3821         if (typeSet) {
3822             bag_set* set = typeSet[e];
3823             if (set) {
3824                 if (set != (bag_set*)0xFFFFFFFF) {
3825                     if (outTypeSpecFlags != NULL) {
3826                         *outTypeSpecFlags = set->typeSpecFlags;
3827                     }
3828                     *outBag = (bag_entry*)(set+1);
3829                     //ALOGI("Found existing bag for: %p\n", (void*)resID);
3830                     return set->numAttrs;
3831                 }
3832                 ALOGW("Attempt to retrieve bag 0x%08x which is invalid or in a cycle.",
3833                      resID);
3834                 return BAD_INDEX;
3835             }
3836         }
3837     }
3838
3839     // Bag not found, we need to compute it!
3840     if (!grp->bags) {
3841         grp->bags = new ByteBucketArray<bag_set**>();
3842         if (!grp->bags) return NO_MEMORY;
3843     }
3844
3845     bag_set** typeSet = grp->bags->get(t);
3846     if (!typeSet) {
3847         typeSet = (bag_set**)calloc(NENTRY, sizeof(bag_set*));
3848         if (!typeSet) return NO_MEMORY;
3849         grp->bags->set(t, typeSet);
3850     }
3851
3852     // Mark that we are currently working on this one.
3853     typeSet[e] = (bag_set*)0xFFFFFFFF;
3854
3855     TABLE_NOISY(ALOGI("Building bag: %p\n", (void*)resID));
3856
3857     // Now collect all bag attributes
3858     Entry entry;
3859     status_t err = getEntry(grp, t, e, &mParams, &entry);
3860     if (err != NO_ERROR) {
3861         return err;
3862     }
3863
3864     const uint16_t entrySize = dtohs(entry.entry->size);
3865     const uint32_t parent = entrySize >= sizeof(ResTable_map_entry)
3866         ? dtohl(((const ResTable_map_entry*)entry.entry)->parent.ident) : 0;
3867     const uint32_t count = entrySize >= sizeof(ResTable_map_entry)
3868         ? dtohl(((const ResTable_map_entry*)entry.entry)->count) : 0;
3869
3870     size_t N = count;
3871
3872     TABLE_NOISY(ALOGI("Found map: size=%p parent=%p count=%d\n",
3873                      entrySize, parent, count));
3874
3875     // If this map inherits from another, we need to start
3876     // with its parent's values.  Otherwise start out empty.
3877     TABLE_NOISY(printf("Creating new bag, entrySize=0x%08x, parent=0x%08x\n",
3878                        entrySize, parent));
3879
3880     // This is what we are building.
3881     bag_set* set = NULL;
3882
3883     if (parent) {
3884         uint32_t resolvedParent = parent;
3885
3886         // Bags encode a parent reference without using the standard
3887         // Res_value structure. That means we must always try to
3888         // resolve a parent reference in case it is actually a
3889         // TYPE_DYNAMIC_REFERENCE.
3890         status_t err = grp->dynamicRefTable.lookupResourceId(&resolvedParent);
3891         if (err != NO_ERROR) {
3892             ALOGE("Failed resolving bag parent id 0x%08x", parent);
3893             return UNKNOWN_ERROR;
3894         }
3895
3896         const bag_entry* parentBag;
3897         uint32_t parentTypeSpecFlags = 0;
3898         const ssize_t NP = getBagLocked(resolvedParent, &parentBag, &parentTypeSpecFlags);
3899         const size_t NT = ((NP >= 0) ? NP : 0) + N;
3900         set = (bag_set*)malloc(sizeof(bag_set)+sizeof(bag_entry)*NT);
3901         if (set == NULL) {
3902             return NO_MEMORY;
3903         }
3904         if (NP > 0) {
3905             memcpy(set+1, parentBag, NP*sizeof(bag_entry));
3906             set->numAttrs = NP;
3907             TABLE_NOISY(ALOGI("Initialized new bag with %d inherited attributes.\n", NP));
3908         } else {
3909             TABLE_NOISY(ALOGI("Initialized new bag with no inherited attributes.\n"));
3910             set->numAttrs = 0;
3911         }
3912         set->availAttrs = NT;
3913         set->typeSpecFlags = parentTypeSpecFlags;
3914     } else {
3915         set = (bag_set*)malloc(sizeof(bag_set)+sizeof(bag_entry)*N);
3916         if (set == NULL) {
3917             return NO_MEMORY;
3918         }
3919         set->numAttrs = 0;
3920         set->availAttrs = N;
3921         set->typeSpecFlags = 0;
3922     }
3923
3924     set->typeSpecFlags |= entry.specFlags;
3925
3926     // Now merge in the new attributes...
3927     size_t curOff = (reinterpret_cast<uintptr_t>(entry.entry) - reinterpret_cast<uintptr_t>(entry.type))
3928         + dtohs(entry.entry->size);
3929     const ResTable_map* map;
3930     bag_entry* entries = (bag_entry*)(set+1);
3931     size_t curEntry = 0;
3932     uint32_t pos = 0;
3933     TABLE_NOISY(ALOGI("Starting with set %p, entries=%p, avail=%d\n",
3934                  set, entries, set->availAttrs));
3935     while (pos < count) {
3936         TABLE_NOISY(printf("Now at %p\n", (void*)curOff));
3937
3938         if (curOff > (dtohl(entry.type->header.size)-sizeof(ResTable_map))) {
3939             ALOGW("ResTable_map at %d is beyond type chunk data %d",
3940                  (int)curOff, dtohl(entry.type->header.size));
3941             return BAD_TYPE;
3942         }
3943         map = (const ResTable_map*)(((const uint8_t*)entry.type) + curOff);
3944         N++;
3945
3946         uint32_t newName = htodl(map->name.ident);
3947         if (!Res_INTERNALID(newName)) {
3948             // Attributes don't have a resource id as the name. They specify
3949             // other data, which would be wrong to change via a lookup.
3950             if (grp->dynamicRefTable.lookupResourceId(&newName) != NO_ERROR) {
3951                 ALOGE("Failed resolving ResTable_map name at %d with ident 0x%08x",
3952                         (int) curOff, (int) newName);
3953                 return UNKNOWN_ERROR;
3954             }
3955         }
3956
3957         bool isInside;
3958         uint32_t oldName = 0;
3959         while ((isInside=(curEntry < set->numAttrs))
3960                 && (oldName=entries[curEntry].map.name.ident) < newName) {
3961             TABLE_NOISY(printf("#%d: Keeping existing attribute: 0x%08x\n",
3962                          curEntry, entries[curEntry].map.name.ident));
3963             curEntry++;
3964         }
3965
3966         if ((!isInside) || oldName != newName) {
3967             // This is a new attribute...  figure out what to do with it.
3968             if (set->numAttrs >= set->availAttrs) {
3969                 // Need to alloc more memory...
3970                 const size_t newAvail = set->availAttrs+N;
3971                 set = (bag_set*)realloc(set,
3972                                         sizeof(bag_set)
3973                                         + sizeof(bag_entry)*newAvail);
3974                 if (set == NULL) {
3975                     return NO_MEMORY;
3976                 }
3977                 set->availAttrs = newAvail;
3978                 entries = (bag_entry*)(set+1);
3979                 TABLE_NOISY(printf("Reallocated set %p, entries=%p, avail=%d\n",
3980                              set, entries, set->availAttrs));
3981             }
3982             if (isInside) {
3983                 // Going in the middle, need to make space.
3984                 memmove(entries+curEntry+1, entries+curEntry,
3985                         sizeof(bag_entry)*(set->numAttrs-curEntry));
3986                 set->numAttrs++;
3987             }
3988             TABLE_NOISY(printf("#%d: Inserting new attribute: 0x%08x\n",
3989                          curEntry, newName));
3990         } else {
3991             TABLE_NOISY(printf("#%d: Replacing existing attribute: 0x%08x\n",
3992                          curEntry, oldName));
3993         }
3994
3995         bag_entry* cur = entries+curEntry;
3996
3997         cur->stringBlock = entry.package->header->index;
3998         cur->map.name.ident = newName;
3999         cur->map.value.copyFrom_dtoh(map->value);
4000         status_t err = grp->dynamicRefTable.lookupResourceValue(&cur->map.value);
4001         if (err != NO_ERROR) {
4002             ALOGE("Reference item(0x%08x) in bag could not be resolved.", cur->map.value.data);
4003             return UNKNOWN_ERROR;
4004         }
4005
4006         TABLE_NOISY(printf("Setting entry #%d %p: block=%d, name=0x%08x, type=%d, data=0x%08x\n",
4007                      curEntry, cur, cur->stringBlock, cur->map.name.ident,
4008                      cur->map.value.dataType, cur->map.value.data));
4009
4010         // On to the next!
4011         curEntry++;
4012         pos++;
4013         const size_t size = dtohs(map->value.size);
4014         curOff += size + sizeof(*map)-sizeof(map->value);
4015     };
4016
4017     if (curEntry > set->numAttrs) {
4018         set->numAttrs = curEntry;
4019     }
4020
4021     // And this is it...
4022     typeSet[e] = set;
4023     if (set) {
4024         if (outTypeSpecFlags != NULL) {
4025             *outTypeSpecFlags = set->typeSpecFlags;
4026         }
4027         *outBag = (bag_entry*)(set+1);
4028         TABLE_NOISY(ALOGI("Returning %d attrs\n", set->numAttrs));
4029         return set->numAttrs;
4030     }
4031     return BAD_INDEX;
4032 }
4033
4034 void ResTable::setParameters(const ResTable_config* params)
4035 {
4036     mLock.lock();
4037     TABLE_GETENTRY(ALOGI("Setting parameters: %s\n", params->toString().string()));
4038     mParams = *params;
4039     for (size_t i=0; i<mPackageGroups.size(); i++) {
4040         TABLE_NOISY(ALOGI("CLEARING BAGS FOR GROUP %d!", i));
4041         mPackageGroups[i]->clearBagCache();
4042     }
4043     mLock.unlock();
4044 }
4045
4046 void ResTable::getParameters(ResTable_config* params) const
4047 {
4048     mLock.lock();
4049     *params = mParams;
4050     mLock.unlock();
4051 }
4052
4053 struct id_name_map {
4054     uint32_t id;
4055     size_t len;
4056     char16_t name[6];
4057 };
4058
4059 const static id_name_map ID_NAMES[] = {
4060     { ResTable_map::ATTR_TYPE,  5, { '^', 't', 'y', 'p', 'e' } },
4061     { ResTable_map::ATTR_L10N,  5, { '^', 'l', '1', '0', 'n' } },
4062     { ResTable_map::ATTR_MIN,   4, { '^', 'm', 'i', 'n' } },
4063     { ResTable_map::ATTR_MAX,   4, { '^', 'm', 'a', 'x' } },
4064     { ResTable_map::ATTR_OTHER, 6, { '^', 'o', 't', 'h', 'e', 'r' } },
4065     { ResTable_map::ATTR_ZERO,  5, { '^', 'z', 'e', 'r', 'o' } },
4066     { ResTable_map::ATTR_ONE,   4, { '^', 'o', 'n', 'e' } },
4067     { ResTable_map::ATTR_TWO,   4, { '^', 't', 'w', 'o' } },
4068     { ResTable_map::ATTR_FEW,   4, { '^', 'f', 'e', 'w' } },
4069     { ResTable_map::ATTR_MANY,  5, { '^', 'm', 'a', 'n', 'y' } },
4070 };
4071
4072 uint32_t ResTable::identifierForName(const char16_t* name, size_t nameLen,
4073                                      const char16_t* type, size_t typeLen,
4074                                      const char16_t* package,
4075                                      size_t packageLen,
4076                                      uint32_t* outTypeSpecFlags) const
4077 {
4078     TABLE_SUPER_NOISY(printf("Identifier for name: error=%d\n", mError));
4079
4080     // Check for internal resource identifier as the very first thing, so
4081     // that we will always find them even when there are no resources.
4082     if (name[0] == '^') {
4083         const int N = (sizeof(ID_NAMES)/sizeof(ID_NAMES[0]));
4084         size_t len;
4085         for (int i=0; i<N; i++) {
4086             const id_name_map* m = ID_NAMES + i;
4087             len = m->len;
4088             if (len != nameLen) {
4089                 continue;
4090             }
4091             for (size_t j=1; j<len; j++) {
4092                 if (m->name[j] != name[j]) {
4093                     goto nope;
4094                 }
4095             }
4096             if (outTypeSpecFlags) {
4097                 *outTypeSpecFlags = ResTable_typeSpec::SPEC_PUBLIC;
4098             }
4099             return m->id;
4100 nope:
4101             ;
4102         }
4103         if (nameLen > 7) {
4104             if (name[1] == 'i' && name[2] == 'n'
4105                 && name[3] == 'd' && name[4] == 'e' && name[5] == 'x'
4106                 && name[6] == '_') {
4107                 int index = atoi(String8(name + 7, nameLen - 7).string());
4108                 if (Res_CHECKID(index)) {
4109                     ALOGW("Array resource index: %d is too large.",
4110                          index);
4111                     return 0;
4112                 }
4113                 if (outTypeSpecFlags) {
4114                     *outTypeSpecFlags = ResTable_typeSpec::SPEC_PUBLIC;
4115                 }
4116                 return  Res_MAKEARRAY(index);
4117             }
4118         }
4119         return 0;
4120     }
4121
4122     if (mError != NO_ERROR) {
4123         return 0;
4124     }
4125
4126     bool fakePublic = false;
4127
4128     // Figure out the package and type we are looking in...
4129
4130     const char16_t* packageEnd = NULL;
4131     const char16_t* typeEnd = NULL;
4132     const char16_t* const nameEnd = name+nameLen;
4133     const char16_t* p = name;
4134     while (p < nameEnd) {
4135         if (*p == ':') packageEnd = p;
4136         else if (*p == '/') typeEnd = p;
4137         p++;
4138     }
4139     if (*name == '@') {
4140         name++;
4141         if (*name == '*') {
4142             fakePublic = true;
4143             name++;
4144         }
4145     }
4146     if (name >= nameEnd) {
4147         return 0;
4148     }
4149
4150     if (packageEnd) {
4151         package = name;
4152         packageLen = packageEnd-name;
4153         name = packageEnd+1;
4154     } else if (!package) {
4155         return 0;
4156     }
4157
4158     if (typeEnd) {
4159         type = name;
4160         typeLen = typeEnd-name;
4161         name = typeEnd+1;
4162     } else if (!type) {
4163         return 0;
4164     }
4165
4166     if (name >= nameEnd) {
4167         return 0;
4168     }
4169     nameLen = nameEnd-name;
4170
4171     TABLE_NOISY(printf("Looking for identifier: type=%s, name=%s, package=%s\n",
4172                  String8(type, typeLen).string(),
4173                  String8(name, nameLen).string(),
4174                  String8(package, packageLen).string()));
4175
4176     const String16 attr("attr");
4177     const String16 attrPrivate("^attr-private");
4178
4179     const size_t NG = mPackageGroups.size();
4180     for (size_t ig=0; ig<NG; ig++) {
4181         const PackageGroup* group = mPackageGroups[ig];
4182
4183         if (strzcmp16(package, packageLen,
4184                       group->name.string(), group->name.size())) {
4185             TABLE_NOISY(printf("Skipping package group: %s\n", String8(group->name).string()));
4186             continue;
4187         }
4188
4189         const size_t packageCount = group->packages.size();
4190         for (size_t pi = 0; pi < packageCount; pi++) {
4191             const char16_t* targetType = type;
4192             size_t targetTypeLen = typeLen;
4193
4194             do {
4195                 ssize_t ti = group->packages[pi]->typeStrings.indexOfString(
4196                         targetType, targetTypeLen);
4197                 if (ti < 0) {
4198                     continue;
4199                 }
4200
4201                 ti += group->packages[pi]->typeIdOffset;
4202
4203                 const uint32_t identifier = findEntry(group, ti, name, nameLen,
4204                         outTypeSpecFlags);
4205                 if (identifier != 0) {
4206                     if (fakePublic && outTypeSpecFlags) {
4207                         *outTypeSpecFlags |= ResTable_typeSpec::SPEC_PUBLIC;
4208                     }
4209                     return identifier;
4210                 }
4211             } while (strzcmp16(attr.string(), attr.size(), targetType, targetTypeLen) == 0
4212                     && (targetType = attrPrivate.string())
4213                     && (targetTypeLen = attrPrivate.size())
4214             );
4215         }
4216         break;
4217     }
4218     return 0;
4219 }
4220
4221 uint32_t ResTable::findEntry(const PackageGroup* group, ssize_t typeIndex, const char16_t* name,
4222         size_t nameLen, uint32_t* outTypeSpecFlags) const {
4223     const TypeList& typeList = group->types[typeIndex];
4224     const size_t typeCount = typeList.size();
4225     for (size_t i = 0; i < typeCount; i++) {
4226         const Type* t = typeList[i];
4227         const ssize_t ei = t->package->keyStrings.indexOfString(name, nameLen);
4228         if (ei < 0) {
4229             continue;
4230         }
4231
4232         const size_t configCount = t->configs.size();
4233         for (size_t j = 0; j < configCount; j++) {
4234             const TypeVariant tv(t->configs[j]);
4235             for (TypeVariant::iterator iter = tv.beginEntries();
4236                  iter != tv.endEntries();
4237                  iter++) {
4238                 const ResTable_entry* entry = *iter;
4239                 if (entry == NULL) {
4240                     continue;
4241                 }
4242
4243                 if (dtohl(entry->key.index) == (size_t) ei) {
4244                     uint32_t resId = Res_MAKEID(group->id - 1, typeIndex, iter.index());
4245                     if (outTypeSpecFlags) {
4246                         Entry result;
4247                         if (getEntry(group, typeIndex, iter.index(), NULL, &result) != NO_ERROR) {
4248                             ALOGW("Failed to find spec flags for 0x%08x", resId);
4249                             return 0;
4250                         }
4251                         *outTypeSpecFlags = result.specFlags;
4252                     }
4253                     return resId;
4254                 }
4255             }
4256         }
4257     }
4258     return 0;
4259 }
4260
4261 bool ResTable::expandResourceRef(const char16_t* refStr, size_t refLen,
4262                                  String16* outPackage,
4263                                  String16* outType,
4264                                  String16* outName,
4265                                  const String16* defType,
4266                                  const String16* defPackage,
4267                                  const char** outErrorMsg,
4268                                  bool* outPublicOnly)
4269 {
4270     const char16_t* packageEnd = NULL;
4271     const char16_t* typeEnd = NULL;
4272     const char16_t* p = refStr;
4273     const char16_t* const end = p + refLen;
4274     while (p < end) {
4275         if (*p == ':') packageEnd = p;
4276         else if (*p == '/') {
4277             typeEnd = p;
4278             break;
4279         }
4280         p++;
4281     }
4282     p = refStr;
4283     if (*p == '@') p++;
4284
4285     if (outPublicOnly != NULL) {
4286         *outPublicOnly = true;
4287     }
4288     if (*p == '*') {
4289         p++;
4290         if (outPublicOnly != NULL) {
4291             *outPublicOnly = false;
4292         }
4293     }
4294
4295     if (packageEnd) {
4296         *outPackage = String16(p, packageEnd-p);
4297         p = packageEnd+1;
4298     } else {
4299         if (!defPackage) {
4300             if (outErrorMsg) {
4301                 *outErrorMsg = "No resource package specified";
4302             }
4303             return false;
4304         }
4305         *outPackage = *defPackage;
4306     }
4307     if (typeEnd) {
4308         *outType = String16(p, typeEnd-p);
4309         p = typeEnd+1;
4310     } else {
4311         if (!defType) {
4312             if (outErrorMsg) {
4313                 *outErrorMsg = "No resource type specified";
4314             }
4315             return false;
4316         }
4317         *outType = *defType;
4318     }
4319     *outName = String16(p, end-p);
4320     if(**outPackage == 0) {
4321         if(outErrorMsg) {
4322             *outErrorMsg = "Resource package cannot be an empty string";
4323         }
4324         return false;
4325     }
4326     if(**outType == 0) {
4327         if(outErrorMsg) {
4328             *outErrorMsg = "Resource type cannot be an empty string";
4329         }
4330         return false;
4331     }
4332     if(**outName == 0) {
4333         if(outErrorMsg) {
4334             *outErrorMsg = "Resource id cannot be an empty string";
4335         }
4336         return false;
4337     }
4338     return true;
4339 }
4340
4341 static uint32_t get_hex(char c, bool* outError)
4342 {
4343     if (c >= '0' && c <= '9') {
4344         return c - '0';
4345     } else if (c >= 'a' && c <= 'f') {
4346         return c - 'a' + 0xa;
4347     } else if (c >= 'A' && c <= 'F') {
4348         return c - 'A' + 0xa;
4349     }
4350     *outError = true;
4351     return 0;
4352 }
4353
4354 struct unit_entry
4355 {
4356     const char* name;
4357     size_t len;
4358     uint8_t type;
4359     uint32_t unit;
4360     float scale;
4361 };
4362
4363 static const unit_entry unitNames[] = {
4364     { "px", strlen("px"), Res_value::TYPE_DIMENSION, Res_value::COMPLEX_UNIT_PX, 1.0f },
4365     { "dip", strlen("dip"), Res_value::TYPE_DIMENSION, Res_value::COMPLEX_UNIT_DIP, 1.0f },
4366     { "dp", strlen("dp"), Res_value::TYPE_DIMENSION, Res_value::COMPLEX_UNIT_DIP, 1.0f },
4367     { "sp", strlen("sp"), Res_value::TYPE_DIMENSION, Res_value::COMPLEX_UNIT_SP, 1.0f },
4368     { "pt", strlen("pt"), Res_value::TYPE_DIMENSION, Res_value::COMPLEX_UNIT_PT, 1.0f },
4369     { "in", strlen("in"), Res_value::TYPE_DIMENSION, Res_value::COMPLEX_UNIT_IN, 1.0f },
4370     { "mm", strlen("mm"), Res_value::TYPE_DIMENSION, Res_value::COMPLEX_UNIT_MM, 1.0f },
4371     { "%", strlen("%"), Res_value::TYPE_FRACTION, Res_value::COMPLEX_UNIT_FRACTION, 1.0f/100 },
4372     { "%p", strlen("%p"), Res_value::TYPE_FRACTION, Res_value::COMPLEX_UNIT_FRACTION_PARENT, 1.0f/100 },
4373     { NULL, 0, 0, 0, 0 }
4374 };
4375
4376 static bool parse_unit(const char* str, Res_value* outValue,
4377                        float* outScale, const char** outEnd)
4378 {
4379     const char* end = str;
4380     while (*end != 0 && !isspace((unsigned char)*end)) {
4381         end++;
4382     }
4383     const size_t len = end-str;
4384
4385     const char* realEnd = end;
4386     while (*realEnd != 0 && isspace((unsigned char)*realEnd)) {
4387         realEnd++;
4388     }
4389     if (*realEnd != 0) {
4390         return false;
4391     }
4392
4393     const unit_entry* cur = unitNames;
4394     while (cur->name) {
4395         if (len == cur->len && strncmp(cur->name, str, len) == 0) {
4396             outValue->dataType = cur->type;
4397             outValue->data = cur->unit << Res_value::COMPLEX_UNIT_SHIFT;
4398             *outScale = cur->scale;
4399             *outEnd = end;
4400             //printf("Found unit %s for %s\n", cur->name, str);
4401             return true;
4402         }
4403         cur++;
4404     }
4405
4406     return false;
4407 }
4408
4409
4410 bool ResTable::stringToInt(const char16_t* s, size_t len, Res_value* outValue)
4411 {
4412     while (len > 0 && isspace16(*s)) {
4413         s++;
4414         len--;
4415     }
4416
4417     if (len <= 0) {
4418         return false;
4419     }
4420
4421     size_t i = 0;
4422     int32_t val = 0;
4423     bool neg = false;
4424
4425     if (*s == '-') {
4426         neg = true;
4427         i++;
4428     }
4429
4430     if (s[i] < '0' || s[i] > '9') {
4431         return false;
4432     }
4433
4434     // Decimal or hex?
4435     if (s[i] == '0' && s[i+1] == 'x') {
4436         if (outValue)
4437             outValue->dataType = outValue->TYPE_INT_HEX;
4438         i += 2;
4439         bool error = false;
4440         while (i < len && !error) {
4441             val = (val*16) + get_hex(s[i], &error);
4442             i++;
4443         }
4444         if (error) {
4445             return false;
4446         }
4447     } else {
4448         if (outValue)
4449             outValue->dataType = outValue->TYPE_INT_DEC;
4450         while (i < len) {
4451             if (s[i] < '0' || s[i] > '9') {
4452                 return false;
4453             }
4454             val = (val*10) + s[i]-'0';
4455             i++;
4456         }
4457     }
4458
4459     if (neg) val = -val;
4460
4461     while (i < len && isspace16(s[i])) {
4462         i++;
4463     }
4464
4465     if (i == len) {
4466         if (outValue)
4467             outValue->data = val;
4468         return true;
4469     }
4470
4471     return false;
4472 }
4473
4474 bool ResTable::stringToFloat(const char16_t* s, size_t len, Res_value* outValue)
4475 {
4476     while (len > 0 && isspace16(*s)) {
4477         s++;
4478         len--;
4479     }
4480
4481     if (len <= 0) {
4482         return false;
4483     }
4484
4485     char buf[128];
4486     int i=0;
4487     while (len > 0 && *s != 0 && i < 126) {
4488         if (*s > 255) {
4489             return false;
4490         }
4491         buf[i++] = *s++;
4492         len--;
4493     }
4494
4495     if (len > 0) {
4496         return false;
4497     }
4498     if (buf[0] < '0' && buf[0] > '9' && buf[0] != '.') {
4499         return false;
4500     }
4501
4502     buf[i] = 0;
4503     const char* end;
4504     float f = strtof(buf, (char**)&end);
4505
4506     if (*end != 0 && !isspace((unsigned char)*end)) {
4507         // Might be a unit...
4508         float scale;
4509         if (parse_unit(end, outValue, &scale, &end)) {
4510             f *= scale;
4511             const bool neg = f < 0;
4512             if (neg) f = -f;
4513             uint64_t bits = (uint64_t)(f*(1<<23)+.5f);
4514             uint32_t radix;
4515             uint32_t shift;
4516             if ((bits&0x7fffff) == 0) {
4517                 // Always use 23p0 if there is no fraction, just to make
4518                 // things easier to read.
4519                 radix = Res_value::COMPLEX_RADIX_23p0;
4520                 shift = 23;
4521             } else if ((bits&0xffffffffff800000LL) == 0) {
4522                 // Magnitude is zero -- can fit in 0 bits of precision.
4523                 radix = Res_value::COMPLEX_RADIX_0p23;
4524                 shift = 0;
4525             } else if ((bits&0xffffffff80000000LL) == 0) {
4526                 // Magnitude can fit in 8 bits of precision.
4527                 radix = Res_value::COMPLEX_RADIX_8p15;
4528                 shift = 8;
4529             } else if ((bits&0xffffff8000000000LL) == 0) {
4530                 // Magnitude can fit in 16 bits of precision.
4531                 radix = Res_value::COMPLEX_RADIX_16p7;
4532                 shift = 16;
4533             } else {
4534                 // Magnitude needs entire range, so no fractional part.
4535                 radix = Res_value::COMPLEX_RADIX_23p0;
4536                 shift = 23;
4537             }
4538             int32_t mantissa = (int32_t)(
4539                 (bits>>shift) & Res_value::COMPLEX_MANTISSA_MASK);
4540             if (neg) {
4541                 mantissa = (-mantissa) & Res_value::COMPLEX_MANTISSA_MASK;
4542             }
4543             outValue->data |=
4544                 (radix<<Res_value::COMPLEX_RADIX_SHIFT)
4545                 | (mantissa<<Res_value::COMPLEX_MANTISSA_SHIFT);
4546             //printf("Input value: %f 0x%016Lx, mult: %f, radix: %d, shift: %d, final: 0x%08x\n",
4547             //       f * (neg ? -1 : 1), bits, f*(1<<23),
4548             //       radix, shift, outValue->data);
4549             return true;
4550         }
4551         return false;
4552     }
4553
4554     while (*end != 0 && isspace((unsigned char)*end)) {
4555         end++;
4556     }
4557
4558     if (*end == 0) {
4559         if (outValue) {
4560             outValue->dataType = outValue->TYPE_FLOAT;
4561             *(float*)(&outValue->data) = f;
4562             return true;
4563         }
4564     }
4565
4566     return false;
4567 }
4568
4569 bool ResTable::stringToValue(Res_value* outValue, String16* outString,
4570                              const char16_t* s, size_t len,
4571                              bool preserveSpaces, bool coerceType,
4572                              uint32_t attrID,
4573                              const String16* defType,
4574                              const String16* defPackage,
4575                              Accessor* accessor,
4576                              void* accessorCookie,
4577                              uint32_t attrType,
4578                              bool enforcePrivate) const
4579 {
4580     bool localizationSetting = accessor != NULL && accessor->getLocalizationSetting();
4581     const char* errorMsg = NULL;
4582
4583     outValue->size = sizeof(Res_value);
4584     outValue->res0 = 0;
4585
4586     // First strip leading/trailing whitespace.  Do this before handling
4587     // escapes, so they can be used to force whitespace into the string.
4588     if (!preserveSpaces) {
4589         while (len > 0 && isspace16(*s)) {
4590             s++;
4591             len--;
4592         }
4593         while (len > 0 && isspace16(s[len-1])) {
4594             len--;
4595         }
4596         // If the string ends with '\', then we keep the space after it.
4597         if (len > 0 && s[len-1] == '\\' && s[len] != 0) {
4598             len++;
4599         }
4600     }
4601
4602     //printf("Value for: %s\n", String8(s, len).string());
4603
4604     uint32_t l10nReq = ResTable_map::L10N_NOT_REQUIRED;
4605     uint32_t attrMin = 0x80000000, attrMax = 0x7fffffff;
4606     bool fromAccessor = false;
4607     if (attrID != 0 && !Res_INTERNALID(attrID)) {
4608         const ssize_t p = getResourcePackageIndex(attrID);
4609         const bag_entry* bag;
4610         ssize_t cnt = p >= 0 ? lockBag(attrID, &bag) : -1;
4611         //printf("For attr 0x%08x got bag of %d\n", attrID, cnt);
4612         if (cnt >= 0) {
4613             while (cnt > 0) {
4614                 //printf("Entry 0x%08x = 0x%08x\n", bag->map.name.ident, bag->map.value.data);
4615                 switch (bag->map.name.ident) {
4616                 case ResTable_map::ATTR_TYPE:
4617                     attrType = bag->map.value.data;
4618                     break;
4619                 case ResTable_map::ATTR_MIN:
4620                     attrMin = bag->map.value.data;
4621                     break;
4622                 case ResTable_map::ATTR_MAX:
4623                     attrMax = bag->map.value.data;
4624                     break;
4625                 case ResTable_map::ATTR_L10N:
4626                     l10nReq = bag->map.value.data;
4627                     break;
4628                 }
4629                 bag++;
4630                 cnt--;
4631             }
4632             unlockBag(bag);
4633         } else if (accessor && accessor->getAttributeType(attrID, &attrType)) {
4634             fromAccessor = true;
4635             if (attrType == ResTable_map::TYPE_ENUM
4636                     || attrType == ResTable_map::TYPE_FLAGS
4637                     || attrType == ResTable_map::TYPE_INTEGER) {
4638                 accessor->getAttributeMin(attrID, &attrMin);
4639                 accessor->getAttributeMax(attrID, &attrMax);
4640             }
4641             if (localizationSetting) {
4642                 l10nReq = accessor->getAttributeL10N(attrID);
4643             }
4644         }
4645     }
4646
4647     const bool canStringCoerce =
4648         coerceType && (attrType&ResTable_map::TYPE_STRING) != 0;
4649
4650     if (*s == '@') {
4651         outValue->dataType = outValue->TYPE_REFERENCE;
4652
4653         // Note: we don't check attrType here because the reference can
4654         // be to any other type; we just need to count on the client making
4655         // sure the referenced type is correct.
4656
4657         //printf("Looking up ref: %s\n", String8(s, len).string());
4658
4659         // It's a reference!
4660         if (len == 5 && s[1]=='n' && s[2]=='u' && s[3]=='l' && s[4]=='l') {
4661             // Special case @null as undefined. This will be converted by
4662             // AssetManager to TYPE_NULL with data DATA_NULL_UNDEFINED.
4663             outValue->data = 0;
4664             return true;
4665         } else if (len == 6 && s[1]=='e' && s[2]=='m' && s[3]=='p' && s[4]=='t' && s[5]=='y') {
4666             // Special case @empty as explicitly defined empty value.
4667             outValue->dataType = Res_value::TYPE_NULL;
4668             outValue->data = Res_value::DATA_NULL_EMPTY;
4669             return true;
4670         } else {
4671             bool createIfNotFound = false;
4672             const char16_t* resourceRefName;
4673             int resourceNameLen;
4674             if (len > 2 && s[1] == '+') {
4675                 createIfNotFound = true;
4676                 resourceRefName = s + 2;
4677                 resourceNameLen = len - 2;
4678             } else if (len > 2 && s[1] == '*') {
4679                 enforcePrivate = false;
4680                 resourceRefName = s + 2;
4681                 resourceNameLen = len - 2;
4682             } else {
4683                 createIfNotFound = false;
4684                 resourceRefName = s + 1;
4685                 resourceNameLen = len - 1;
4686             }
4687             String16 package, type, name;
4688             if (!expandResourceRef(resourceRefName,resourceNameLen, &package, &type, &name,
4689                                    defType, defPackage, &errorMsg)) {
4690                 if (accessor != NULL) {
4691                     accessor->reportError(accessorCookie, errorMsg);
4692                 }
4693                 return false;
4694             }
4695
4696             uint32_t specFlags = 0;
4697             uint32_t rid = identifierForName(name.string(), name.size(), type.string(),
4698                     type.size(), package.string(), package.size(), &specFlags);
4699             if (rid != 0) {
4700                 if (enforcePrivate) {
4701                     if (accessor == NULL || accessor->getAssetsPackage() != package) {
4702                         if ((specFlags&ResTable_typeSpec::SPEC_PUBLIC) == 0) {
4703                             if (accessor != NULL) {
4704                                 accessor->reportError(accessorCookie, "Resource is not public.");
4705                             }
4706                             return false;
4707                         }
4708                     }
4709                 }
4710
4711                 if (accessor) {
4712                     rid = Res_MAKEID(
4713                         accessor->getRemappedPackage(Res_GETPACKAGE(rid)),
4714                         Res_GETTYPE(rid), Res_GETENTRY(rid));
4715                     TABLE_NOISY(printf("Incl %s:%s/%s: 0x%08x\n",
4716                            String8(package).string(), String8(type).string(),
4717                            String8(name).string(), rid));
4718                 }
4719
4720                 uint32_t packageId = Res_GETPACKAGE(rid) + 1;
4721                 if (packageId != APP_PACKAGE_ID && packageId != SYS_PACKAGE_ID) {
4722                     outValue->dataType = Res_value::TYPE_DYNAMIC_REFERENCE;
4723                 }
4724                 outValue->data = rid;
4725                 return true;
4726             }
4727
4728             if (accessor) {
4729                 uint32_t rid = accessor->getCustomResourceWithCreation(package, type, name,
4730                                                                        createIfNotFound);
4731                 if (rid != 0) {
4732                     TABLE_NOISY(printf("Pckg %s:%s/%s: 0x%08x\n",
4733                            String8(package).string(), String8(type).string(),
4734                            String8(name).string(), rid));
4735                     uint32_t packageId = Res_GETPACKAGE(rid) + 1;
4736                     if (packageId == 0x00) {
4737                         outValue->data = rid;
4738                         outValue->dataType = Res_value::TYPE_DYNAMIC_REFERENCE;
4739                         return true;
4740                     } else if (packageId == APP_PACKAGE_ID || packageId == SYS_PACKAGE_ID) {
4741                         // We accept packageId's generated as 0x01 in order to support
4742                         // building the android system resources
4743                         outValue->data = rid;
4744                         return true;
4745                     }
4746                 }
4747             }
4748         }
4749
4750         if (accessor != NULL) {
4751             accessor->reportError(accessorCookie, "No resource found that matches the given name");
4752         }
4753         return false;
4754     }
4755
4756     // if we got to here, and localization is required and it's not a reference,
4757     // complain and bail.
4758     if (l10nReq == ResTable_map::L10N_SUGGESTED) {
4759         if (localizationSetting) {
4760             if (accessor != NULL) {
4761                 accessor->reportError(accessorCookie, "This attribute must be localized.");
4762             }
4763         }
4764     }
4765
4766     if (*s == '#') {
4767         // It's a color!  Convert to an integer of the form 0xaarrggbb.
4768         uint32_t color = 0;
4769         bool error = false;
4770         if (len == 4) {
4771             outValue->dataType = outValue->TYPE_INT_COLOR_RGB4;
4772             color |= 0xFF000000;
4773             color |= get_hex(s[1], &error) << 20;
4774             color |= get_hex(s[1], &error) << 16;
4775             color |= get_hex(s[2], &error) << 12;
4776             color |= get_hex(s[2], &error) << 8;
4777             color |= get_hex(s[3], &error) << 4;
4778             color |= get_hex(s[3], &error);
4779         } else if (len == 5) {
4780             outValue->dataType = outValue->TYPE_INT_COLOR_ARGB4;
4781             color |= get_hex(s[1], &error) << 28;
4782             color |= get_hex(s[1], &error) << 24;
4783             color |= get_hex(s[2], &error) << 20;
4784             color |= get_hex(s[2], &error) << 16;
4785             color |= get_hex(s[3], &error) << 12;
4786             color |= get_hex(s[3], &error) << 8;
4787             color |= get_hex(s[4], &error) << 4;
4788             color |= get_hex(s[4], &error);
4789         } else if (len == 7) {
4790             outValue->dataType = outValue->TYPE_INT_COLOR_RGB8;
4791             color |= 0xFF000000;
4792             color |= get_hex(s[1], &error) << 20;
4793             color |= get_hex(s[2], &error) << 16;
4794             color |= get_hex(s[3], &error) << 12;
4795             color |= get_hex(s[4], &error) << 8;
4796             color |= get_hex(s[5], &error) << 4;
4797             color |= get_hex(s[6], &error);
4798         } else if (len == 9) {
4799             outValue->dataType = outValue->TYPE_INT_COLOR_ARGB8;
4800             color |= get_hex(s[1], &error) << 28;
4801             color |= get_hex(s[2], &error) << 24;
4802             color |= get_hex(s[3], &error) << 20;
4803             color |= get_hex(s[4], &error) << 16;
4804             color |= get_hex(s[5], &error) << 12;
4805             color |= get_hex(s[6], &error) << 8;
4806             color |= get_hex(s[7], &error) << 4;
4807             color |= get_hex(s[8], &error);
4808         } else {
4809             error = true;
4810         }
4811         if (!error) {
4812             if ((attrType&ResTable_map::TYPE_COLOR) == 0) {
4813                 if (!canStringCoerce) {
4814                     if (accessor != NULL) {
4815                         accessor->reportError(accessorCookie,
4816                                 "Color types not allowed");
4817                     }
4818                     return false;
4819                 }
4820             } else {
4821                 outValue->data = color;
4822                 //printf("Color input=%s, output=0x%x\n", String8(s, len).string(), color);
4823                 return true;
4824             }
4825         } else {
4826             if ((attrType&ResTable_map::TYPE_COLOR) != 0) {
4827                 if (accessor != NULL) {
4828                     accessor->reportError(accessorCookie, "Color value not valid --"
4829                             " must be #rgb, #argb, #rrggbb, or #aarrggbb");
4830                 }
4831                 #if 0
4832                 fprintf(stderr, "%s: Color ID %s value %s is not valid\n",
4833                         "Resource File", //(const char*)in->getPrintableSource(),
4834                         String8(*curTag).string(),
4835                         String8(s, len).string());
4836                 #endif
4837                 return false;
4838             }
4839         }
4840     }
4841
4842     if (*s == '?') {
4843         outValue->dataType = outValue->TYPE_ATTRIBUTE;
4844
4845         // Note: we don't check attrType here because the reference can
4846         // be to any other type; we just need to count on the client making
4847         // sure the referenced type is correct.
4848
4849         //printf("Looking up attr: %s\n", String8(s, len).string());
4850
4851         static const String16 attr16("attr");
4852         String16 package, type, name;
4853         if (!expandResourceRef(s+1, len-1, &package, &type, &name,
4854                                &attr16, defPackage, &errorMsg)) {
4855             if (accessor != NULL) {
4856                 accessor->reportError(accessorCookie, errorMsg);
4857             }
4858             return false;
4859         }
4860
4861         //printf("Pkg: %s, Type: %s, Name: %s\n",
4862         //       String8(package).string(), String8(type).string(),
4863         //       String8(name).string());
4864         uint32_t specFlags = 0;
4865         uint32_t rid =
4866             identifierForName(name.string(), name.size(),
4867                               type.string(), type.size(),
4868                               package.string(), package.size(), &specFlags);
4869         if (rid != 0) {
4870             if (enforcePrivate) {
4871                 if ((specFlags&ResTable_typeSpec::SPEC_PUBLIC) == 0) {
4872                     if (accessor != NULL) {
4873                         accessor->reportError(accessorCookie, "Attribute is not public.");
4874                     }
4875                     return false;
4876                 }
4877             }
4878             if (!accessor) {
4879                 outValue->data = rid;
4880                 return true;
4881             }
4882             rid = Res_MAKEID(
4883                 accessor->getRemappedPackage(Res_GETPACKAGE(rid)),
4884                 Res_GETTYPE(rid), Res_GETENTRY(rid));
4885             //printf("Incl %s:%s/%s: 0x%08x\n",
4886             //       String8(package).string(), String8(type).string(),
4887             //       String8(name).string(), rid);
4888             outValue->data = rid;
4889             return true;
4890         }
4891
4892         if (accessor) {
4893             uint32_t rid = accessor->getCustomResource(package, type, name);
4894             if (rid != 0) {
4895                 //printf("Mine %s:%s/%s: 0x%08x\n",
4896                 //       String8(package).string(), String8(type).string(),
4897                 //       String8(name).string(), rid);
4898                 outValue->data = rid;
4899                 return true;
4900             }
4901         }
4902
4903         if (accessor != NULL) {
4904             accessor->reportError(accessorCookie, "No resource found that matches the given name");
4905         }
4906         return false;
4907     }
4908
4909     if (stringToInt(s, len, outValue)) {
4910         if ((attrType&ResTable_map::TYPE_INTEGER) == 0) {
4911             // If this type does not allow integers, but does allow floats,
4912             // fall through on this error case because the float type should
4913             // be able to accept any integer value.
4914             if (!canStringCoerce && (attrType&ResTable_map::TYPE_FLOAT) == 0) {
4915                 if (accessor != NULL) {
4916                     accessor->reportError(accessorCookie, "Integer types not allowed");
4917                 }
4918                 return false;
4919             }
4920         } else {
4921             if (((int32_t)outValue->data) < ((int32_t)attrMin)
4922                     || ((int32_t)outValue->data) > ((int32_t)attrMax)) {
4923                 if (accessor != NULL) {
4924                     accessor->reportError(accessorCookie, "Integer value out of range");
4925                 }
4926                 return false;
4927             }
4928             return true;
4929         }
4930     }
4931
4932     if (stringToFloat(s, len, outValue)) {
4933         if (outValue->dataType == Res_value::TYPE_DIMENSION) {
4934             if ((attrType&ResTable_map::TYPE_DIMENSION) != 0) {
4935                 return true;
4936             }
4937             if (!canStringCoerce) {
4938                 if (accessor != NULL) {
4939                     accessor->reportError(accessorCookie, "Dimension types not allowed");
4940                 }
4941                 return false;
4942             }
4943         } else if (outValue->dataType == Res_value::TYPE_FRACTION) {
4944             if ((attrType&ResTable_map::TYPE_FRACTION) != 0) {
4945                 return true;
4946             }
4947             if (!canStringCoerce) {
4948                 if (accessor != NULL) {
4949                     accessor->reportError(accessorCookie, "Fraction types not allowed");
4950                 }
4951                 return false;
4952             }
4953         } else if ((attrType&ResTable_map::TYPE_FLOAT) == 0) {
4954             if (!canStringCoerce) {
4955                 if (accessor != NULL) {
4956                     accessor->reportError(accessorCookie, "Float types not allowed");
4957                 }
4958                 return false;
4959             }
4960         } else {
4961             return true;
4962         }
4963     }
4964
4965     if (len == 4) {
4966         if ((s[0] == 't' || s[0] == 'T') &&
4967             (s[1] == 'r' || s[1] == 'R') &&
4968             (s[2] == 'u' || s[2] == 'U') &&
4969             (s[3] == 'e' || s[3] == 'E')) {
4970             if ((attrType&ResTable_map::TYPE_BOOLEAN) == 0) {
4971                 if (!canStringCoerce) {
4972                     if (accessor != NULL) {
4973                         accessor->reportError(accessorCookie, "Boolean types not allowed");
4974                     }
4975                     return false;
4976                 }
4977             } else {
4978                 outValue->dataType = outValue->TYPE_INT_BOOLEAN;
4979                 outValue->data = (uint32_t)-1;
4980                 return true;
4981             }
4982         }
4983     }
4984
4985     if (len == 5) {
4986         if ((s[0] == 'f' || s[0] == 'F') &&
4987             (s[1] == 'a' || s[1] == 'A') &&
4988             (s[2] == 'l' || s[2] == 'L') &&
4989             (s[3] == 's' || s[3] == 'S') &&
4990             (s[4] == 'e' || s[4] == 'E')) {
4991             if ((attrType&ResTable_map::TYPE_BOOLEAN) == 0) {
4992                 if (!canStringCoerce) {
4993                     if (accessor != NULL) {
4994                         accessor->reportError(accessorCookie, "Boolean types not allowed");
4995                     }
4996                     return false;
4997                 }
4998             } else {
4999                 outValue->dataType = outValue->TYPE_INT_BOOLEAN;
5000                 outValue->data = 0;
5001                 return true;
5002             }
5003         }
5004     }
5005
5006     if ((attrType&ResTable_map::TYPE_ENUM) != 0) {
5007         const ssize_t p = getResourcePackageIndex(attrID);
5008         const bag_entry* bag;
5009         ssize_t cnt = p >= 0 ? lockBag(attrID, &bag) : -1;
5010         //printf("Got %d for enum\n", cnt);
5011         if (cnt >= 0) {
5012             resource_name rname;
5013             while (cnt > 0) {
5014                 if (!Res_INTERNALID(bag->map.name.ident)) {
5015                     //printf("Trying attr #%08x\n", bag->map.name.ident);
5016                     if (getResourceName(bag->map.name.ident, false, &rname)) {
5017                         #if 0
5018                         printf("Matching %s against %s (0x%08x)\n",
5019                                String8(s, len).string(),
5020                                String8(rname.name, rname.nameLen).string(),
5021                                bag->map.name.ident);
5022                         #endif
5023                         if (strzcmp16(s, len, rname.name, rname.nameLen) == 0) {
5024                             outValue->dataType = bag->map.value.dataType;
5025                             outValue->data = bag->map.value.data;
5026                             unlockBag(bag);
5027                             return true;
5028                         }
5029                     }
5030
5031                 }
5032                 bag++;
5033                 cnt--;
5034             }
5035             unlockBag(bag);
5036         }
5037
5038         if (fromAccessor) {
5039             if (accessor->getAttributeEnum(attrID, s, len, outValue)) {
5040                 return true;
5041             }
5042         }
5043     }
5044
5045     if ((attrType&ResTable_map::TYPE_FLAGS) != 0) {
5046         const ssize_t p = getResourcePackageIndex(attrID);
5047         const bag_entry* bag;
5048         ssize_t cnt = p >= 0 ? lockBag(attrID, &bag) : -1;
5049         //printf("Got %d for flags\n", cnt);
5050         if (cnt >= 0) {
5051             bool failed = false;
5052             resource_name rname;
5053             outValue->dataType = Res_value::TYPE_INT_HEX;
5054             outValue->data = 0;
5055             const char16_t* end = s + len;
5056             const char16_t* pos = s;
5057             while (pos < end && !failed) {
5058                 const char16_t* start = pos;
5059                 pos++;
5060                 while (pos < end && *pos != '|') {
5061                     pos++;
5062                 }
5063                 //printf("Looking for: %s\n", String8(start, pos-start).string());
5064                 const bag_entry* bagi = bag;
5065                 ssize_t i;
5066                 for (i=0; i<cnt; i++, bagi++) {
5067                     if (!Res_INTERNALID(bagi->map.name.ident)) {
5068                         //printf("Trying attr #%08x\n", bagi->map.name.ident);
5069                         if (getResourceName(bagi->map.name.ident, false, &rname)) {
5070                             #if 0
5071                             printf("Matching %s against %s (0x%08x)\n",
5072                                    String8(start,pos-start).string(),
5073                                    String8(rname.name, rname.nameLen).string(),
5074                                    bagi->map.name.ident);
5075                             #endif
5076                             if (strzcmp16(start, pos-start, rname.name, rname.nameLen) == 0) {
5077                                 outValue->data |= bagi->map.value.data;
5078                                 break;
5079                             }
5080                         }
5081                     }
5082                 }
5083                 if (i >= cnt) {
5084                     // Didn't find this flag identifier.
5085                     failed = true;
5086                 }
5087                 if (pos < end) {
5088                     pos++;
5089                 }
5090             }
5091             unlockBag(bag);
5092             if (!failed) {
5093                 //printf("Final flag value: 0x%lx\n", outValue->data);
5094                 return true;
5095             }
5096         }
5097
5098
5099         if (fromAccessor) {
5100             if (accessor->getAttributeFlags(attrID, s, len, outValue)) {
5101                 //printf("Final flag value: 0x%lx\n", outValue->data);
5102                 return true;
5103             }
5104         }
5105     }
5106
5107     if ((attrType&ResTable_map::TYPE_STRING) == 0) {
5108         if (accessor != NULL) {
5109             accessor->reportError(accessorCookie, "String types not allowed");
5110         }
5111         return false;
5112     }
5113
5114     // Generic string handling...
5115     outValue->dataType = outValue->TYPE_STRING;
5116     if (outString) {
5117         bool failed = collectString(outString, s, len, preserveSpaces, &errorMsg);
5118         if (accessor != NULL) {
5119             accessor->reportError(accessorCookie, errorMsg);
5120         }
5121         return failed;
5122     }
5123
5124     return true;
5125 }
5126
5127 bool ResTable::collectString(String16* outString,
5128                              const char16_t* s, size_t len,
5129                              bool preserveSpaces,
5130                              const char** outErrorMsg,
5131                              bool append)
5132 {
5133     String16 tmp;
5134
5135     char quoted = 0;
5136     const char16_t* p = s;
5137     while (p < (s+len)) {
5138         while (p < (s+len)) {
5139             const char16_t c = *p;
5140             if (c == '\\') {
5141                 break;
5142             }
5143             if (!preserveSpaces) {
5144                 if (quoted == 0 && isspace16(c)
5145                     && (c != ' ' || isspace16(*(p+1)))) {
5146                     break;
5147                 }
5148                 if (c == '"' && (quoted == 0 || quoted == '"')) {
5149                     break;
5150                 }
5151                 if (c == '\'' && (quoted == 0 || quoted == '\'')) {
5152                     /*
5153                      * In practice, when people write ' instead of \'
5154                      * in a string, they are doing it by accident
5155                      * instead of really meaning to use ' as a quoting
5156                      * character.  Warn them so they don't lose it.
5157                      */
5158                     if (outErrorMsg) {
5159                         *outErrorMsg = "Apostrophe not preceded by \\";
5160                     }
5161                     return false;
5162                 }
5163             }
5164             p++;
5165         }
5166         if (p < (s+len)) {
5167             if (p > s) {
5168                 tmp.append(String16(s, p-s));
5169             }
5170             if (!preserveSpaces && (*p == '"' || *p == '\'')) {
5171                 if (quoted == 0) {
5172                     quoted = *p;
5173                 } else {
5174                     quoted = 0;
5175                 }
5176                 p++;
5177             } else if (!preserveSpaces && isspace16(*p)) {
5178                 // Space outside of a quote -- consume all spaces and
5179                 // leave a single plain space char.
5180                 tmp.append(String16(" "));
5181                 p++;
5182                 while (p < (s+len) && isspace16(*p)) {
5183                     p++;
5184                 }
5185             } else if (*p == '\\') {
5186                 p++;
5187                 if (p < (s+len)) {
5188                     switch (*p) {
5189                     case 't':
5190                         tmp.append(String16("\t"));
5191                         break;
5192                     case 'n':
5193                         tmp.append(String16("\n"));
5194                         break;
5195                     case '#':
5196                         tmp.append(String16("#"));
5197                         break;
5198                     case '@':
5199                         tmp.append(String16("@"));
5200                         break;
5201                     case '?':
5202                         tmp.append(String16("?"));
5203                         break;
5204                     case '"':
5205                         tmp.append(String16("\""));
5206                         break;
5207                     case '\'':
5208                         tmp.append(String16("'"));
5209                         break;
5210                     case '\\':
5211                         tmp.append(String16("\\"));
5212                         break;
5213                     case 'u':
5214                     {
5215                         char16_t chr = 0;
5216                         int i = 0;
5217                         while (i < 4 && p[1] != 0) {
5218                             p++;
5219                             i++;
5220                             int c;
5221                             if (*p >= '0' && *p <= '9') {
5222                                 c = *p - '0';
5223                             } else if (*p >= 'a' && *p <= 'f') {
5224                                 c = *p - 'a' + 10;
5225                             } else if (*p >= 'A' && *p <= 'F') {
5226                                 c = *p - 'A' + 10;
5227                             } else {
5228                                 if (outErrorMsg) {
5229                                     *outErrorMsg = "Bad character in \\u unicode escape sequence";
5230                                 }
5231                                 return false;
5232                             }
5233                             chr = (chr<<4) | c;
5234                         }
5235                         tmp.append(String16(&chr, 1));
5236                     } break;
5237                     default:
5238                         // ignore unknown escape chars.
5239                         break;
5240                     }
5241                     p++;
5242                 }
5243             }
5244             len -= (p-s);
5245             s = p;
5246         }
5247     }
5248
5249     if (tmp.size() != 0) {
5250         if (len > 0) {
5251             tmp.append(String16(s, len));
5252         }
5253         if (append) {
5254             outString->append(tmp);
5255         } else {
5256             outString->setTo(tmp);
5257         }
5258     } else {
5259         if (append) {
5260             outString->append(String16(s, len));
5261         } else {
5262             outString->setTo(s, len);
5263         }
5264     }
5265
5266     return true;
5267 }
5268
5269 size_t ResTable::getBasePackageCount() const
5270 {
5271     if (mError != NO_ERROR) {
5272         return 0;
5273     }
5274     return mPackageGroups.size();
5275 }
5276
5277 const String16 ResTable::getBasePackageName(size_t idx) const
5278 {
5279     if (mError != NO_ERROR) {
5280         return String16();
5281     }
5282     LOG_FATAL_IF(idx >= mPackageGroups.size(),
5283                  "Requested package index %d past package count %d",
5284                  (int)idx, (int)mPackageGroups.size());
5285     return mPackageGroups[idx]->name;
5286 }
5287
5288 uint32_t ResTable::getBasePackageId(size_t idx) const
5289 {
5290     if (mError != NO_ERROR) {
5291         return 0;
5292     }
5293     LOG_FATAL_IF(idx >= mPackageGroups.size(),
5294                  "Requested package index %d past package count %d",
5295                  (int)idx, (int)mPackageGroups.size());
5296     return mPackageGroups[idx]->id;
5297 }
5298
5299 uint32_t ResTable::getLastTypeIdForPackage(size_t idx) const
5300 {
5301     if (mError != NO_ERROR) {
5302         return 0;
5303     }
5304     LOG_FATAL_IF(idx >= mPackageGroups.size(),
5305             "Requested package index %d past package count %d",
5306             (int)idx, (int)mPackageGroups.size());
5307     const PackageGroup* const group = mPackageGroups[idx];
5308     return group->largestTypeId;
5309 }
5310
5311 size_t ResTable::getTableCount() const
5312 {
5313     return mHeaders.size();
5314 }
5315
5316 const ResStringPool* ResTable::getTableStringBlock(size_t index) const
5317 {
5318     return &mHeaders[index]->values;
5319 }
5320
5321 int32_t ResTable::getTableCookie(size_t index) const
5322 {
5323     return mHeaders[index]->cookie;
5324 }
5325
5326 const DynamicRefTable* ResTable::getDynamicRefTableForCookie(int32_t cookie) const
5327 {
5328     const size_t N = mPackageGroups.size();
5329     for (size_t i = 0; i < N; i++) {
5330         const PackageGroup* pg = mPackageGroups[i];
5331         size_t M = pg->packages.size();
5332         for (size_t j = 0; j < M; j++) {
5333             if (pg->packages[j]->header->cookie == cookie) {
5334                 return &pg->dynamicRefTable;
5335             }
5336         }
5337     }
5338     return NULL;
5339 }
5340
5341 void ResTable::getConfigurations(Vector<ResTable_config>* configs, bool ignoreMipmap) const
5342 {
5343     const size_t packageCount = mPackageGroups.size();
5344     for (size_t i = 0; i < packageCount; i++) {
5345         const PackageGroup* packageGroup = mPackageGroups[i];
5346         const size_t typeCount = packageGroup->types.size();
5347         for (size_t j = 0; j < typeCount; j++) {
5348             const TypeList& typeList = packageGroup->types[j];
5349             const size_t numTypes = typeList.size();
5350             for (size_t k = 0; k < numTypes; k++) {
5351                 const Type* type = typeList[k];
5352                 const ResStringPool& typeStrings = type->package->typeStrings;
5353                 if (ignoreMipmap && typeStrings.string8ObjectAt(
5354                             type->typeSpec->id - 1) == "mipmap") {
5355                     continue;
5356                 }
5357
5358                 const size_t numConfigs = type->configs.size();
5359                 for (size_t m = 0; m < numConfigs; m++) {
5360                     const ResTable_type* config = type->configs[m];
5361                     ResTable_config cfg;
5362                     memset(&cfg, 0, sizeof(ResTable_config));
5363                     cfg.copyFromDtoH(config->config);
5364                     // only insert unique
5365                     const size_t N = configs->size();
5366                     size_t n;
5367                     for (n = 0; n < N; n++) {
5368                         if (0 == (*configs)[n].compare(cfg)) {
5369                             break;
5370                         }
5371                     }
5372                     // if we didn't find it
5373                     if (n == N) {
5374                         configs->add(cfg);
5375                     }
5376                 }
5377             }
5378         }
5379     }
5380 }
5381
5382 void ResTable::getLocales(Vector<String8>* locales) const
5383 {
5384     Vector<ResTable_config> configs;
5385     ALOGV("calling getConfigurations");
5386     getConfigurations(&configs);
5387     ALOGV("called getConfigurations size=%d", (int)configs.size());
5388     const size_t I = configs.size();
5389
5390     char locale[RESTABLE_MAX_LOCALE_LEN];
5391     for (size_t i=0; i<I; i++) {
5392         configs[i].getBcp47Locale(locale);
5393         const size_t J = locales->size();
5394         size_t j;
5395         for (j=0; j<J; j++) {
5396             if (0 == strcmp(locale, (*locales)[j].string())) {
5397                 break;
5398             }
5399         }
5400         if (j == J) {
5401             locales->add(String8(locale));
5402         }
5403     }
5404 }
5405
5406 StringPoolRef::StringPoolRef(const ResStringPool* pool, uint32_t index)
5407     : mPool(pool), mIndex(index) {}
5408
5409 StringPoolRef::StringPoolRef()
5410     : mPool(NULL), mIndex(0) {}
5411
5412 const char* StringPoolRef::string8(size_t* outLen) const {
5413     if (mPool != NULL) {
5414         return mPool->string8At(mIndex, outLen);
5415     }
5416     if (outLen != NULL) {
5417         *outLen = 0;
5418     }
5419     return NULL;
5420 }
5421
5422 const char16_t* StringPoolRef::string16(size_t* outLen) const {
5423     if (mPool != NULL) {
5424         return mPool->stringAt(mIndex, outLen);
5425     }
5426     if (outLen != NULL) {
5427         *outLen = 0;
5428     }
5429     return NULL;
5430 }
5431
5432 bool ResTable::getResourceFlags(uint32_t resID, uint32_t* outFlags) const {
5433     if (mError != NO_ERROR) {
5434         return false;
5435     }
5436
5437     const ssize_t p = getResourcePackageIndex(resID);
5438     const int t = Res_GETTYPE(resID);
5439     const int e = Res_GETENTRY(resID);
5440
5441     if (p < 0) {
5442         if (Res_GETPACKAGE(resID)+1 == 0) {
5443             ALOGW("No package identifier when getting flags for resource number 0x%08x", resID);
5444         } else {
5445             ALOGW("No known package when getting flags for resource number 0x%08x", resID);
5446         }
5447         return false;
5448     }
5449     if (t < 0) {
5450         ALOGW("No type identifier when getting flags for resource number 0x%08x", resID);
5451         return false;
5452     }
5453
5454     const PackageGroup* const grp = mPackageGroups[p];
5455     if (grp == NULL) {
5456         ALOGW("Bad identifier when getting flags for resource number 0x%08x", resID);
5457         return false;
5458     }
5459
5460     Entry entry;
5461     status_t err = getEntry(grp, t, e, NULL, &entry);
5462     if (err != NO_ERROR) {
5463         return false;
5464     }
5465
5466     *outFlags = entry.specFlags;
5467     return true;
5468 }
5469
5470 status_t ResTable::getEntry(
5471         const PackageGroup* packageGroup, int typeIndex, int entryIndex,
5472         const ResTable_config* config,
5473         Entry* outEntry) const
5474 {
5475     const TypeList& typeList = packageGroup->types[typeIndex];
5476     if (typeList.isEmpty()) {
5477         ALOGV("Skipping entry type index 0x%02x because type is NULL!\n", typeIndex);
5478         return BAD_TYPE;
5479     }
5480
5481     const ResTable_type* bestType = NULL;
5482     uint32_t bestOffset = ResTable_type::NO_ENTRY;
5483     const Package* bestPackage = NULL;
5484     uint32_t specFlags = 0;
5485     uint8_t actualTypeIndex = typeIndex;
5486     ResTable_config bestConfig;
5487     memset(&bestConfig, 0, sizeof(bestConfig));
5488
5489     // Iterate over the Types of each package.
5490     const size_t typeCount = typeList.size();
5491     for (size_t i = 0; i < typeCount; i++) {
5492         const Type* const typeSpec = typeList[i];
5493
5494         int realEntryIndex = entryIndex;
5495         int realTypeIndex = typeIndex;
5496         bool currentTypeIsOverlay = false;
5497
5498         // Runtime overlay packages provide a mapping of app resource
5499         // ID to package resource ID.
5500         if (typeSpec->idmapEntries.hasEntries()) {
5501             uint16_t overlayEntryIndex;
5502             if (typeSpec->idmapEntries.lookup(entryIndex, &overlayEntryIndex) != NO_ERROR) {
5503                 // No such mapping exists
5504                 continue;
5505             }
5506             realEntryIndex = overlayEntryIndex;
5507             realTypeIndex = typeSpec->idmapEntries.overlayTypeId() - 1;
5508             currentTypeIsOverlay = true;
5509         }
5510
5511         if (static_cast<size_t>(realEntryIndex) >= typeSpec->entryCount) {
5512             ALOGW("For resource 0x%08x, entry index(%d) is beyond type entryCount(%d)",
5513                     Res_MAKEID(packageGroup->id - 1, typeIndex, entryIndex),
5514                     entryIndex, static_cast<int>(typeSpec->entryCount));
5515             // We should normally abort here, but some legacy apps declare
5516             // resources in the 'android' package (old bug in AAPT).
5517             continue;
5518         }
5519
5520         // Aggregate all the flags for each package that defines this entry.
5521         if (typeSpec->typeSpecFlags != NULL) {
5522             specFlags |= dtohl(typeSpec->typeSpecFlags[realEntryIndex]);
5523         } else {
5524             specFlags = -1;
5525         }
5526
5527         const size_t numConfigs = typeSpec->configs.size();
5528         for (size_t c = 0; c < numConfigs; c++) {
5529             const ResTable_type* const thisType = typeSpec->configs[c];
5530             if (thisType == NULL) {
5531                 continue;
5532             }
5533
5534             ResTable_config thisConfig;
5535             thisConfig.copyFromDtoH(thisType->config);
5536
5537             // Check to make sure this one is valid for the current parameters.
5538             if (config != NULL && !thisConfig.match(*config)) {
5539                 continue;
5540             }
5541
5542             // Check if there is the desired entry in this type.
5543             const uint8_t* const end = reinterpret_cast<const uint8_t*>(thisType)
5544                     + dtohl(thisType->header.size);
5545             const uint32_t* const eindex = reinterpret_cast<const uint32_t*>(
5546                     reinterpret_cast<const uint8_t*>(thisType) + dtohs(thisType->header.headerSize));
5547
5548             uint32_t thisOffset = dtohl(eindex[realEntryIndex]);
5549             if (thisOffset == ResTable_type::NO_ENTRY) {
5550                 // There is no entry for this index and configuration.
5551                 continue;
5552             }
5553
5554             if (bestType != NULL) {
5555                 // Check if this one is less specific than the last found.  If so,
5556                 // we will skip it.  We check starting with things we most care
5557                 // about to those we least care about.
5558                 if (!thisConfig.isBetterThan(bestConfig, config)) {
5559                     if (!currentTypeIsOverlay || thisConfig.compare(bestConfig) != 0) {
5560                         continue;
5561                     }
5562                 }
5563             }
5564
5565             bestType = thisType;
5566             bestOffset = thisOffset;
5567             bestConfig = thisConfig;
5568             bestPackage = typeSpec->package;
5569             actualTypeIndex = realTypeIndex;
5570
5571             // If no config was specified, any type will do, so skip
5572             if (config == NULL) {
5573                 break;
5574             }
5575         }
5576     }
5577
5578     if (bestType == NULL) {
5579         return BAD_INDEX;
5580     }
5581
5582     bestOffset += dtohl(bestType->entriesStart);
5583
5584     if (bestOffset > (dtohl(bestType->header.size)-sizeof(ResTable_entry))) {
5585         ALOGW("ResTable_entry at 0x%x is beyond type chunk data 0x%x",
5586                 bestOffset, dtohl(bestType->header.size));
5587         return BAD_TYPE;
5588     }
5589     if ((bestOffset & 0x3) != 0) {
5590         ALOGW("ResTable_entry at 0x%x is not on an integer boundary", bestOffset);
5591         return BAD_TYPE;
5592     }
5593
5594     const ResTable_entry* const entry = reinterpret_cast<const ResTable_entry*>(
5595             reinterpret_cast<const uint8_t*>(bestType) + bestOffset);
5596     if (dtohs(entry->size) < sizeof(*entry)) {
5597         ALOGW("ResTable_entry size 0x%x is too small", dtohs(entry->size));
5598         return BAD_TYPE;
5599     }
5600
5601     if (outEntry != NULL) {
5602         outEntry->entry = entry;
5603         outEntry->config = bestConfig;
5604         outEntry->type = bestType;
5605         outEntry->specFlags = specFlags;
5606         outEntry->package = bestPackage;
5607         outEntry->typeStr = StringPoolRef(&bestPackage->typeStrings, actualTypeIndex - bestPackage->typeIdOffset);
5608         outEntry->keyStr = StringPoolRef(&bestPackage->keyStrings, dtohl(entry->key.index));
5609     }
5610     return NO_ERROR;
5611 }
5612
5613 status_t ResTable::parsePackage(const ResTable_package* const pkg,
5614                                 const Header* const header)
5615 {
5616     const uint8_t* base = (const uint8_t*)pkg;
5617     status_t err = validate_chunk(&pkg->header, sizeof(*pkg) - sizeof(pkg->typeIdOffset),
5618                                   header->dataEnd, "ResTable_package");
5619     if (err != NO_ERROR) {
5620         return (mError=err);
5621     }
5622
5623     const uint32_t pkgSize = dtohl(pkg->header.size);
5624
5625     if (dtohl(pkg->typeStrings) >= pkgSize) {
5626         ALOGW("ResTable_package type strings at 0x%x are past chunk size 0x%x.",
5627              dtohl(pkg->typeStrings), pkgSize);
5628         return (mError=BAD_TYPE);
5629     }
5630     if ((dtohl(pkg->typeStrings)&0x3) != 0) {
5631         ALOGW("ResTable_package type strings at 0x%x is not on an integer boundary.",
5632              dtohl(pkg->typeStrings));
5633         return (mError=BAD_TYPE);
5634     }
5635     if (dtohl(pkg->keyStrings) >= pkgSize) {
5636         ALOGW("ResTable_package key strings at 0x%x are past chunk size 0x%x.",
5637              dtohl(pkg->keyStrings), pkgSize);
5638         return (mError=BAD_TYPE);
5639     }
5640     if ((dtohl(pkg->keyStrings)&0x3) != 0) {
5641         ALOGW("ResTable_package key strings at 0x%x is not on an integer boundary.",
5642              dtohl(pkg->keyStrings));
5643         return (mError=BAD_TYPE);
5644     }
5645
5646     uint32_t id = dtohl(pkg->id);
5647     KeyedVector<uint8_t, IdmapEntries> idmapEntries;
5648
5649     if (header->resourceIDMap != NULL) {
5650         uint8_t targetPackageId = 0;
5651         status_t err = parseIdmap(header->resourceIDMap, header->resourceIDMapSize, &targetPackageId, &idmapEntries);
5652         if (err != NO_ERROR) {
5653             ALOGW("Overlay is broken");
5654             return (mError=err);
5655         }
5656         id = targetPackageId;
5657     }
5658
5659     if (id >= 256) {
5660         LOG_ALWAYS_FATAL("Package id out of range");
5661         return NO_ERROR;
5662     } else if (id == 0) {
5663         // This is a library so assign an ID
5664         id = mNextPackageId++;
5665     }
5666
5667     PackageGroup* group = NULL;
5668     Package* package = new Package(this, header, pkg);
5669     if (package == NULL) {
5670         return (mError=NO_MEMORY);
5671     }
5672
5673     err = package->typeStrings.setTo(base+dtohl(pkg->typeStrings),
5674                                    header->dataEnd-(base+dtohl(pkg->typeStrings)));
5675     if (err != NO_ERROR) {
5676         delete group;
5677         delete package;
5678         return (mError=err);
5679     }
5680
5681     err = package->keyStrings.setTo(base+dtohl(pkg->keyStrings),
5682                                   header->dataEnd-(base+dtohl(pkg->keyStrings)));
5683     if (err != NO_ERROR) {
5684         delete group;
5685         delete package;
5686         return (mError=err);
5687     }
5688
5689     size_t idx = mPackageMap[id];
5690     if (idx == 0) {
5691         idx = mPackageGroups.size() + 1;
5692
5693         char16_t tmpName[sizeof(pkg->name)/sizeof(pkg->name[0])];
5694         strcpy16_dtoh(tmpName, pkg->name, sizeof(pkg->name)/sizeof(pkg->name[0]));
5695         group = new PackageGroup(this, String16(tmpName), id);
5696         if (group == NULL) {
5697             delete package;
5698             return (mError=NO_MEMORY);
5699         }
5700
5701         err = mPackageGroups.add(group);
5702         if (err < NO_ERROR) {
5703             return (mError=err);
5704         }
5705
5706         mPackageMap[id] = static_cast<uint8_t>(idx);
5707
5708         // Find all packages that reference this package
5709         size_t N = mPackageGroups.size();
5710         for (size_t i = 0; i < N; i++) {
5711             mPackageGroups[i]->dynamicRefTable.addMapping(
5712                     group->name, static_cast<uint8_t>(group->id));
5713         }
5714     } else {
5715         group = mPackageGroups.itemAt(idx - 1);
5716         if (group == NULL) {
5717             return (mError=UNKNOWN_ERROR);
5718         }
5719     }
5720
5721     err = group->packages.add(package);
5722     if (err < NO_ERROR) {
5723         return (mError=err);
5724     }
5725
5726     // Iterate through all chunks.
5727     const ResChunk_header* chunk =
5728         (const ResChunk_header*)(((const uint8_t*)pkg)
5729                                  + dtohs(pkg->header.headerSize));
5730     const uint8_t* endPos = ((const uint8_t*)pkg) + dtohs(pkg->header.size);
5731     while (((const uint8_t*)chunk) <= (endPos-sizeof(ResChunk_header)) &&
5732            ((const uint8_t*)chunk) <= (endPos-dtohl(chunk->size))) {
5733         TABLE_NOISY(ALOGV("PackageChunk: type=0x%x, headerSize=0x%x, size=0x%x, pos=%p\n",
5734                          dtohs(chunk->type), dtohs(chunk->headerSize), dtohl(chunk->size),
5735                          (void*)(((const uint8_t*)chunk) - ((const uint8_t*)header->header))));
5736         const size_t csize = dtohl(chunk->size);
5737         const uint16_t ctype = dtohs(chunk->type);
5738         if (ctype == RES_TABLE_TYPE_SPEC_TYPE) {
5739             const ResTable_typeSpec* typeSpec = (const ResTable_typeSpec*)(chunk);
5740             err = validate_chunk(&typeSpec->header, sizeof(*typeSpec),
5741                                  endPos, "ResTable_typeSpec");
5742             if (err != NO_ERROR) {
5743                 return (mError=err);
5744             }
5745
5746             const size_t typeSpecSize = dtohl(typeSpec->header.size);
5747             const size_t newEntryCount = dtohl(typeSpec->entryCount);
5748
5749             LOAD_TABLE_NOISY(printf("TypeSpec off %p: type=0x%x, headerSize=0x%x, size=%p\n",
5750                                     (void*)(base-(const uint8_t*)chunk),
5751                                     dtohs(typeSpec->header.type),
5752                                     dtohs(typeSpec->header.headerSize),
5753                                     (void*)typeSpecSize));
5754             // look for block overrun or int overflow when multiplying by 4
5755             if ((dtohl(typeSpec->entryCount) > (INT32_MAX/sizeof(uint32_t))
5756                     || dtohs(typeSpec->header.headerSize)+(sizeof(uint32_t)*newEntryCount)
5757                     > typeSpecSize)) {
5758                 ALOGW("ResTable_typeSpec entry index to %p extends beyond chunk end %p.",
5759                         (void*)(dtohs(typeSpec->header.headerSize) + (sizeof(uint32_t)*newEntryCount)),
5760                         (void*)typeSpecSize);
5761                 return (mError=BAD_TYPE);
5762             }
5763
5764             if (typeSpec->id == 0) {
5765                 ALOGW("ResTable_type has an id of 0.");
5766                 return (mError=BAD_TYPE);
5767             }
5768
5769             if (newEntryCount > 0) {
5770                 uint8_t typeIndex = typeSpec->id - 1;
5771                 ssize_t idmapIndex = idmapEntries.indexOfKey(typeSpec->id);
5772                 if (idmapIndex >= 0) {
5773                     typeIndex = idmapEntries[idmapIndex].targetTypeId() - 1;
5774                 }
5775
5776                 TypeList& typeList = group->types.editItemAt(typeIndex);
5777                 if (!typeList.isEmpty()) {
5778                     const Type* existingType = typeList[0];
5779                     if (existingType->entryCount != newEntryCount && idmapIndex < 0) {
5780                         ALOGW("ResTable_typeSpec entry count inconsistent: given %d, previously %d",
5781                                 (int) newEntryCount, (int) existingType->entryCount);
5782                         // We should normally abort here, but some legacy apps declare
5783                         // resources in the 'android' package (old bug in AAPT).
5784                     }
5785                 }
5786
5787                 Type* t = new Type(header, package, newEntryCount);
5788                 t->typeSpec = typeSpec;
5789                 t->typeSpecFlags = (const uint32_t*)(
5790                         ((const uint8_t*)typeSpec) + dtohs(typeSpec->header.headerSize));
5791                 if (idmapIndex >= 0) {
5792                     t->idmapEntries = idmapEntries[idmapIndex];
5793                 }
5794                 typeList.add(t);
5795                 group->largestTypeId = max(group->largestTypeId, typeSpec->id);
5796             } else {
5797                 ALOGV("Skipping empty ResTable_typeSpec for type %d", typeSpec->id);
5798             }
5799
5800         } else if (ctype == RES_TABLE_TYPE_TYPE) {
5801             const ResTable_type* type = (const ResTable_type*)(chunk);
5802             err = validate_chunk(&type->header, sizeof(*type)-sizeof(ResTable_config)+4,
5803                                  endPos, "ResTable_type");
5804             if (err != NO_ERROR) {
5805                 return (mError=err);
5806             }
5807
5808             const uint32_t typeSize = dtohl(type->header.size);
5809             const size_t newEntryCount = dtohl(type->entryCount);
5810
5811             LOAD_TABLE_NOISY(printf("Type off %p: type=0x%x, headerSize=0x%x, size=%p\n",
5812                                     (void*)(base-(const uint8_t*)chunk),
5813                                     dtohs(type->header.type),
5814                                     dtohs(type->header.headerSize),
5815                                     (void*)typeSize));
5816             if (dtohs(type->header.headerSize)+(sizeof(uint32_t)*newEntryCount)
5817                     > typeSize) {
5818                 ALOGW("ResTable_type entry index to %p extends beyond chunk end 0x%x.",
5819                         (void*)(dtohs(type->header.headerSize) + (sizeof(uint32_t)*newEntryCount)),
5820                         typeSize);
5821                 return (mError=BAD_TYPE);
5822             }
5823
5824             if (newEntryCount != 0
5825                 && dtohl(type->entriesStart) > (typeSize-sizeof(ResTable_entry))) {
5826                 ALOGW("ResTable_type entriesStart at 0x%x extends beyond chunk end 0x%x.",
5827                      dtohl(type->entriesStart), typeSize);
5828                 return (mError=BAD_TYPE);
5829             }
5830
5831             if (type->id == 0) {
5832                 ALOGW("ResTable_type has an id of 0.");
5833                 return (mError=BAD_TYPE);
5834             }
5835
5836             if (newEntryCount > 0) {
5837                 uint8_t typeIndex = type->id - 1;
5838                 ssize_t idmapIndex = idmapEntries.indexOfKey(type->id);
5839                 if (idmapIndex >= 0) {
5840                     typeIndex = idmapEntries[idmapIndex].targetTypeId() - 1;
5841                 }
5842
5843                 TypeList& typeList = group->types.editItemAt(typeIndex);
5844                 if (typeList.isEmpty()) {
5845                     ALOGE("No TypeSpec for type %d", type->id);
5846                     return (mError=BAD_TYPE);
5847                 }
5848
5849                 Type* t = typeList.editItemAt(typeList.size() - 1);
5850                 if (newEntryCount != t->entryCount) {
5851                     ALOGE("ResTable_type entry count inconsistent: given %d, previously %d",
5852                         (int)newEntryCount, (int)t->entryCount);
5853                     return (mError=BAD_TYPE);
5854                 }
5855
5856                 if (t->package != package) {
5857                     ALOGE("No TypeSpec for type %d", type->id);
5858                     return (mError=BAD_TYPE);
5859                 }
5860
5861                 t->configs.add(type);
5862
5863                 TABLE_GETENTRY(
5864                     ResTable_config thisConfig;
5865                     thisConfig.copyFromDtoH(type->config);
5866                     ALOGI("Adding config to type %d: %s\n",
5867                           type->id, thisConfig.toString().string()));
5868             } else {
5869                 ALOGV("Skipping empty ResTable_type for type %d", type->id);
5870             }
5871
5872         } else if (ctype == RES_TABLE_LIBRARY_TYPE) {
5873             if (group->dynamicRefTable.entries().size() == 0) {
5874                 status_t err = group->dynamicRefTable.load((const ResTable_lib_header*) chunk);
5875                 if (err != NO_ERROR) {
5876                     return (mError=err);
5877                 }
5878
5879                 // Fill in the reference table with the entries we already know about.
5880                 size_t N = mPackageGroups.size();
5881                 for (size_t i = 0; i < N; i++) {
5882                     group->dynamicRefTable.addMapping(mPackageGroups[i]->name, mPackageGroups[i]->id);
5883                 }
5884             } else {
5885                 ALOGW("Found multiple library tables, ignoring...");
5886             }
5887         } else {
5888             status_t err = validate_chunk(chunk, sizeof(ResChunk_header),
5889                                           endPos, "ResTable_package:unknown");
5890             if (err != NO_ERROR) {
5891                 return (mError=err);
5892             }
5893         }
5894         chunk = (const ResChunk_header*)
5895             (((const uint8_t*)chunk) + csize);
5896     }
5897
5898     return NO_ERROR;
5899 }
5900
5901 DynamicRefTable::DynamicRefTable(uint8_t packageId)
5902     : mAssignedPackageId(packageId)
5903 {
5904     memset(mLookupTable, 0, sizeof(mLookupTable));
5905
5906     // Reserved package ids
5907     mLookupTable[APP_PACKAGE_ID] = APP_PACKAGE_ID;
5908     mLookupTable[SYS_PACKAGE_ID] = SYS_PACKAGE_ID;
5909 }
5910
5911 status_t DynamicRefTable::load(const ResTable_lib_header* const header)
5912 {
5913     const uint32_t entryCount = dtohl(header->count);
5914     const uint32_t sizeOfEntries = sizeof(ResTable_lib_entry) * entryCount;
5915     const uint32_t expectedSize = dtohl(header->header.size) - dtohl(header->header.headerSize);
5916     if (sizeOfEntries > expectedSize) {
5917         ALOGE("ResTable_lib_header size %u is too small to fit %u entries (x %u).",
5918                 expectedSize, entryCount, (uint32_t)sizeof(ResTable_lib_entry));
5919         return UNKNOWN_ERROR;
5920     }
5921
5922     const ResTable_lib_entry* entry = (const ResTable_lib_entry*)(((uint8_t*) header) +
5923             dtohl(header->header.headerSize));
5924     for (uint32_t entryIndex = 0; entryIndex < entryCount; entryIndex++) {
5925         uint32_t packageId = dtohl(entry->packageId);
5926         char16_t tmpName[sizeof(entry->packageName) / sizeof(char16_t)];
5927         strcpy16_dtoh(tmpName, entry->packageName, sizeof(entry->packageName) / sizeof(char16_t));
5928         LIB_NOISY(ALOGV("Found lib entry %s with id %d\n", String8(tmpName).string(),
5929                 dtohl(entry->packageId)));
5930         if (packageId >= 256) {
5931             ALOGE("Bad package id 0x%08x", packageId);
5932             return UNKNOWN_ERROR;
5933         }
5934         mEntries.replaceValueFor(String16(tmpName), (uint8_t) packageId);
5935         entry = entry + 1;
5936     }
5937     return NO_ERROR;
5938 }
5939
5940 status_t DynamicRefTable::addMappings(const DynamicRefTable& other) {
5941     if (mAssignedPackageId != other.mAssignedPackageId) {
5942         return UNKNOWN_ERROR;
5943     }
5944
5945     const size_t entryCount = other.mEntries.size();
5946     for (size_t i = 0; i < entryCount; i++) {
5947         ssize_t index = mEntries.indexOfKey(other.mEntries.keyAt(i));
5948         if (index < 0) {
5949             mEntries.add(other.mEntries.keyAt(i), other.mEntries[i]);
5950         } else {
5951             if (other.mEntries[i] != mEntries[index]) {
5952                 return UNKNOWN_ERROR;
5953             }
5954         }
5955     }
5956
5957     // Merge the lookup table. No entry can conflict
5958     // (value of 0 means not set).
5959     for (size_t i = 0; i < 256; i++) {
5960         if (mLookupTable[i] != other.mLookupTable[i]) {
5961             if (mLookupTable[i] == 0) {
5962                 mLookupTable[i] = other.mLookupTable[i];
5963             } else if (other.mLookupTable[i] != 0) {
5964                 return UNKNOWN_ERROR;
5965             }
5966         }
5967     }
5968     return NO_ERROR;
5969 }
5970
5971 status_t DynamicRefTable::addMapping(const String16& packageName, uint8_t packageId)
5972 {
5973     ssize_t index = mEntries.indexOfKey(packageName);
5974     if (index < 0) {
5975         return UNKNOWN_ERROR;
5976     }
5977     mLookupTable[mEntries.valueAt(index)] = packageId;
5978     return NO_ERROR;
5979 }
5980
5981 status_t DynamicRefTable::lookupResourceId(uint32_t* resId) const {
5982     uint32_t res = *resId;
5983     size_t packageId = Res_GETPACKAGE(res) + 1;
5984
5985     if (packageId == APP_PACKAGE_ID) {
5986         // No lookup needs to be done, app package IDs are absolute.
5987         return NO_ERROR;
5988     }
5989
5990     if (packageId == 0) {
5991         // The package ID is 0x00. That means that a shared library is accessing
5992         // its own local resource, so we fix up the resource with the calling
5993         // package ID.
5994         *resId |= ((uint32_t) mAssignedPackageId) << 24;
5995         return NO_ERROR;
5996     }
5997
5998     // Do a proper lookup.
5999     uint8_t translatedId = mLookupTable[packageId];
6000     if (translatedId == 0) {
6001         ALOGV("DynamicRefTable(0x%02x): No mapping for build-time package ID 0x%02x.",
6002                 (uint8_t)mAssignedPackageId, (uint8_t)packageId);
6003         for (size_t i = 0; i < 256; i++) {
6004             if (mLookupTable[i] != 0) {
6005                 ALOGV("e[0x%02x] -> 0x%02x", (uint8_t)i, mLookupTable[i]);
6006             }
6007         }
6008         return UNKNOWN_ERROR;
6009     }
6010
6011     *resId = (res & 0x00ffffff) | (((uint32_t) translatedId) << 24);
6012     return NO_ERROR;
6013 }
6014
6015 status_t DynamicRefTable::lookupResourceValue(Res_value* value) const {
6016     if (value->dataType != Res_value::TYPE_DYNAMIC_REFERENCE) {
6017         return NO_ERROR;
6018     }
6019
6020     status_t err = lookupResourceId(&value->data);
6021     if (err != NO_ERROR) {
6022         return err;
6023     }
6024
6025     value->dataType = Res_value::TYPE_REFERENCE;
6026     return NO_ERROR;
6027 }
6028
6029 struct IdmapTypeMap {
6030     ssize_t overlayTypeId;
6031     size_t entryOffset;
6032     Vector<uint32_t> entryMap;
6033 };
6034
6035 status_t ResTable::createIdmap(const ResTable& overlay,
6036         uint32_t targetCrc, uint32_t overlayCrc,
6037         const char* targetPath, const char* overlayPath,
6038         void** outData, size_t* outSize) const
6039 {
6040     // see README for details on the format of map
6041     if (mPackageGroups.size() == 0) {
6042         ALOGW("idmap: target package has no package groups, cannot create idmap\n");
6043         return UNKNOWN_ERROR;
6044     }
6045
6046     if (mPackageGroups[0]->packages.size() == 0) {
6047         ALOGW("idmap: target package has no packages in its first package group, "
6048                 "cannot create idmap\n");
6049         return UNKNOWN_ERROR;
6050     }
6051
6052     KeyedVector<uint8_t, IdmapTypeMap> map;
6053
6054     // overlaid packages are assumed to contain only one package group
6055     const PackageGroup* pg = mPackageGroups[0];
6056
6057     // starting size is header
6058     *outSize = ResTable::IDMAP_HEADER_SIZE_BYTES;
6059
6060     // target package id and number of types in map
6061     *outSize += 2 * sizeof(uint16_t);
6062
6063     // overlay packages are assumed to contain only one package group
6064     const ResTable_package* overlayPackageStruct = overlay.mPackageGroups[0]->packages[0]->package;
6065     char16_t tmpName[sizeof(overlayPackageStruct->name)/sizeof(overlayPackageStruct->name[0])];
6066     strcpy16_dtoh(tmpName, overlayPackageStruct->name, sizeof(overlayPackageStruct->name)/sizeof(overlayPackageStruct->name[0]));
6067     const String16 overlayPackage(tmpName);
6068
6069     for (size_t typeIndex = 0; typeIndex < pg->types.size(); ++typeIndex) {
6070         const TypeList& typeList = pg->types[typeIndex];
6071         if (typeList.isEmpty()) {
6072             continue;
6073         }
6074
6075         const Type* typeConfigs = typeList[0];
6076
6077         IdmapTypeMap typeMap;
6078         typeMap.overlayTypeId = -1;
6079         typeMap.entryOffset = 0;
6080
6081         for (size_t entryIndex = 0; entryIndex < typeConfigs->entryCount; ++entryIndex) {
6082             uint32_t resID = Res_MAKEID(pg->id - 1, typeIndex, entryIndex);
6083             resource_name resName;
6084             if (!this->getResourceName(resID, false, &resName)) {
6085                 if (typeMap.entryMap.isEmpty()) {
6086                     typeMap.entryOffset++;
6087                 }
6088                 continue;
6089             }
6090
6091             const String16 overlayType(resName.type, resName.typeLen);
6092             const String16 overlayName(resName.name, resName.nameLen);
6093             uint32_t overlayResID = overlay.identifierForName(overlayName.string(),
6094                                                               overlayName.size(),
6095                                                               overlayType.string(),
6096                                                               overlayType.size(),
6097                                                               overlayPackage.string(),
6098                                                               overlayPackage.size());
6099             if (overlayResID == 0) {
6100                 if (typeMap.entryMap.isEmpty()) {
6101                     typeMap.entryOffset++;
6102                 }
6103                 continue;
6104             }
6105
6106             if (typeMap.overlayTypeId == -1) {
6107                 typeMap.overlayTypeId = Res_GETTYPE(overlayResID) + 1;
6108             }
6109
6110             if (Res_GETTYPE(overlayResID) + 1 != static_cast<size_t>(typeMap.overlayTypeId)) {
6111                 ALOGE("idmap: can't mix type ids in entry map. Resource 0x%08x maps to 0x%08x"
6112                         " but entries should map to resources of type %02x",
6113                         resID, overlayResID, typeMap.overlayTypeId);
6114                 return BAD_TYPE;
6115             }
6116
6117             if (typeMap.entryOffset + typeMap.entryMap.size() < entryIndex) {
6118                 // Resize to accomodate this entry and the 0's in between.
6119                 if (typeMap.entryMap.resize((entryIndex - typeMap.entryOffset) + 1) < 0) {
6120                     return NO_MEMORY;
6121                 }
6122                 typeMap.entryMap.editTop() = Res_GETENTRY(overlayResID);
6123             } else {
6124                 typeMap.entryMap.add(Res_GETENTRY(overlayResID));
6125             }
6126         }
6127
6128         if (!typeMap.entryMap.isEmpty()) {
6129             if (map.add(static_cast<uint8_t>(typeIndex), typeMap) < 0) {
6130                 return NO_MEMORY;
6131             }
6132             *outSize += (4 * sizeof(uint16_t)) + (typeMap.entryMap.size() * sizeof(uint32_t));
6133         }
6134     }
6135
6136     if (map.isEmpty()) {
6137         ALOGW("idmap: no resources in overlay package present in base package");
6138         return UNKNOWN_ERROR;
6139     }
6140
6141     if ((*outData = malloc(*outSize)) == NULL) {
6142         return NO_MEMORY;
6143     }
6144
6145     uint32_t* data = (uint32_t*)*outData;
6146     *data++ = htodl(IDMAP_MAGIC);
6147     *data++ = htodl(IDMAP_CURRENT_VERSION);
6148     *data++ = htodl(targetCrc);
6149     *data++ = htodl(overlayCrc);
6150     const char* paths[] = { targetPath, overlayPath };
6151     for (int j = 0; j < 2; ++j) {
6152         char* p = (char*)data;
6153         const char* path = paths[j];
6154         const size_t I = strlen(path);
6155         if (I > 255) {
6156             ALOGV("path exceeds expected 255 characters: %s\n", path);
6157             return UNKNOWN_ERROR;
6158         }
6159         for (size_t i = 0; i < 256; ++i) {
6160             *p++ = i < I ? path[i] : '\0';
6161         }
6162         data += 256 / sizeof(uint32_t);
6163     }
6164     const size_t mapSize = map.size();
6165     uint16_t* typeData = reinterpret_cast<uint16_t*>(data);
6166     *typeData++ = htods(pg->id);
6167     *typeData++ = htods(mapSize);
6168     for (size_t i = 0; i < mapSize; ++i) {
6169         uint8_t targetTypeId = map.keyAt(i);
6170         const IdmapTypeMap& typeMap = map[i];
6171         *typeData++ = htods(targetTypeId + 1);
6172         *typeData++ = htods(typeMap.overlayTypeId);
6173         *typeData++ = htods(typeMap.entryMap.size());
6174         *typeData++ = htods(typeMap.entryOffset);
6175
6176         const size_t entryCount = typeMap.entryMap.size();
6177         uint32_t* entries = reinterpret_cast<uint32_t*>(typeData);
6178         for (size_t j = 0; j < entryCount; j++) {
6179             entries[j] = htodl(typeMap.entryMap[j]);
6180         }
6181         typeData += entryCount * 2;
6182     }
6183
6184     return NO_ERROR;
6185 }
6186
6187 bool ResTable::getIdmapInfo(const void* idmap, size_t sizeBytes,
6188                             uint32_t* pVersion,
6189                             uint32_t* pTargetCrc, uint32_t* pOverlayCrc,
6190                             String8* pTargetPath, String8* pOverlayPath)
6191 {
6192     const uint32_t* map = (const uint32_t*)idmap;
6193     if (!assertIdmapHeader(map, sizeBytes)) {
6194         return false;
6195     }
6196     if (pVersion) {
6197         *pVersion = dtohl(map[1]);
6198     }
6199     if (pTargetCrc) {
6200         *pTargetCrc = dtohl(map[2]);
6201     }
6202     if (pOverlayCrc) {
6203         *pOverlayCrc = dtohl(map[3]);
6204     }
6205     if (pTargetPath) {
6206         pTargetPath->setTo(reinterpret_cast<const char*>(map + 4));
6207     }
6208     if (pOverlayPath) {
6209         pOverlayPath->setTo(reinterpret_cast<const char*>(map + 4 + 256 / sizeof(uint32_t)));
6210     }
6211     return true;
6212 }
6213
6214
6215 #define CHAR16_TO_CSTR(c16, len) (String8(String16(c16,len)).string())
6216
6217 #define CHAR16_ARRAY_EQ(constant, var, len) \
6218         ((len == (sizeof(constant)/sizeof(constant[0]))) && (0 == memcmp((var), (constant), (len))))
6219
6220 static void print_complex(uint32_t complex, bool isFraction)
6221 {
6222     const float MANTISSA_MULT =
6223         1.0f / (1<<Res_value::COMPLEX_MANTISSA_SHIFT);
6224     const float RADIX_MULTS[] = {
6225         1.0f*MANTISSA_MULT, 1.0f/(1<<7)*MANTISSA_MULT,
6226         1.0f/(1<<15)*MANTISSA_MULT, 1.0f/(1<<23)*MANTISSA_MULT
6227     };
6228
6229     float value = (complex&(Res_value::COMPLEX_MANTISSA_MASK
6230                    <<Res_value::COMPLEX_MANTISSA_SHIFT))
6231             * RADIX_MULTS[(complex>>Res_value::COMPLEX_RADIX_SHIFT)
6232                             & Res_value::COMPLEX_RADIX_MASK];
6233     printf("%f", value);
6234
6235     if (!isFraction) {
6236         switch ((complex>>Res_value::COMPLEX_UNIT_SHIFT)&Res_value::COMPLEX_UNIT_MASK) {
6237             case Res_value::COMPLEX_UNIT_PX: printf("px"); break;
6238             case Res_value::COMPLEX_UNIT_DIP: printf("dp"); break;
6239             case Res_value::COMPLEX_UNIT_SP: printf("sp"); break;
6240             case Res_value::COMPLEX_UNIT_PT: printf("pt"); break;
6241             case Res_value::COMPLEX_UNIT_IN: printf("in"); break;
6242             case Res_value::COMPLEX_UNIT_MM: printf("mm"); break;
6243             default: printf(" (unknown unit)"); break;
6244         }
6245     } else {
6246         switch ((complex>>Res_value::COMPLEX_UNIT_SHIFT)&Res_value::COMPLEX_UNIT_MASK) {
6247             case Res_value::COMPLEX_UNIT_FRACTION: printf("%%"); break;
6248             case Res_value::COMPLEX_UNIT_FRACTION_PARENT: printf("%%p"); break;
6249             default: printf(" (unknown unit)"); break;
6250         }
6251     }
6252 }
6253
6254 // Normalize a string for output
6255 String8 ResTable::normalizeForOutput( const char *input )
6256 {
6257     String8 ret;
6258     char buff[2];
6259     buff[1] = '\0';
6260
6261     while (*input != '\0') {
6262         switch (*input) {
6263             // All interesting characters are in the ASCII zone, so we are making our own lives
6264             // easier by scanning the string one byte at a time.
6265         case '\\':
6266             ret += "\\\\";
6267             break;
6268         case '\n':
6269             ret += "\\n";
6270             break;
6271         case '"':
6272             ret += "\\\"";
6273             break;
6274         default:
6275             buff[0] = *input;
6276             ret += buff;
6277             break;
6278         }
6279
6280         input++;
6281     }
6282
6283     return ret;
6284 }
6285
6286 void ResTable::print_value(const Package* pkg, const Res_value& value) const
6287 {
6288     if (value.dataType == Res_value::TYPE_NULL) {
6289         if (value.data == Res_value::DATA_NULL_UNDEFINED) {
6290             printf("(null)\n");
6291         } else if (value.data == Res_value::DATA_NULL_EMPTY) {
6292             printf("(null empty)\n");
6293         } else {
6294             // This should never happen.
6295             printf("(null) 0x%08x\n", value.data);
6296         }
6297     } else if (value.dataType == Res_value::TYPE_REFERENCE) {
6298         printf("(reference) 0x%08x\n", value.data);
6299     } else if (value.dataType == Res_value::TYPE_DYNAMIC_REFERENCE) {
6300         printf("(dynamic reference) 0x%08x\n", value.data);
6301     } else if (value.dataType == Res_value::TYPE_ATTRIBUTE) {
6302         printf("(attribute) 0x%08x\n", value.data);
6303     } else if (value.dataType == Res_value::TYPE_STRING) {
6304         size_t len;
6305         const char* str8 = pkg->header->values.string8At(
6306                 value.data, &len);
6307         if (str8 != NULL) {
6308             printf("(string8) \"%s\"\n", normalizeForOutput(str8).string());
6309         } else {
6310             const char16_t* str16 = pkg->header->values.stringAt(
6311                     value.data, &len);
6312             if (str16 != NULL) {
6313                 printf("(string16) \"%s\"\n",
6314                     normalizeForOutput(String8(str16, len).string()).string());
6315             } else {
6316                 printf("(string) null\n");
6317             }
6318         }
6319     } else if (value.dataType == Res_value::TYPE_FLOAT) {
6320         printf("(float) %g\n", *(const float*)&value.data);
6321     } else if (value.dataType == Res_value::TYPE_DIMENSION) {
6322         printf("(dimension) ");
6323         print_complex(value.data, false);
6324         printf("\n");
6325     } else if (value.dataType == Res_value::TYPE_FRACTION) {
6326         printf("(fraction) ");
6327         print_complex(value.data, true);
6328         printf("\n");
6329     } else if (value.dataType >= Res_value::TYPE_FIRST_COLOR_INT
6330             || value.dataType <= Res_value::TYPE_LAST_COLOR_INT) {
6331         printf("(color) #%08x\n", value.data);
6332     } else if (value.dataType == Res_value::TYPE_INT_BOOLEAN) {
6333         printf("(boolean) %s\n", value.data ? "true" : "false");
6334     } else if (value.dataType >= Res_value::TYPE_FIRST_INT
6335             || value.dataType <= Res_value::TYPE_LAST_INT) {
6336         printf("(int) 0x%08x or %d\n", value.data, value.data);
6337     } else {
6338         printf("(unknown type) t=0x%02x d=0x%08x (s=0x%04x r=0x%02x)\n",
6339                (int)value.dataType, (int)value.data,
6340                (int)value.size, (int)value.res0);
6341     }
6342 }
6343
6344 void ResTable::print(bool inclValues) const
6345 {
6346     if (mError != 0) {
6347         printf("mError=0x%x (%s)\n", mError, strerror(mError));
6348     }
6349     size_t pgCount = mPackageGroups.size();
6350     printf("Package Groups (%d)\n", (int)pgCount);
6351     for (size_t pgIndex=0; pgIndex<pgCount; pgIndex++) {
6352         const PackageGroup* pg = mPackageGroups[pgIndex];
6353         printf("Package Group %d id=0x%02x packageCount=%d name=%s\n",
6354                 (int)pgIndex, pg->id, (int)pg->packages.size(),
6355                 String8(pg->name).string());
6356
6357         const KeyedVector<String16, uint8_t>& refEntries = pg->dynamicRefTable.entries();
6358         const size_t refEntryCount = refEntries.size();
6359         if (refEntryCount > 0) {
6360             printf("  DynamicRefTable entryCount=%d:\n", (int) refEntryCount);
6361             for (size_t refIndex = 0; refIndex < refEntryCount; refIndex++) {
6362                 printf("    0x%02x -> %s\n",
6363                         refEntries.valueAt(refIndex),
6364                         String8(refEntries.keyAt(refIndex)).string());
6365             }
6366             printf("\n");
6367         }
6368
6369         int packageId = pg->id;
6370         size_t pkgCount = pg->packages.size();
6371         for (size_t pkgIndex=0; pkgIndex<pkgCount; pkgIndex++) {
6372             const Package* pkg = pg->packages[pkgIndex];
6373             // Use a package's real ID, since the ID may have been assigned
6374             // if this package is a shared library.
6375             packageId = pkg->package->id;
6376             char16_t tmpName[sizeof(pkg->package->name)/sizeof(pkg->package->name[0])];
6377             strcpy16_dtoh(tmpName, pkg->package->name, sizeof(pkg->package->name)/sizeof(pkg->package->name[0]));
6378             printf("  Package %d id=0x%02x name=%s\n", (int)pkgIndex,
6379                     pkg->package->id, String8(tmpName).string());
6380         }
6381
6382         for (size_t typeIndex=0; typeIndex < pg->types.size(); typeIndex++) {
6383             const TypeList& typeList = pg->types[typeIndex];
6384             if (typeList.isEmpty()) {
6385                 continue;
6386             }
6387             const Type* typeConfigs = typeList[0];
6388             const size_t NTC = typeConfigs->configs.size();
6389             printf("    type %d configCount=%d entryCount=%d\n",
6390                    (int)typeIndex, (int)NTC, (int)typeConfigs->entryCount);
6391             if (typeConfigs->typeSpecFlags != NULL) {
6392                 for (size_t entryIndex=0; entryIndex<typeConfigs->entryCount; entryIndex++) {
6393                     uint32_t resID = (0xff000000 & ((packageId)<<24))
6394                                 | (0x00ff0000 & ((typeIndex+1)<<16))
6395                                 | (0x0000ffff & (entryIndex));
6396                     // Since we are creating resID without actually
6397                     // iterating over them, we have no idea which is a
6398                     // dynamic reference. We must check.
6399                     if (packageId == 0) {
6400                         pg->dynamicRefTable.lookupResourceId(&resID);
6401                     }
6402
6403                     resource_name resName;
6404                     if (this->getResourceName(resID, true, &resName)) {
6405                         String8 type8;
6406                         String8 name8;
6407                         if (resName.type8 != NULL) {
6408                             type8 = String8(resName.type8, resName.typeLen);
6409                         } else {
6410                             type8 = String8(resName.type, resName.typeLen);
6411                         }
6412                         if (resName.name8 != NULL) {
6413                             name8 = String8(resName.name8, resName.nameLen);
6414                         } else {
6415                             name8 = String8(resName.name, resName.nameLen);
6416                         }
6417                         printf("      spec resource 0x%08x %s:%s/%s: flags=0x%08x\n",
6418                             resID,
6419                             CHAR16_TO_CSTR(resName.package, resName.packageLen),
6420                             type8.string(), name8.string(),
6421                             dtohl(typeConfigs->typeSpecFlags[entryIndex]));
6422                     } else {
6423                         printf("      INVALID TYPE CONFIG FOR RESOURCE 0x%08x\n", resID);
6424                     }
6425                 }
6426             }
6427             for (size_t configIndex=0; configIndex<NTC; configIndex++) {
6428                 const ResTable_type* type = typeConfigs->configs[configIndex];
6429                 if ((((uint64_t)type)&0x3) != 0) {
6430                     printf("      NON-INTEGER ResTable_type ADDRESS: %p\n", type);
6431                     continue;
6432                 }
6433                 String8 configStr = type->config.toString();
6434                 printf("      config %s:\n", configStr.size() > 0
6435                         ? configStr.string() : "(default)");
6436                 size_t entryCount = dtohl(type->entryCount);
6437                 uint32_t entriesStart = dtohl(type->entriesStart);
6438                 if ((entriesStart&0x3) != 0) {
6439                     printf("      NON-INTEGER ResTable_type entriesStart OFFSET: 0x%x\n", entriesStart);
6440                     continue;
6441                 }
6442                 uint32_t typeSize = dtohl(type->header.size);
6443                 if ((typeSize&0x3) != 0) {
6444                     printf("      NON-INTEGER ResTable_type header.size: 0x%x\n", typeSize);
6445                     continue;
6446                 }
6447                 for (size_t entryIndex=0; entryIndex<entryCount; entryIndex++) {
6448
6449                     const uint8_t* const end = ((const uint8_t*)type)
6450                         + dtohl(type->header.size);
6451                     const uint32_t* const eindex = (const uint32_t*)
6452                         (((const uint8_t*)type) + dtohs(type->header.headerSize));
6453
6454                     uint32_t thisOffset = dtohl(eindex[entryIndex]);
6455                     if (thisOffset == ResTable_type::NO_ENTRY) {
6456                         continue;
6457                     }
6458
6459                     uint32_t resID = (0xff000000 & ((packageId)<<24))
6460                                 | (0x00ff0000 & ((typeIndex+1)<<16))
6461                                 | (0x0000ffff & (entryIndex));
6462                     if (packageId == 0) {
6463                         pg->dynamicRefTable.lookupResourceId(&resID);
6464                     }
6465                     resource_name resName;
6466                     if (this->getResourceName(resID, true, &resName)) {
6467                         String8 type8;
6468                         String8 name8;
6469                         if (resName.type8 != NULL) {
6470                             type8 = String8(resName.type8, resName.typeLen);
6471                         } else {
6472                             type8 = String8(resName.type, resName.typeLen);
6473                         }
6474                         if (resName.name8 != NULL) {
6475                             name8 = String8(resName.name8, resName.nameLen);
6476                         } else {
6477                             name8 = String8(resName.name, resName.nameLen);
6478                         }
6479                         printf("        resource 0x%08x %s:%s/%s: ", resID,
6480                                 CHAR16_TO_CSTR(resName.package, resName.packageLen),
6481                                 type8.string(), name8.string());
6482                     } else {
6483                         printf("        INVALID RESOURCE 0x%08x: ", resID);
6484                     }
6485                     if ((thisOffset&0x3) != 0) {
6486                         printf("NON-INTEGER OFFSET: 0x%x\n", thisOffset);
6487                         continue;
6488                     }
6489                     if ((thisOffset+sizeof(ResTable_entry)) > typeSize) {
6490                         printf("OFFSET OUT OF BOUNDS: 0x%x+0x%x (size is 0x%x)\n",
6491                                entriesStart, thisOffset, typeSize);
6492                         continue;
6493                     }
6494
6495                     const ResTable_entry* ent = (const ResTable_entry*)
6496                         (((const uint8_t*)type) + entriesStart + thisOffset);
6497                     if (((entriesStart + thisOffset)&0x3) != 0) {
6498                         printf("NON-INTEGER ResTable_entry OFFSET: 0x%x\n",
6499                              (entriesStart + thisOffset));
6500                         continue;
6501                     }
6502
6503                     uintptr_t esize = dtohs(ent->size);
6504                     if ((esize&0x3) != 0) {
6505                         printf("NON-INTEGER ResTable_entry SIZE: %p\n", (void *)esize);
6506                         continue;
6507                     }
6508                     if ((thisOffset+esize) > typeSize) {
6509                         printf("ResTable_entry OUT OF BOUNDS: 0x%x+0x%x+%p (size is 0x%x)\n",
6510                                entriesStart, thisOffset, (void *)esize, typeSize);
6511                         continue;
6512                     }
6513
6514                     const Res_value* valuePtr = NULL;
6515                     const ResTable_map_entry* bagPtr = NULL;
6516                     Res_value value;
6517                     if ((dtohs(ent->flags)&ResTable_entry::FLAG_COMPLEX) != 0) {
6518                         printf("<bag>");
6519                         bagPtr = (const ResTable_map_entry*)ent;
6520                     } else {
6521                         valuePtr = (const Res_value*)
6522                             (((const uint8_t*)ent) + esize);
6523                         value.copyFrom_dtoh(*valuePtr);
6524                         printf("t=0x%02x d=0x%08x (s=0x%04x r=0x%02x)",
6525                                (int)value.dataType, (int)value.data,
6526                                (int)value.size, (int)value.res0);
6527                     }
6528
6529                     if ((dtohs(ent->flags)&ResTable_entry::FLAG_PUBLIC) != 0) {
6530                         printf(" (PUBLIC)");
6531                     }
6532                     printf("\n");
6533
6534                     if (inclValues) {
6535                         if (valuePtr != NULL) {
6536                             printf("          ");
6537                             print_value(typeConfigs->package, value);
6538                         } else if (bagPtr != NULL) {
6539                             const int N = dtohl(bagPtr->count);
6540                             const uint8_t* baseMapPtr = (const uint8_t*)ent;
6541                             size_t mapOffset = esize;
6542                             const ResTable_map* mapPtr = (ResTable_map*)(baseMapPtr+mapOffset);
6543                             const uint32_t parent = dtohl(bagPtr->parent.ident);
6544                             uint32_t resolvedParent = parent;
6545                             if (Res_GETPACKAGE(resolvedParent) + 1 == 0) {
6546                                 status_t err = pg->dynamicRefTable.lookupResourceId(&resolvedParent);
6547                                 if (err != NO_ERROR) {
6548                                     resolvedParent = 0;
6549                                 }
6550                             }
6551                             printf("          Parent=0x%08x(Resolved=0x%08x), Count=%d\n",
6552                                     parent, resolvedParent, N);
6553                             for (int i=0; i<N && mapOffset < (typeSize-sizeof(ResTable_map)); i++) {
6554                                 printf("          #%i (Key=0x%08x): ",
6555                                     i, dtohl(mapPtr->name.ident));
6556                                 value.copyFrom_dtoh(mapPtr->value);
6557                                 print_value(typeConfigs->package, value);
6558                                 const size_t size = dtohs(mapPtr->value.size);
6559                                 mapOffset += size + sizeof(*mapPtr)-sizeof(mapPtr->value);
6560                                 mapPtr = (ResTable_map*)(baseMapPtr+mapOffset);
6561                             }
6562                         }
6563                     }
6564                 }
6565             }
6566         }
6567     }
6568 }
6569
6570 }   // namespace android