1 // 2 // Copyright 2006 The Android Open Source Project 3 // 4 // Build resource files from raw assets. 5 // 6 7 #include "StringPool.h" 8 9 #include <utils/ByteOrder.h> 10 11 #define NOISY(x) //x 12 13 void strcpy16_htod(uint16_t* dst, const uint16_t* src) 14 { 15 while (*src) { 16 char16_t s = htods(*src); 17 *dst++ = s; 18 src++; 19 } 20 *dst = 0; 21 } 22 23 void printStringPool(const ResStringPool* pool) 24 { 25 const size_t NS = pool->size(); 26 for (size_t s=0; s<NS; s++) { 27 size_t len; 28 const char *str = (const char*)pool->string8At(s, &len); 29 if (str == NULL) { 30 str = String8(pool->stringAt(s, &len)).string(); 31 } 32 33 printf("String #%ld: %s\n", s, str); 34 } 35 } 36 37 StringPool::StringPool(bool sorted, bool utf8) 38 : mSorted(sorted), mUTF8(utf8), mValues(-1), mIdents(-1) 39 { 40 } 41 42 ssize_t StringPool::add(const String16& value, bool mergeDuplicates) 43 { 44 return add(String16(), value, mergeDuplicates); 45 } 46 47 ssize_t StringPool::add(const String16& value, const Vector<entry_style_span>& spans) 48 { 49 ssize_t res = add(String16(), value, false); 50 if (res >= 0) { 51 addStyleSpans(res, spans); 52 } 53 return res; 54 } 55 56 ssize_t StringPool::add(const String16& ident, const String16& value, 57 bool mergeDuplicates) 58 { 59 if (ident.size() > 0) { 60 ssize_t idx = mIdents.valueFor(ident); 61 if (idx >= 0) { 62 fprintf(stderr, "ERROR: Duplicate string identifier %s\n", 63 String8(mEntries[idx].value).string()); 64 return UNKNOWN_ERROR; 65 } 66 } 67 68 ssize_t vidx = mValues.indexOfKey(value); 69 ssize_t pos = vidx >= 0 ? mValues.valueAt(vidx) : -1; 70 ssize_t eidx = pos >= 0 ? mEntryArray.itemAt(pos) : -1; 71 if (eidx < 0) { 72 eidx = mEntries.add(entry(value)); 73 if (eidx < 0) { 74 fprintf(stderr, "Failure adding string %s\n", String8(value).string()); 75 return eidx; 76 } 77 } 78 79 const bool first = vidx < 0; 80 if (first || !mergeDuplicates) { 81 pos = mEntryArray.add(eidx); 82 if (first) { 83 vidx = mValues.add(value, pos); 84 const size_t N = mEntryArrayToValues.size(); 85 for (size_t i=0; i<N; i++) { 86 size_t& e = mEntryArrayToValues.editItemAt(i); 87 if ((ssize_t)e >= vidx) { 88 e++; 89 } 90 } 91 } 92 mEntryArrayToValues.add(vidx); 93 if (!mSorted) { 94 entry& ent = mEntries.editItemAt(eidx); 95 ent.indices.add(pos); 96 } 97 } 98 99 if (ident.size() > 0) { 100 mIdents.add(ident, vidx); 101 } 102 103 NOISY(printf("Adding string %s to pool: pos=%d eidx=%d vidx=%d\n", 104 String8(value).string(), pos, eidx, vidx)); 105 106 return pos; 107 } 108 109 status_t StringPool::addStyleSpan(size_t idx, const String16& name, 110 uint32_t start, uint32_t end) 111 { 112 entry_style_span span; 113 span.name = name; 114 span.span.firstChar = start; 115 span.span.lastChar = end; 116 return addStyleSpan(idx, span); 117 } 118 119 status_t StringPool::addStyleSpans(size_t idx, const Vector<entry_style_span>& spans) 120 { 121 const size_t N=spans.size(); 122 for (size_t i=0; i<N; i++) { 123 status_t err = addStyleSpan(idx, spans[i]); 124 if (err != NO_ERROR) { 125 return err; 126 } 127 } 128 return NO_ERROR; 129 } 130 131 status_t StringPool::addStyleSpan(size_t idx, const entry_style_span& span) 132 { 133 LOG_ALWAYS_FATAL_IF(mSorted, "Can't use styles with sorted string pools."); 134 135 // Place blank entries in the span array up to this index. 136 while (mEntryStyleArray.size() <= idx) { 137 mEntryStyleArray.add(); 138 } 139 140 entry_style& style = mEntryStyleArray.editItemAt(idx); 141 style.spans.add(span); 142 return NO_ERROR; 143 } 144 145 size_t StringPool::size() const 146 { 147 return mSorted ? mValues.size() : mEntryArray.size(); 148 } 149 150 const StringPool::entry& StringPool::entryAt(size_t idx) const 151 { 152 if (!mSorted) { 153 return mEntries[mEntryArray[idx]]; 154 } else { 155 return mEntries[mEntryArray[mValues.valueAt(idx)]]; 156 } 157 } 158 159 size_t StringPool::countIdentifiers() const 160 { 161 return mIdents.size(); 162 } 163 164 sp<AaptFile> StringPool::createStringBlock() 165 { 166 sp<AaptFile> pool = new AaptFile(String8(), AaptGroupEntry(), 167 String8()); 168 status_t err = writeStringBlock(pool); 169 return err == NO_ERROR ? pool : NULL; 170 } 171 172 #define ENCODE_LENGTH(str, chrsz, strSize) \ 173 { \ 174 size_t maxMask = 1 << ((chrsz*8)-1); \ 175 size_t maxSize = maxMask-1; \ 176 if (strSize > maxSize) { \ 177 *str++ = maxMask | ((strSize>>(chrsz*8))&maxSize); \ 178 } \ 179 *str++ = strSize; \ 180 } 181 182 status_t StringPool::writeStringBlock(const sp<AaptFile>& pool) 183 { 184 // Allow appending. Sorry this is a little wacky. 185 if (pool->getSize() > 0) { 186 sp<AaptFile> block = createStringBlock(); 187 if (block == NULL) { 188 return UNKNOWN_ERROR; 189 } 190 ssize_t res = pool->writeData(block->getData(), block->getSize()); 191 return (res >= 0) ? (status_t)NO_ERROR : res; 192 } 193 194 // First we need to add all style span names to the string pool. 195 // We do this now (instead of when the span is added) so that these 196 // will appear at the end of the pool, not disrupting the order 197 // our client placed their own strings in it. 198 199 const size_t STYLES = mEntryStyleArray.size(); 200 size_t i; 201 202 for (i=0; i<STYLES; i++) { 203 entry_style& style = mEntryStyleArray.editItemAt(i); 204 const size_t N = style.spans.size(); 205 for (size_t i=0; i<N; i++) { 206 entry_style_span& span = style.spans.editItemAt(i); 207 ssize_t idx = add(span.name, true); 208 if (idx < 0) { 209 fprintf(stderr, "Error adding span for style tag '%s'\n", 210 String8(span.name).string()); 211 return idx; 212 } 213 span.span.name.index = (uint32_t)idx; 214 } 215 } 216 217 const size_t ENTRIES = size(); 218 219 // Now build the pool of unique strings. 220 221 const size_t STRINGS = mEntries.size(); 222 const size_t preSize = sizeof(ResStringPool_header) 223 + (sizeof(uint32_t)*ENTRIES) 224 + (sizeof(uint32_t)*STYLES); 225 if (pool->editData(preSize) == NULL) { 226 fprintf(stderr, "ERROR: Out of memory for string pool\n"); 227 return NO_MEMORY; 228 } 229 230 const size_t charSize = mUTF8 ? sizeof(uint8_t) : sizeof(char16_t); 231 232 size_t strPos = 0; 233 for (i=0; i<STRINGS; i++) { 234 entry& ent = mEntries.editItemAt(i); 235 const size_t strSize = (ent.value.size()); 236 const size_t lenSize = strSize > (size_t)(1<<((charSize*8)-1))-1 ? 237 charSize*2 : charSize; 238 239 String8 encStr; 240 if (mUTF8) { 241 encStr = String8(ent.value); 242 } 243 244 const size_t encSize = mUTF8 ? encStr.size() : 0; 245 const size_t encLenSize = mUTF8 ? 246 (encSize > (size_t)(1<<((charSize*8)-1))-1 ? 247 charSize*2 : charSize) : 0; 248 249 ent.offset = strPos; 250 251 const size_t totalSize = lenSize + encLenSize + 252 ((mUTF8 ? encSize : strSize)+1)*charSize; 253 254 void* dat = (void*)pool->editData(preSize + strPos + totalSize); 255 if (dat == NULL) { 256 fprintf(stderr, "ERROR: Out of memory for string pool\n"); 257 return NO_MEMORY; 258 } 259 dat = (uint8_t*)dat + preSize + strPos; 260 if (mUTF8) { 261 uint8_t* strings = (uint8_t*)dat; 262 263 ENCODE_LENGTH(strings, sizeof(uint8_t), strSize) 264 265 ENCODE_LENGTH(strings, sizeof(uint8_t), encSize) 266 267 strncpy((char*)strings, encStr, encSize+1); 268 } else { 269 uint16_t* strings = (uint16_t*)dat; 270 271 ENCODE_LENGTH(strings, sizeof(uint16_t), strSize) 272 273 strcpy16_htod(strings, ent.value); 274 } 275 276 strPos += totalSize; 277 } 278 279 // Pad ending string position up to a uint32_t boundary. 280 281 if (strPos&0x3) { 282 size_t padPos = ((strPos+3)&~0x3); 283 uint8_t* dat = (uint8_t*)pool->editData(preSize + padPos); 284 if (dat == NULL) { 285 fprintf(stderr, "ERROR: Out of memory padding string pool\n"); 286 return NO_MEMORY; 287 } 288 memset(dat+preSize+strPos, 0, padPos-strPos); 289 strPos = padPos; 290 } 291 292 // Build the pool of style spans. 293 294 size_t styPos = strPos; 295 for (i=0; i<STYLES; i++) { 296 entry_style& ent = mEntryStyleArray.editItemAt(i); 297 const size_t N = ent.spans.size(); 298 const size_t totalSize = (N*sizeof(ResStringPool_span)) 299 + sizeof(ResStringPool_ref); 300 301 ent.offset = styPos-strPos; 302 uint8_t* dat = (uint8_t*)pool->editData(preSize + styPos + totalSize); 303 if (dat == NULL) { 304 fprintf(stderr, "ERROR: Out of memory for string styles\n"); 305 return NO_MEMORY; 306 } 307 ResStringPool_span* span = (ResStringPool_span*)(dat+preSize+styPos); 308 for (size_t i=0; i<N; i++) { 309 span->name.index = htodl(ent.spans[i].span.name.index); 310 span->firstChar = htodl(ent.spans[i].span.firstChar); 311 span->lastChar = htodl(ent.spans[i].span.lastChar); 312 span++; 313 } 314 span->name.index = htodl(ResStringPool_span::END); 315 316 styPos += totalSize; 317 } 318 319 if (STYLES > 0) { 320 // Add full terminator at the end (when reading we validate that 321 // the end of the pool is fully terminated to simplify error 322 // checking). 323 size_t extra = sizeof(ResStringPool_span)-sizeof(ResStringPool_ref); 324 uint8_t* dat = (uint8_t*)pool->editData(preSize + styPos + extra); 325 if (dat == NULL) { 326 fprintf(stderr, "ERROR: Out of memory for string styles\n"); 327 return NO_MEMORY; 328 } 329 uint32_t* p = (uint32_t*)(dat+preSize+styPos); 330 while (extra > 0) { 331 *p++ = htodl(ResStringPool_span::END); 332 extra -= sizeof(uint32_t); 333 } 334 styPos += extra; 335 } 336 337 // Write header. 338 339 ResStringPool_header* header = 340 (ResStringPool_header*)pool->padData(sizeof(uint32_t)); 341 if (header == NULL) { 342 fprintf(stderr, "ERROR: Out of memory for string pool\n"); 343 return NO_MEMORY; 344 } 345 memset(header, 0, sizeof(*header)); 346 header->header.type = htods(RES_STRING_POOL_TYPE); 347 header->header.headerSize = htods(sizeof(*header)); 348 header->header.size = htodl(pool->getSize()); 349 header->stringCount = htodl(ENTRIES); 350 header->styleCount = htodl(STYLES); 351 if (mSorted) { 352 header->flags |= htodl(ResStringPool_header::SORTED_FLAG); 353 } 354 if (mUTF8) { 355 header->flags |= htodl(ResStringPool_header::UTF8_FLAG); 356 } 357 header->stringsStart = htodl(preSize); 358 header->stylesStart = htodl(STYLES > 0 ? (preSize+strPos) : 0); 359 360 // Write string index array. 361 362 uint32_t* index = (uint32_t*)(header+1); 363 if (mSorted) { 364 for (i=0; i<ENTRIES; i++) { 365 entry& ent = const_cast<entry&>(entryAt(i)); 366 ent.indices.clear(); 367 ent.indices.add(i); 368 *index++ = htodl(ent.offset); 369 } 370 } else { 371 for (i=0; i<ENTRIES; i++) { 372 entry& ent = mEntries.editItemAt(mEntryArray[i]); 373 *index++ = htodl(ent.offset); 374 NOISY(printf("Writing entry #%d: \"%s\" ent=%d off=%d\n", i, 375 String8(ent.value).string(), 376 mEntryArray[i], ent.offset)); 377 } 378 } 379 380 // Write style index array. 381 382 if (mSorted) { 383 for (i=0; i<STYLES; i++) { 384 LOG_ALWAYS_FATAL("Shouldn't be here!"); 385 } 386 } else { 387 for (i=0; i<STYLES; i++) { 388 *index++ = htodl(mEntryStyleArray[i].offset); 389 } 390 } 391 392 return NO_ERROR; 393 } 394 395 ssize_t StringPool::offsetForString(const String16& val) const 396 { 397 const Vector<size_t>* indices = offsetsForString(val); 398 ssize_t res = indices != NULL && indices->size() > 0 ? indices->itemAt(0) : -1; 399 NOISY(printf("Offset for string %s: %d (%s)\n", String8(val).string(), res, 400 res >= 0 ? String8(mEntries[mEntryArray[res]].value).string() : String8())); 401 return res; 402 } 403 404 const Vector<size_t>* StringPool::offsetsForString(const String16& val) const 405 { 406 ssize_t pos = mValues.valueFor(val); 407 if (pos < 0) { 408 return NULL; 409 } 410 return &mEntries[mEntryArray[pos]].indices; 411 } 412
