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