/tools/aapt/StringPool.cpp
C++ | 411 lines | 330 code | 61 blank | 20 comment | 64 complexity | ca034aefe7d210a4ee64b262296ce099 MD5 | raw file
- //
- // Copyright 2006 The Android Open Source Project
- //
- // Build resource files from raw assets.
- //
- #include "StringPool.h"
- #include <utils/ByteOrder.h>
- #define NOISY(x) //x
- void strcpy16_htod(uint16_t* dst, const uint16_t* src)
- {
- while (*src) {
- char16_t s = htods(*src);
- *dst++ = s;
- src++;
- }
- *dst = 0;
- }
- void printStringPool(const ResStringPool* pool)
- {
- const size_t NS = pool->size();
- for (size_t s=0; s<NS; s++) {
- size_t len;
- const char *str = (const char*)pool->string8At(s, &len);
- if (str == NULL) {
- str = String8(pool->stringAt(s, &len)).string();
- }
- printf("String #%ld: %s\n", s, str);
- }
- }
- StringPool::StringPool(bool sorted, bool utf8)
- : mSorted(sorted), mUTF8(utf8), mValues(-1), mIdents(-1)
- {
- }
- ssize_t StringPool::add(const String16& value, bool mergeDuplicates)
- {
- return add(String16(), value, mergeDuplicates);
- }
- ssize_t StringPool::add(const String16& value, const Vector<entry_style_span>& spans)
- {
- ssize_t res = add(String16(), value, false);
- if (res >= 0) {
- addStyleSpans(res, spans);
- }
- return res;
- }
- ssize_t StringPool::add(const String16& ident, const String16& value,
- bool mergeDuplicates)
- {
- if (ident.size() > 0) {
- ssize_t idx = mIdents.valueFor(ident);
- if (idx >= 0) {
- fprintf(stderr, "ERROR: Duplicate string identifier %s\n",
- String8(mEntries[idx].value).string());
- return UNKNOWN_ERROR;
- }
- }
- ssize_t vidx = mValues.indexOfKey(value);
- ssize_t pos = vidx >= 0 ? mValues.valueAt(vidx) : -1;
- ssize_t eidx = pos >= 0 ? mEntryArray.itemAt(pos) : -1;
- if (eidx < 0) {
- eidx = mEntries.add(entry(value));
- if (eidx < 0) {
- fprintf(stderr, "Failure adding string %s\n", String8(value).string());
- return eidx;
- }
- }
- const bool first = vidx < 0;
- if (first || !mergeDuplicates) {
- pos = mEntryArray.add(eidx);
- if (first) {
- vidx = mValues.add(value, pos);
- const size_t N = mEntryArrayToValues.size();
- for (size_t i=0; i<N; i++) {
- size_t& e = mEntryArrayToValues.editItemAt(i);
- if ((ssize_t)e >= vidx) {
- e++;
- }
- }
- }
- mEntryArrayToValues.add(vidx);
- if (!mSorted) {
- entry& ent = mEntries.editItemAt(eidx);
- ent.indices.add(pos);
- }
- }
- if (ident.size() > 0) {
- mIdents.add(ident, vidx);
- }
- NOISY(printf("Adding string %s to pool: pos=%d eidx=%d vidx=%d\n",
- String8(value).string(), pos, eidx, vidx));
-
- return pos;
- }
- status_t StringPool::addStyleSpan(size_t idx, const String16& name,
- uint32_t start, uint32_t end)
- {
- entry_style_span span;
- span.name = name;
- span.span.firstChar = start;
- span.span.lastChar = end;
- return addStyleSpan(idx, span);
- }
- status_t StringPool::addStyleSpans(size_t idx, const Vector<entry_style_span>& spans)
- {
- const size_t N=spans.size();
- for (size_t i=0; i<N; i++) {
- status_t err = addStyleSpan(idx, spans[i]);
- if (err != NO_ERROR) {
- return err;
- }
- }
- return NO_ERROR;
- }
- status_t StringPool::addStyleSpan(size_t idx, const entry_style_span& span)
- {
- LOG_ALWAYS_FATAL_IF(mSorted, "Can't use styles with sorted string pools.");
- // Place blank entries in the span array up to this index.
- while (mEntryStyleArray.size() <= idx) {
- mEntryStyleArray.add();
- }
- entry_style& style = mEntryStyleArray.editItemAt(idx);
- style.spans.add(span);
- return NO_ERROR;
- }
- size_t StringPool::size() const
- {
- return mSorted ? mValues.size() : mEntryArray.size();
- }
- const StringPool::entry& StringPool::entryAt(size_t idx) const
- {
- if (!mSorted) {
- return mEntries[mEntryArray[idx]];
- } else {
- return mEntries[mEntryArray[mValues.valueAt(idx)]];
- }
- }
- size_t StringPool::countIdentifiers() const
- {
- return mIdents.size();
- }
- sp<AaptFile> StringPool::createStringBlock()
- {
- sp<AaptFile> pool = new AaptFile(String8(), AaptGroupEntry(),
- String8());
- status_t err = writeStringBlock(pool);
- return err == NO_ERROR ? pool : NULL;
- }
- #define ENCODE_LENGTH(str, chrsz, strSize) \
- { \
- size_t maxMask = 1 << ((chrsz*8)-1); \
- size_t maxSize = maxMask-1; \
- if (strSize > maxSize) { \
- *str++ = maxMask | ((strSize>>(chrsz*8))&maxSize); \
- } \
- *str++ = strSize; \
- }
- status_t StringPool::writeStringBlock(const sp<AaptFile>& pool)
- {
- // Allow appending. Sorry this is a little wacky.
- if (pool->getSize() > 0) {
- sp<AaptFile> block = createStringBlock();
- if (block == NULL) {
- return UNKNOWN_ERROR;
- }
- ssize_t res = pool->writeData(block->getData(), block->getSize());
- return (res >= 0) ? (status_t)NO_ERROR : res;
- }
- // First we need to add all style span names to the string pool.
- // We do this now (instead of when the span is added) so that these
- // will appear at the end of the pool, not disrupting the order
- // our client placed their own strings in it.
-
- const size_t STYLES = mEntryStyleArray.size();
- size_t i;
- for (i=0; i<STYLES; i++) {
- entry_style& style = mEntryStyleArray.editItemAt(i);
- const size_t N = style.spans.size();
- for (size_t i=0; i<N; i++) {
- entry_style_span& span = style.spans.editItemAt(i);
- ssize_t idx = add(span.name, true);
- if (idx < 0) {
- fprintf(stderr, "Error adding span for style tag '%s'\n",
- String8(span.name).string());
- return idx;
- }
- span.span.name.index = (uint32_t)idx;
- }
- }
- const size_t ENTRIES = size();
- // Now build the pool of unique strings.
- const size_t STRINGS = mEntries.size();
- const size_t preSize = sizeof(ResStringPool_header)
- + (sizeof(uint32_t)*ENTRIES)
- + (sizeof(uint32_t)*STYLES);
- if (pool->editData(preSize) == NULL) {
- fprintf(stderr, "ERROR: Out of memory for string pool\n");
- return NO_MEMORY;
- }
- const size_t charSize = mUTF8 ? sizeof(uint8_t) : sizeof(char16_t);
- size_t strPos = 0;
- for (i=0; i<STRINGS; i++) {
- entry& ent = mEntries.editItemAt(i);
- const size_t strSize = (ent.value.size());
- const size_t lenSize = strSize > (size_t)(1<<((charSize*8)-1))-1 ?
- charSize*2 : charSize;
- String8 encStr;
- if (mUTF8) {
- encStr = String8(ent.value);
- }
- const size_t encSize = mUTF8 ? encStr.size() : 0;
- const size_t encLenSize = mUTF8 ?
- (encSize > (size_t)(1<<((charSize*8)-1))-1 ?
- charSize*2 : charSize) : 0;
- ent.offset = strPos;
- const size_t totalSize = lenSize + encLenSize +
- ((mUTF8 ? encSize : strSize)+1)*charSize;
- void* dat = (void*)pool->editData(preSize + strPos + totalSize);
- if (dat == NULL) {
- fprintf(stderr, "ERROR: Out of memory for string pool\n");
- return NO_MEMORY;
- }
- dat = (uint8_t*)dat + preSize + strPos;
- if (mUTF8) {
- uint8_t* strings = (uint8_t*)dat;
- ENCODE_LENGTH(strings, sizeof(uint8_t), strSize)
- ENCODE_LENGTH(strings, sizeof(uint8_t), encSize)
- strncpy((char*)strings, encStr, encSize+1);
- } else {
- uint16_t* strings = (uint16_t*)dat;
- ENCODE_LENGTH(strings, sizeof(uint16_t), strSize)
- strcpy16_htod(strings, ent.value);
- }
- strPos += totalSize;
- }
- // Pad ending string position up to a uint32_t boundary.
- if (strPos&0x3) {
- size_t padPos = ((strPos+3)&~0x3);
- uint8_t* dat = (uint8_t*)pool->editData(preSize + padPos);
- if (dat == NULL) {
- fprintf(stderr, "ERROR: Out of memory padding string pool\n");
- return NO_MEMORY;
- }
- memset(dat+preSize+strPos, 0, padPos-strPos);
- strPos = padPos;
- }
- // Build the pool of style spans.
- size_t styPos = strPos;
- for (i=0; i<STYLES; i++) {
- entry_style& ent = mEntryStyleArray.editItemAt(i);
- const size_t N = ent.spans.size();
- const size_t totalSize = (N*sizeof(ResStringPool_span))
- + sizeof(ResStringPool_ref);
- ent.offset = styPos-strPos;
- uint8_t* dat = (uint8_t*)pool->editData(preSize + styPos + totalSize);
- if (dat == NULL) {
- fprintf(stderr, "ERROR: Out of memory for string styles\n");
- return NO_MEMORY;
- }
- ResStringPool_span* span = (ResStringPool_span*)(dat+preSize+styPos);
- for (size_t i=0; i<N; i++) {
- span->name.index = htodl(ent.spans[i].span.name.index);
- span->firstChar = htodl(ent.spans[i].span.firstChar);
- span->lastChar = htodl(ent.spans[i].span.lastChar);
- span++;
- }
- span->name.index = htodl(ResStringPool_span::END);
- styPos += totalSize;
- }
- if (STYLES > 0) {
- // Add full terminator at the end (when reading we validate that
- // the end of the pool is fully terminated to simplify error
- // checking).
- size_t extra = sizeof(ResStringPool_span)-sizeof(ResStringPool_ref);
- uint8_t* dat = (uint8_t*)pool->editData(preSize + styPos + extra);
- if (dat == NULL) {
- fprintf(stderr, "ERROR: Out of memory for string styles\n");
- return NO_MEMORY;
- }
- uint32_t* p = (uint32_t*)(dat+preSize+styPos);
- while (extra > 0) {
- *p++ = htodl(ResStringPool_span::END);
- extra -= sizeof(uint32_t);
- }
- styPos += extra;
- }
- // Write header.
- ResStringPool_header* header =
- (ResStringPool_header*)pool->padData(sizeof(uint32_t));
- if (header == NULL) {
- fprintf(stderr, "ERROR: Out of memory for string pool\n");
- return NO_MEMORY;
- }
- memset(header, 0, sizeof(*header));
- header->header.type = htods(RES_STRING_POOL_TYPE);
- header->header.headerSize = htods(sizeof(*header));
- header->header.size = htodl(pool->getSize());
- header->stringCount = htodl(ENTRIES);
- header->styleCount = htodl(STYLES);
- if (mSorted) {
- header->flags |= htodl(ResStringPool_header::SORTED_FLAG);
- }
- if (mUTF8) {
- header->flags |= htodl(ResStringPool_header::UTF8_FLAG);
- }
- header->stringsStart = htodl(preSize);
- header->stylesStart = htodl(STYLES > 0 ? (preSize+strPos) : 0);
- // Write string index array.
- uint32_t* index = (uint32_t*)(header+1);
- if (mSorted) {
- for (i=0; i<ENTRIES; i++) {
- entry& ent = const_cast<entry&>(entryAt(i));
- ent.indices.clear();
- ent.indices.add(i);
- *index++ = htodl(ent.offset);
- }
- } else {
- for (i=0; i<ENTRIES; i++) {
- entry& ent = mEntries.editItemAt(mEntryArray[i]);
- *index++ = htodl(ent.offset);
- NOISY(printf("Writing entry #%d: \"%s\" ent=%d off=%d\n", i,
- String8(ent.value).string(),
- mEntryArray[i], ent.offset));
- }
- }
- // Write style index array.
- if (mSorted) {
- for (i=0; i<STYLES; i++) {
- LOG_ALWAYS_FATAL("Shouldn't be here!");
- }
- } else {
- for (i=0; i<STYLES; i++) {
- *index++ = htodl(mEntryStyleArray[i].offset);
- }
- }
- return NO_ERROR;
- }
- ssize_t StringPool::offsetForString(const String16& val) const
- {
- const Vector<size_t>* indices = offsetsForString(val);
- ssize_t res = indices != NULL && indices->size() > 0 ? indices->itemAt(0) : -1;
- NOISY(printf("Offset for string %s: %d (%s)\n", String8(val).string(), res,
- res >= 0 ? String8(mEntries[mEntryArray[res]].value).string() : String8()));
- return res;
- }
- const Vector<size_t>* StringPool::offsetsForString(const String16& val) const
- {
- ssize_t pos = mValues.valueFor(val);
- if (pos < 0) {
- return NULL;
- }
- return &mEntries[mEntryArray[pos]].indices;
- }