]> git.saurik.com Git - android/aapt.git/blob - ResourceTable.cpp
projects / android / aapt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
merge from open-source master
[android/aapt.git] / ResourceTable.cpp
1 //
2 // Copyright 2006 The Android Open Source Project
3 //
4 // Build resource files from raw assets.
5 //
6
7 #include "ResourceTable.h"
8
9 #include "XMLNode.h"
10
11 #include <utils/ByteOrder.h>
12 #include <utils/ResourceTypes.h>
13 #include <stdarg.h>
14
15 #define NOISY(x) //x
16
17 status_t compileXmlFile(const sp<AaptAssets>& assets,
18 const sp<AaptFile>& target,
19 ResourceTable* table,
20 int options)
21 {
22 sp<XMLNode> root = XMLNode::parse(target);
23 if (root == NULL) {
24 return UNKNOWN_ERROR;
25 }
26
27 return compileXmlFile(assets, root, target, table, options);
28 }
29
30 status_t compileXmlFile(const sp<AaptAssets>& assets,
31 const sp<XMLNode>& root,
32 const sp<AaptFile>& target,
33 ResourceTable* table,
34 int options)
35 {
36 if ((options&XML_COMPILE_STRIP_WHITESPACE) != 0) {
37 root->removeWhitespace(true, NULL);
38 } else if ((options&XML_COMPILE_COMPACT_WHITESPACE) != 0) {
39 root->removeWhitespace(false, NULL);
40 }
41
42 bool hasErrors = false;
43
44 if ((options&XML_COMPILE_ASSIGN_ATTRIBUTE_IDS) != 0) {
45 status_t err = root->assignResourceIds(assets, table);
46 if (err != NO_ERROR) {
47 hasErrors = true;
48 }
49 }
50
51 status_t err = root->parseValues(assets, table);
52 if (err != NO_ERROR) {
53 hasErrors = true;
54 }
55
56 if (hasErrors) {
57 return UNKNOWN_ERROR;
58 }
59
60 NOISY(printf("Input XML Resource:\n"));
61 NOISY(root->print());
62 err = root->flatten(target,
63 (options&XML_COMPILE_STRIP_COMMENTS) != 0,
64 (options&XML_COMPILE_STRIP_RAW_VALUES) != 0);
65 if (err != NO_ERROR) {
66 return err;
67 }
68
69 NOISY(printf("Output XML Resource:\n"));
70 NOISY(ResXMLTree tree;
71 tree.setTo(target->getData(), target->getSize());
72 printXMLBlock(&tree));
73
74 target->setCompressionMethod(ZipEntry::kCompressDeflated);
75
76 return err;
77 }
78
79 #undef NOISY
80 #define NOISY(x) //x
81
82 struct flag_entry
83 {
84 const char16_t* name;
85 size_t nameLen;
86 uint32_t value;
87 const char* description;
88 };
89
90 static const char16_t referenceArray[] =
91 { 'r', 'e', 'f', 'e', 'r', 'e', 'n', 'c', 'e' };
92 static const char16_t stringArray[] =
93 { 's', 't', 'r', 'i', 'n', 'g' };
94 static const char16_t integerArray[] =
95 { 'i', 'n', 't', 'e', 'g', 'e', 'r' };
96 static const char16_t booleanArray[] =
97 { 'b', 'o', 'o', 'l', 'e', 'a', 'n' };
98 static const char16_t colorArray[] =
99 { 'c', 'o', 'l', 'o', 'r' };
100 static const char16_t floatArray[] =
101 { 'f', 'l', 'o', 'a', 't' };
102 static const char16_t dimensionArray[] =
103 { 'd', 'i', 'm', 'e', 'n', 's', 'i', 'o', 'n' };
104 static const char16_t fractionArray[] =
105 { 'f', 'r', 'a', 'c', 't', 'i', 'o', 'n' };
106 static const char16_t enumArray[] =
107 { 'e', 'n', 'u', 'm' };
108 static const char16_t flagsArray[] =
109 { 'f', 'l', 'a', 'g', 's' };
110
111 static const flag_entry gFormatFlags[] = {
112 { referenceArray, sizeof(referenceArray)/2, ResTable_map::TYPE_REFERENCE,
113 "a reference to another resource, in the form \"<code>@[+][<i>package</i>:]<i>type</i>:<i>name</i></code>\"\n"
114 "or to a theme attribute in the form \"<code>?[<i>package</i>:][<i>type</i>:]<i>name</i></code>\"."},
115 { stringArray, sizeof(stringArray)/2, ResTable_map::TYPE_STRING,
116 "a string value, using '\\\\;' to escape characters such as '\\\\n' or '\\\\uxxxx' for a unicode character." },
117 { integerArray, sizeof(integerArray)/2, ResTable_map::TYPE_INTEGER,
118 "an integer value, such as \"<code>100</code>\"." },
119 { booleanArray, sizeof(booleanArray)/2, ResTable_map::TYPE_BOOLEAN,
120 "a boolean value, either \"<code>true</code>\" or \"<code>false</code>\"." },
121 { colorArray, sizeof(colorArray)/2, ResTable_map::TYPE_COLOR,
122 "a color value, in the form of \"<code>#<i>rgb</i></code>\", \"<code>#<i>argb</i></code>\",\n"
123 "\"<code>#<i>rrggbb</i></code>\", or \"<code>#<i>aarrggbb</i></code>\"." },
124 { floatArray, sizeof(floatArray)/2, ResTable_map::TYPE_FLOAT,
125 "a floating point value, such as \"<code>1.2</code>\"."},
126 { dimensionArray, sizeof(dimensionArray)/2, ResTable_map::TYPE_DIMENSION,
127 "a dimension value, which is a floating point number appended with a unit such as \"<code>14.5sp</code>\".\n"
128 "Available units are: px (pixels), dp (density-independent pixels), sp (scaled pixels based on preferred font size),\n"
129 "in (inches), mm (millimeters)." },
130 { fractionArray, sizeof(fractionArray)/2, ResTable_map::TYPE_FRACTION,
131 "a fractional value, which is a floating point number appended with either % or %p, such as \"<code>14.5%</code>\".\n"
132 "The % suffix always means a percentage of the base size; the optional %p suffix provides a size relative to\n"
133 "some parent container." },
134 { enumArray, sizeof(enumArray)/2, ResTable_map::TYPE_ENUM, NULL },
135 { flagsArray, sizeof(flagsArray)/2, ResTable_map::TYPE_FLAGS, NULL },
136 { NULL, 0, 0, NULL }
137 };
138
139 static const char16_t suggestedArray[] = { 's', 'u', 'g', 'g', 'e', 's', 't', 'e', 'd' };
140
141 static const flag_entry l10nRequiredFlags[] = {
142 { suggestedArray, sizeof(suggestedArray)/2, ResTable_map::L10N_SUGGESTED, NULL },
143 { NULL, 0, 0, NULL }
144 };
145
146 static const char16_t nulStr[] = { 0 };
147
148 static uint32_t parse_flags(const char16_t* str, size_t len,
149 const flag_entry* flags, bool* outError = NULL)
150 {
151 while (len > 0 && isspace(*str)) {
152 str++;
153 len--;
154 }
155 while (len > 0 && isspace(str[len-1])) {
156 len--;
157 }
158
159 const char16_t* const end = str + len;
160 uint32_t value = 0;
161
162 while (str < end) {
163 const char16_t* div = str;
164 while (div < end && *div != '|') {
165 div++;
166 }
167
168 const flag_entry* cur = flags;
169 while (cur->name) {
170 if (strzcmp16(cur->name, cur->nameLen, str, div-str) == 0) {
171 value |= cur->value;
172 break;
173 }
174 cur++;
175 }
176
177 if (!cur->name) {
178 if (outError) *outError = true;
179 return 0;
180 }
181
182 str = div < end ? div+1 : div;
183 }
184
185 if (outError) *outError = false;
186 return value;
187 }
188
189 static String16 mayOrMust(int type, int flags)
190 {
191 if ((type&(~flags)) == 0) {
192 return String16("<p>Must");
193 }
194
195 return String16("<p>May");
196 }
197
198 static void appendTypeInfo(ResourceTable* outTable, const String16& pkg,
199 const String16& typeName, const String16& ident, int type,
200 const flag_entry* flags)
201 {
202 bool hadType = false;
203 while (flags->name) {
204 if ((type&flags->value) != 0 && flags->description != NULL) {
205 String16 fullMsg(mayOrMust(type, flags->value));
206 fullMsg.append(String16(" be "));
207 fullMsg.append(String16(flags->description));
208 outTable->appendTypeComment(pkg, typeName, ident, fullMsg);
209 hadType = true;
210 }
211 flags++;
212 }
213 if (hadType && (type&ResTable_map::TYPE_REFERENCE) == 0) {
214 outTable->appendTypeComment(pkg, typeName, ident,
215 String16("<p>This may also be a reference to a resource (in the form\n"
216 "\"<code>@[<i>package</i>:]<i>type</i>:<i>name</i></code>\") or\n"
217 "theme attribute (in the form\n"
218 "\"<code>?[<i>package</i>:][<i>type</i>:]<i>name</i></code>\")\n"
219 "containing a value of this type."));
220 }
221 }
222
223 struct PendingAttribute
224 {
225 const String16 myPackage;
226 const SourcePos sourcePos;
227 const bool appendComment;
228 int32_t type;
229 String16 ident;
230 String16 comment;
231 bool hasErrors;
232 bool added;
233
234 PendingAttribute(String16 _package, const sp<AaptFile>& in,
235 ResXMLTree& block, bool _appendComment)
236 : myPackage(_package)
237 , sourcePos(in->getPrintableSource(), block.getLineNumber())
238 , appendComment(_appendComment)
239 , type(ResTable_map::TYPE_ANY)
240 , hasErrors(false)
241 , added(false)
242 {
243 }
244
245 status_t createIfNeeded(ResourceTable* outTable)
246 {
247 if (added || hasErrors) {
248 return NO_ERROR;
249 }
250 added = true;
251
252 String16 attr16("attr");
253
254 if (outTable->hasBagOrEntry(myPackage, attr16, ident)) {
255 sourcePos.error("Attribute \"%s\" has already been defined\n",
256 String8(ident).string());
257 hasErrors = true;
258 return UNKNOWN_ERROR;
259 }
260
261 char numberStr[16];
262 sprintf(numberStr, "%d", type);
263 status_t err = outTable->addBag(sourcePos, myPackage,
264 attr16, ident, String16(""),
265 String16("^type"),
266 String16(numberStr), NULL, NULL);
267 if (err != NO_ERROR) {
268 hasErrors = true;
269 return err;
270 }
271 outTable->appendComment(myPackage, attr16, ident, comment, appendComment);
272 //printf("Attribute %s comment: %s\n", String8(ident).string(),
273 // String8(comment).string());
274 return err;
275 }
276 };
277
278 static status_t compileAttribute(const sp<AaptFile>& in,
279 ResXMLTree& block,
280 const String16& myPackage,
281 ResourceTable* outTable,
282 String16* outIdent = NULL,
283 bool inStyleable = false)
284 {
285 PendingAttribute attr(myPackage, in, block, inStyleable);
286
287 const String16 attr16("attr");
288 const String16 id16("id");
289
290 // Attribute type constants.
291 const String16 enum16("enum");
292 const String16 flag16("flag");
293
294 ResXMLTree::event_code_t code;
295 size_t len;
296 status_t err;
297
298 ssize_t identIdx = block.indexOfAttribute(NULL, "name");
299 if (identIdx >= 0) {
300 attr.ident = String16(block.getAttributeStringValue(identIdx, &len));
301 if (outIdent) {
302 *outIdent = attr.ident;
303 }
304 } else {
305 attr.sourcePos.error("A 'name' attribute is required for <attr>\n");
306 attr.hasErrors = true;
307 }
308
309 attr.comment = String16(
310 block.getComment(&len) ? block.getComment(&len) : nulStr);
311
312 ssize_t typeIdx = block.indexOfAttribute(NULL, "format");
313 if (typeIdx >= 0) {
314 String16 typeStr = String16(block.getAttributeStringValue(typeIdx, &len));
315 attr.type = parse_flags(typeStr.string(), typeStr.size(), gFormatFlags);
316 if (attr.type == 0) {
317 attr.sourcePos.error("Tag <attr> 'format' attribute value \"%s\" not valid\n",
318 String8(typeStr).string());
319 attr.hasErrors = true;
320 }
321 attr.createIfNeeded(outTable);
322 } else if (!inStyleable) {
323 // Attribute definitions outside of styleables always define the
324 // attribute as a generic value.
325 attr.createIfNeeded(outTable);
326 }
327
328 //printf("Attribute %s: type=0x%08x\n", String8(attr.ident).string(), attr.type);
329
330 ssize_t minIdx = block.indexOfAttribute(NULL, "min");
331 if (minIdx >= 0) {
332 String16 val = String16(block.getAttributeStringValue(minIdx, &len));
333 if (!ResTable::stringToInt(val.string(), val.size(), NULL)) {
334 attr.sourcePos.error("Tag <attr> 'min' attribute must be a number, not \"%s\"\n",
335 String8(val).string());
336 attr.hasErrors = true;
337 }
338 attr.createIfNeeded(outTable);
339 if (!attr.hasErrors) {
340 err = outTable->addBag(attr.sourcePos, myPackage, attr16, attr.ident,
341 String16(""), String16("^min"), String16(val), NULL, NULL);
342 if (err != NO_ERROR) {
343 attr.hasErrors = true;
344 }
345 }
346 }
347
348 ssize_t maxIdx = block.indexOfAttribute(NULL, "max");
349 if (maxIdx >= 0) {
350 String16 val = String16(block.getAttributeStringValue(maxIdx, &len));
351 if (!ResTable::stringToInt(val.string(), val.size(), NULL)) {
352 attr.sourcePos.error("Tag <attr> 'max' attribute must be a number, not \"%s\"\n",
353 String8(val).string());
354 attr.hasErrors = true;
355 }
356 attr.createIfNeeded(outTable);
357 if (!attr.hasErrors) {
358 err = outTable->addBag(attr.sourcePos, myPackage, attr16, attr.ident,
359 String16(""), String16("^max"), String16(val), NULL, NULL);
360 attr.hasErrors = true;
361 }
362 }
363
364 if ((minIdx >= 0 || maxIdx >= 0) && (attr.type&ResTable_map::TYPE_INTEGER) == 0) {
365 attr.sourcePos.error("Tag <attr> must have format=integer attribute if using max or min\n");
366 attr.hasErrors = true;
367 }
368
369 ssize_t l10nIdx = block.indexOfAttribute(NULL, "localization");
370 if (l10nIdx >= 0) {
371 const uint16_t* str = block.getAttributeStringValue(l10nIdx, &len);
372 bool error;
373 uint32_t l10n_required = parse_flags(str, len, l10nRequiredFlags, &error);
374 if (error) {
375 attr.sourcePos.error("Tag <attr> 'localization' attribute value \"%s\" not valid\n",
376 String8(str).string());
377 attr.hasErrors = true;
378 }
379 attr.createIfNeeded(outTable);
380 if (!attr.hasErrors) {
381 char buf[10];
382 sprintf(buf, "%d", l10n_required);
383 err = outTable->addBag(attr.sourcePos, myPackage, attr16, attr.ident,
384 String16(""), String16("^l10n"), String16(buf), NULL, NULL);
385 if (err != NO_ERROR) {
386 attr.hasErrors = true;
387 }
388 }
389 }
390
391 String16 enumOrFlagsComment;
392
393 while ((code=block.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {
394 if (code == ResXMLTree::START_TAG) {
395 uint32_t localType = 0;
396 if (strcmp16(block.getElementName(&len), enum16.string()) == 0) {
397 localType = ResTable_map::TYPE_ENUM;
398 } else if (strcmp16(block.getElementName(&len), flag16.string()) == 0) {
399 localType = ResTable_map::TYPE_FLAGS;
400 } else {
401 SourcePos(in->getPrintableSource(), block.getLineNumber())
402 .error("Tag <%s> can not appear inside <attr>, only <enum> or <flag>\n",
403 String8(block.getElementName(&len)).string());
404 return UNKNOWN_ERROR;
405 }
406
407 attr.createIfNeeded(outTable);
408
409 if (attr.type == ResTable_map::TYPE_ANY) {
410 // No type was explicitly stated, so supplying enum tags
411 // implicitly creates an enum or flag.
412 attr.type = 0;
413 }
414
415 if ((attr.type&(ResTable_map::TYPE_ENUM|ResTable_map::TYPE_FLAGS)) == 0) {
416 // Wasn't originally specified as an enum, so update its type.
417 attr.type |= localType;
418 if (!attr.hasErrors) {
419 char numberStr[16];
420 sprintf(numberStr, "%d", attr.type);
421 err = outTable->addBag(SourcePos(in->getPrintableSource(), block.getLineNumber()),
422 myPackage, attr16, attr.ident, String16(""),
423 String16("^type"), String16(numberStr), NULL, NULL, true);
424 if (err != NO_ERROR) {
425 attr.hasErrors = true;
426 }
427 }
428 } else if ((uint32_t)(attr.type&(ResTable_map::TYPE_ENUM|ResTable_map::TYPE_FLAGS)) != localType) {
429 if (localType == ResTable_map::TYPE_ENUM) {
430 SourcePos(in->getPrintableSource(), block.getLineNumber())
431 .error("<enum> attribute can not be used inside a flags format\n");
432 attr.hasErrors = true;
433 } else {
434 SourcePos(in->getPrintableSource(), block.getLineNumber())
435 .error("<flag> attribute can not be used inside a enum format\n");
436 attr.hasErrors = true;
437 }
438 }
439
440 String16 itemIdent;
441 ssize_t itemIdentIdx = block.indexOfAttribute(NULL, "name");
442 if (itemIdentIdx >= 0) {
443 itemIdent = String16(block.getAttributeStringValue(itemIdentIdx, &len));
444 } else {
445 SourcePos(in->getPrintableSource(), block.getLineNumber())
446 .error("A 'name' attribute is required for <enum> or <flag>\n");
447 attr.hasErrors = true;
448 }
449
450 String16 value;
451 ssize_t valueIdx = block.indexOfAttribute(NULL, "value");
452 if (valueIdx >= 0) {
453 value = String16(block.getAttributeStringValue(valueIdx, &len));
454 } else {
455 SourcePos(in->getPrintableSource(), block.getLineNumber())
456 .error("A 'value' attribute is required for <enum> or <flag>\n");
457 attr.hasErrors = true;
458 }
459 if (!attr.hasErrors && !ResTable::stringToInt(value.string(), value.size(), NULL)) {
460 SourcePos(in->getPrintableSource(), block.getLineNumber())
461 .error("Tag <enum> or <flag> 'value' attribute must be a number,"
462 " not \"%s\"\n",
463 String8(value).string());
464 attr.hasErrors = true;
465 }
466
467 // Make sure an id is defined for this enum/flag identifier...
468 if (!attr.hasErrors && !outTable->hasBagOrEntry(itemIdent, &id16, &myPackage)) {
469 err = outTable->startBag(SourcePos(in->getPrintableSource(), block.getLineNumber()),
470 myPackage, id16, itemIdent, String16(), NULL);
471 if (err != NO_ERROR) {
472 attr.hasErrors = true;
473 }
474 }
475
476 if (!attr.hasErrors) {
477 if (enumOrFlagsComment.size() == 0) {
478 enumOrFlagsComment.append(mayOrMust(attr.type,
479 ResTable_map::TYPE_ENUM|ResTable_map::TYPE_FLAGS));
480 enumOrFlagsComment.append((attr.type&ResTable_map::TYPE_ENUM)
481 ? String16(" be one of the following constant values.")
482 : String16(" be one or more (separated by '|') of the following constant values."));
483 enumOrFlagsComment.append(String16("</p>\n<table border=\"2\" width=\"85%\" align=\"center\" frame=\"hsides\" rules=\"all\" cellpadding=\"5\">\n"
484 "<colgroup align=\"left\" />\n"
485 "<colgroup align=\"left\" />\n"
486 "<colgroup align=\"left\" />\n"
487 "<tr><th>Constant<th>Value<th>Description</tr>"));
488 }
489
490 enumOrFlagsComment.append(String16("\n<tr><th><code>"));
491 enumOrFlagsComment.append(itemIdent);
492 enumOrFlagsComment.append(String16("</code><td>"));
493 enumOrFlagsComment.append(value);
494 enumOrFlagsComment.append(String16("<td>"));
495 if (block.getComment(&len)) {
496 enumOrFlagsComment.append(String16(block.getComment(&len)));
497 }
498 enumOrFlagsComment.append(String16("</tr>"));
499
500 err = outTable->addBag(SourcePos(in->getPrintableSource(), block.getLineNumber()),
501 myPackage,
502 attr16, attr.ident, String16(""),
503 itemIdent, value, NULL, NULL, false, true);
504 if (err != NO_ERROR) {
505 attr.hasErrors = true;
506 }
507 }
508 } else if (code == ResXMLTree::END_TAG) {
509 if (strcmp16(block.getElementName(&len), attr16.string()) == 0) {
510 break;
511 }
512 if ((attr.type&ResTable_map::TYPE_ENUM) != 0) {
513 if (strcmp16(block.getElementName(&len), enum16.string()) != 0) {
514 SourcePos(in->getPrintableSource(), block.getLineNumber())
515 .error("Found tag </%s> where </enum> is expected\n",
516 String8(block.getElementName(&len)).string());
517 return UNKNOWN_ERROR;
518 }
519 } else {
520 if (strcmp16(block.getElementName(&len), flag16.string()) != 0) {
521 SourcePos(in->getPrintableSource(), block.getLineNumber())
522 .error("Found tag </%s> where </flag> is expected\n",
523 String8(block.getElementName(&len)).string());
524 return UNKNOWN_ERROR;
525 }
526 }
527 }
528 }
529
530 if (!attr.hasErrors && attr.added) {
531 appendTypeInfo(outTable, myPackage, attr16, attr.ident, attr.type, gFormatFlags);
532 }
533
534 if (!attr.hasErrors && enumOrFlagsComment.size() > 0) {
535 enumOrFlagsComment.append(String16("\n</table>"));
536 outTable->appendTypeComment(myPackage, attr16, attr.ident, enumOrFlagsComment);
537 }
538
539
540 return NO_ERROR;
541 }
542
543 bool localeIsDefined(const ResTable_config& config)
544 {
545 return config.locale == 0;
546 }
547
548 status_t parseAndAddBag(Bundle* bundle,
549 const sp<AaptFile>& in,
550 ResXMLTree* block,
551 const ResTable_config& config,
552 const String16& myPackage,
553 const String16& curType,
554 const String16& ident,
555 const String16& parentIdent,
556 const String16& itemIdent,
557 int32_t curFormat,
558 bool pseudolocalize,
559 const bool overwrite,
560 ResourceTable* outTable)
561 {
562 status_t err;
563 const String16 item16("item");
564
565 String16 str;
566 Vector<StringPool::entry_style_span> spans;
567 err = parseStyledString(bundle, in->getPrintableSource().string(),
568 block, item16, &str, &spans,
569 pseudolocalize);
570 if (err != NO_ERROR) {
571 return err;
572 }
573
574 NOISY(printf("Adding resource bag entry l=%c%c c=%c%c orien=%d d=%d "
575 " pid=%s, bag=%s, id=%s: %s\n",
576 config.language[0], config.language[1],
577 config.country[0], config.country[1],
578 config.orientation, config.density,
579 String8(parentIdent).string(),
580 String8(ident).string(),
581 String8(itemIdent).string(),
582 String8(str).string()));
583
584 err = outTable->addBag(SourcePos(in->getPrintableSource(), block->getLineNumber()),
585 myPackage, curType, ident, parentIdent, itemIdent, str,
586 &spans, &config, overwrite, false, curFormat);
587 return err;
588 }
589
590
591 status_t parseAndAddEntry(Bundle* bundle,
592 const sp<AaptFile>& in,
593 ResXMLTree* block,
594 const ResTable_config& config,
595 const String16& myPackage,
596 const String16& curType,
597 const String16& ident,
598 const String16& curTag,
599 bool curIsStyled,
600 int32_t curFormat,
601 bool pseudolocalize,
602 const bool overwrite,
603 ResourceTable* outTable)
604 {
605 status_t err;
606
607 String16 str;
608 Vector<StringPool::entry_style_span> spans;
609 err = parseStyledString(bundle, in->getPrintableSource().string(), block,
610 curTag, &str, curIsStyled ? &spans : NULL,
611 pseudolocalize);
612
613 if (err < NO_ERROR) {
614 return err;
615 }
616
617 NOISY(printf("Adding resource entry l=%c%c c=%c%c orien=%d d=%d id=%s: %s\n",
618 config.language[0], config.language[1],
619 config.country[0], config.country[1],
620 config.orientation, config.density,
621 String8(ident).string(), String8(str).string()));
622
623 err = outTable->addEntry(SourcePos(in->getPrintableSource(), block->getLineNumber()),
624 myPackage, curType, ident, str, &spans, &config,
625 false, curFormat, overwrite);
626
627 return err;
628 }
629
630 status_t compileResourceFile(Bundle* bundle,
631 const sp<AaptAssets>& assets,
632 const sp<AaptFile>& in,
633 const ResTable_config& defParams,
634 const bool overwrite,
635 ResourceTable* outTable)
636 {
637 ResXMLTree block;
638 status_t err = parseXMLResource(in, &block, false, true);
639 if (err != NO_ERROR) {
640 return err;
641 }
642
643 // Top-level tag.
644 const String16 resources16("resources");
645
646 // Identifier declaration tags.
647 const String16 declare_styleable16("declare-styleable");
648 const String16 attr16("attr");
649
650 // Data creation organizational tags.
651 const String16 string16("string");
652 const String16 drawable16("drawable");
653 const String16 color16("color");
654 const String16 bool16("bool");
655 const String16 integer16("integer");
656 const String16 dimen16("dimen");
657 const String16 fraction16("fraction");
658 const String16 style16("style");
659 const String16 plurals16("plurals");
660 const String16 array16("array");
661 const String16 string_array16("string-array");
662 const String16 integer_array16("integer-array");
663 const String16 public16("public");
664 const String16 public_padding16("public-padding");
665 const String16 private_symbols16("private-symbols");
666 const String16 add_resource16("add-resource");
667 const String16 skip16("skip");
668 const String16 eat_comment16("eat-comment");
669
670 // Data creation tags.
671 const String16 bag16("bag");
672 const String16 item16("item");
673
674 // Attribute type constants.
675 const String16 enum16("enum");
676
677 // plural values
678 const String16 other16("other");
679 const String16 quantityOther16("^other");
680 const String16 zero16("zero");
681 const String16 quantityZero16("^zero");
682 const String16 one16("one");
683 const String16 quantityOne16("^one");
684 const String16 two16("two");
685 const String16 quantityTwo16("^two");
686 const String16 few16("few");
687 const String16 quantityFew16("^few");
688 const String16 many16("many");
689 const String16 quantityMany16("^many");
690
691 // useful attribute names and special values
692 const String16 name16("name");
693 const String16 translatable16("translatable");
694 const String16 false16("false");
695
696 const String16 myPackage(assets->getPackage());
697
698 bool hasErrors = false;
699
700 DefaultKeyedVector<String16, uint32_t> nextPublicId(0);
701
702 ResXMLTree::event_code_t code;
703 do {
704 code = block.next();
705 } while (code == ResXMLTree::START_NAMESPACE);
706
707 size_t len;
708 if (code != ResXMLTree::START_TAG) {
709 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
710 "No start tag found\n");
711 return UNKNOWN_ERROR;
712 }
713 if (strcmp16(block.getElementName(&len), resources16.string()) != 0) {
714 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
715 "Invalid start tag %s\n", String8(block.getElementName(&len)).string());
716 return UNKNOWN_ERROR;
717 }
718
719 ResTable_config curParams(defParams);
720
721 ResTable_config pseudoParams(curParams);
722 pseudoParams.language[0] = 'z';
723 pseudoParams.language[1] = 'z';
724 pseudoParams.country[0] = 'Z';
725 pseudoParams.country[1] = 'Z';
726
727 while ((code=block.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {
728 if (code == ResXMLTree::START_TAG) {
729 const String16* curTag = NULL;
730 String16 curType;
731 int32_t curFormat = ResTable_map::TYPE_ANY;
732 bool curIsBag = false;
733 bool curIsBagReplaceOnOverwrite = false;
734 bool curIsStyled = false;
735 bool curIsPseudolocalizable = false;
736 bool localHasErrors = false;
737
738 if (strcmp16(block.getElementName(&len), skip16.string()) == 0) {
739 while ((code=block.next()) != ResXMLTree::END_DOCUMENT
740 && code != ResXMLTree::BAD_DOCUMENT) {
741 if (code == ResXMLTree::END_TAG) {
742 if (strcmp16(block.getElementName(&len), skip16.string()) == 0) {
743 break;
744 }
745 }
746 }
747 continue;
748
749 } else if (strcmp16(block.getElementName(&len), eat_comment16.string()) == 0) {
750 while ((code=block.next()) != ResXMLTree::END_DOCUMENT
751 && code != ResXMLTree::BAD_DOCUMENT) {
752 if (code == ResXMLTree::END_TAG) {
753 if (strcmp16(block.getElementName(&len), eat_comment16.string()) == 0) {
754 break;
755 }
756 }
757 }
758 continue;
759
760 } else if (strcmp16(block.getElementName(&len), public16.string()) == 0) {
761 SourcePos srcPos(in->getPrintableSource(), block.getLineNumber());
762
763 String16 type;
764 ssize_t typeIdx = block.indexOfAttribute(NULL, "type");
765 if (typeIdx < 0) {
766 srcPos.error("A 'type' attribute is required for <public>\n");
767 hasErrors = localHasErrors = true;
768 }
769 type = String16(block.getAttributeStringValue(typeIdx, &len));
770
771 String16 name;
772 ssize_t nameIdx = block.indexOfAttribute(NULL, "name");
773 if (nameIdx < 0) {
774 srcPos.error("A 'name' attribute is required for <public>\n");
775 hasErrors = localHasErrors = true;
776 }
777 name = String16(block.getAttributeStringValue(nameIdx, &len));
778
779 uint32_t ident = 0;
780 ssize_t identIdx = block.indexOfAttribute(NULL, "id");
781 if (identIdx >= 0) {
782 const char16_t* identStr = block.getAttributeStringValue(identIdx, &len);
783 Res_value identValue;
784 if (!ResTable::stringToInt(identStr, len, &identValue)) {
785 srcPos.error("Given 'id' attribute is not an integer: %s\n",
786 String8(block.getAttributeStringValue(identIdx, &len)).string());
787 hasErrors = localHasErrors = true;
788 } else {
789 ident = identValue.data;
790 nextPublicId.replaceValueFor(type, ident+1);
791 }
792 } else if (nextPublicId.indexOfKey(type) < 0) {
793 srcPos.error("No 'id' attribute supplied <public>,"
794 " and no previous id defined in this file.\n");
795 hasErrors = localHasErrors = true;
796 } else if (!localHasErrors) {
797 ident = nextPublicId.valueFor(type);
798 nextPublicId.replaceValueFor(type, ident+1);
799 }
800
801 if (!localHasErrors) {
802 err = outTable->addPublic(srcPos, myPackage, type, name, ident);
803 if (err < NO_ERROR) {
804 hasErrors = localHasErrors = true;
805 }
806 }
807 if (!localHasErrors) {
808 sp<AaptSymbols> symbols = assets->getSymbolsFor(String8("R"));
809 if (symbols != NULL) {
810 symbols = symbols->addNestedSymbol(String8(type), srcPos);
811 }
812 if (symbols != NULL) {
813 symbols->makeSymbolPublic(String8(name), srcPos);
814 String16 comment(
815 block.getComment(&len) ? block.getComment(&len) : nulStr);
816 symbols->appendComment(String8(name), comment, srcPos);
817 } else {
818 srcPos.error("Unable to create symbols!\n");
819 hasErrors = localHasErrors = true;
820 }
821 }
822
823 while ((code=block.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {
824 if (code == ResXMLTree::END_TAG) {
825 if (strcmp16(block.getElementName(&len), public16.string()) == 0) {
826 break;
827 }
828 }
829 }
830 continue;
831
832 } else if (strcmp16(block.getElementName(&len), public_padding16.string()) == 0) {
833 SourcePos srcPos(in->getPrintableSource(), block.getLineNumber());
834
835 String16 type;
836 ssize_t typeIdx = block.indexOfAttribute(NULL, "type");
837 if (typeIdx < 0) {
838 srcPos.error("A 'type' attribute is required for <public-padding>\n");
839 hasErrors = localHasErrors = true;
840 }
841 type = String16(block.getAttributeStringValue(typeIdx, &len));
842
843 String16 name;
844 ssize_t nameIdx = block.indexOfAttribute(NULL, "name");
845 if (nameIdx < 0) {
846 srcPos.error("A 'name' attribute is required for <public-padding>\n");
847 hasErrors = localHasErrors = true;
848 }
849 name = String16(block.getAttributeStringValue(nameIdx, &len));
850
851 uint32_t start = 0;
852 ssize_t startIdx = block.indexOfAttribute(NULL, "start");
853 if (startIdx >= 0) {
854 const char16_t* startStr = block.getAttributeStringValue(startIdx, &len);
855 Res_value startValue;
856 if (!ResTable::stringToInt(startStr, len, &startValue)) {
857 srcPos.error("Given 'start' attribute is not an integer: %s\n",
858 String8(block.getAttributeStringValue(startIdx, &len)).string());
859 hasErrors = localHasErrors = true;
860 } else {
861 start = startValue.data;
862 }
863 } else if (nextPublicId.indexOfKey(type) < 0) {
864 srcPos.error("No 'start' attribute supplied <public-padding>,"
865 " and no previous id defined in this file.\n");
866 hasErrors = localHasErrors = true;
867 } else if (!localHasErrors) {
868 start = nextPublicId.valueFor(type);
869 }
870
871 uint32_t end = 0;
872 ssize_t endIdx = block.indexOfAttribute(NULL, "end");
873 if (endIdx >= 0) {
874 const char16_t* endStr = block.getAttributeStringValue(endIdx, &len);
875 Res_value endValue;
876 if (!ResTable::stringToInt(endStr, len, &endValue)) {
877 srcPos.error("Given 'end' attribute is not an integer: %s\n",
878 String8(block.getAttributeStringValue(endIdx, &len)).string());
879 hasErrors = localHasErrors = true;
880 } else {
881 end = endValue.data;
882 }
883 } else {
884 srcPos.error("No 'end' attribute supplied <public-padding>\n");
885 hasErrors = localHasErrors = true;
886 }
887
888 if (end >= start) {
889 nextPublicId.replaceValueFor(type, end+1);
890 } else {
891 srcPos.error("Padding start '%ul' is after end '%ul'\n",
892 start, end);
893 hasErrors = localHasErrors = true;
894 }
895
896 String16 comment(
897 block.getComment(&len) ? block.getComment(&len) : nulStr);
898 for (uint32_t curIdent=start; curIdent<=end; curIdent++) {
899 if (localHasErrors) {
900 break;
901 }
902 String16 curName(name);
903 char buf[64];
904 sprintf(buf, "%d", (int)(end-curIdent+1));
905 curName.append(String16(buf));
906
907 err = outTable->addEntry(srcPos, myPackage, type, curName,
908 String16("padding"), NULL, &curParams, false,
909 ResTable_map::TYPE_STRING, overwrite);
910 if (err < NO_ERROR) {
911 hasErrors = localHasErrors = true;
912 break;
913 }
914 err = outTable->addPublic(srcPos, myPackage, type,
915 curName, curIdent);
916 if (err < NO_ERROR) {
917 hasErrors = localHasErrors = true;
918 break;
919 }
920 sp<AaptSymbols> symbols = assets->getSymbolsFor(String8("R"));
921 if (symbols != NULL) {
922 symbols = symbols->addNestedSymbol(String8(type), srcPos);
923 }
924 if (symbols != NULL) {
925 symbols->makeSymbolPublic(String8(curName), srcPos);
926 symbols->appendComment(String8(curName), comment, srcPos);
927 } else {
928 srcPos.error("Unable to create symbols!\n");
929 hasErrors = localHasErrors = true;
930 }
931 }
932
933 while ((code=block.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {
934 if (code == ResXMLTree::END_TAG) {
935 if (strcmp16(block.getElementName(&len), public_padding16.string()) == 0) {
936 break;
937 }
938 }
939 }
940 continue;
941
942 } else if (strcmp16(block.getElementName(&len), private_symbols16.string()) == 0) {
943 String16 pkg;
944 ssize_t pkgIdx = block.indexOfAttribute(NULL, "package");
945 if (pkgIdx < 0) {
946 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
947 "A 'package' attribute is required for <private-symbols>\n");
948 hasErrors = localHasErrors = true;
949 }
950 pkg = String16(block.getAttributeStringValue(pkgIdx, &len));
951 if (!localHasErrors) {
952 assets->setSymbolsPrivatePackage(String8(pkg));
953 }
954
955 while ((code=block.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {
956 if (code == ResXMLTree::END_TAG) {
957 if (strcmp16(block.getElementName(&len), private_symbols16.string()) == 0) {
958 break;
959 }
960 }
961 }
962 continue;
963
964 } else if (strcmp16(block.getElementName(&len), add_resource16.string()) == 0) {
965 SourcePos srcPos(in->getPrintableSource(), block.getLineNumber());
966
967 String16 typeName;
968 ssize_t typeIdx = block.indexOfAttribute(NULL, "type");
969 if (typeIdx < 0) {
970 srcPos.error("A 'type' attribute is required for <add-resource>\n");
971 hasErrors = localHasErrors = true;
972 }
973 typeName = String16(block.getAttributeStringValue(typeIdx, &len));
974
975 String16 name;
976 ssize_t nameIdx = block.indexOfAttribute(NULL, "name");
977 if (nameIdx < 0) {
978 srcPos.error("A 'name' attribute is required for <add-resource>\n");
979 hasErrors = localHasErrors = true;
980 }
981 name = String16(block.getAttributeStringValue(nameIdx, &len));
982
983 outTable->canAddEntry(srcPos, myPackage, typeName, name);
984
985 while ((code=block.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {
986 if (code == ResXMLTree::END_TAG) {
987 if (strcmp16(block.getElementName(&len), private_symbols16.string()) == 0) {
988 break;
989 }
990 }
991 }
992 continue;
993
994 } else if (strcmp16(block.getElementName(&len), declare_styleable16.string()) == 0) {
995 SourcePos srcPos(in->getPrintableSource(), block.getLineNumber());
996
997 String16 ident;
998 ssize_t identIdx = block.indexOfAttribute(NULL, "name");
999 if (identIdx < 0) {
1000 srcPos.error("A 'name' attribute is required for <declare-styleable>\n");
1001 hasErrors = localHasErrors = true;
1002 }
1003 ident = String16(block.getAttributeStringValue(identIdx, &len));
1004
1005 sp<AaptSymbols> symbols = assets->getSymbolsFor(String8("R"));
1006 if (!localHasErrors) {
1007 if (symbols != NULL) {
1008 symbols = symbols->addNestedSymbol(String8("styleable"), srcPos);
1009 }
1010 sp<AaptSymbols> styleSymbols = symbols;
1011 if (symbols != NULL) {
1012 symbols = symbols->addNestedSymbol(String8(ident), srcPos);
1013 }
1014 if (symbols == NULL) {
1015 srcPos.error("Unable to create symbols!\n");
1016 return UNKNOWN_ERROR;
1017 }
1018
1019 String16 comment(
1020 block.getComment(&len) ? block.getComment(&len) : nulStr);
1021 styleSymbols->appendComment(String8(ident), comment, srcPos);
1022 } else {
1023 symbols = NULL;
1024 }
1025
1026 while ((code=block.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {
1027 if (code == ResXMLTree::START_TAG) {
1028 if (strcmp16(block.getElementName(&len), skip16.string()) == 0) {
1029 while ((code=block.next()) != ResXMLTree::END_DOCUMENT
1030 && code != ResXMLTree::BAD_DOCUMENT) {
1031 if (code == ResXMLTree::END_TAG) {
1032 if (strcmp16(block.getElementName(&len), skip16.string()) == 0) {
1033 break;
1034 }
1035 }
1036 }
1037 continue;
1038 } else if (strcmp16(block.getElementName(&len), eat_comment16.string()) == 0) {
1039 while ((code=block.next()) != ResXMLTree::END_DOCUMENT
1040 && code != ResXMLTree::BAD_DOCUMENT) {
1041 if (code == ResXMLTree::END_TAG) {
1042 if (strcmp16(block.getElementName(&len), eat_comment16.string()) == 0) {
1043 break;
1044 }
1045 }
1046 }
1047 continue;
1048 } else if (strcmp16(block.getElementName(&len), attr16.string()) != 0) {
1049 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1050 "Tag <%s> can not appear inside <declare-styleable>, only <attr>\n",
1051 String8(block.getElementName(&len)).string());
1052 return UNKNOWN_ERROR;
1053 }
1054
1055 String16 comment(
1056 block.getComment(&len) ? block.getComment(&len) : nulStr);
1057 String16 itemIdent;
1058 err = compileAttribute(in, block, myPackage, outTable, &itemIdent, true);
1059 if (err != NO_ERROR) {
1060 hasErrors = localHasErrors = true;
1061 }
1062
1063 if (symbols != NULL) {
1064 SourcePos srcPos(String8(in->getPrintableSource()), block.getLineNumber());
1065 symbols->addSymbol(String8(itemIdent), 0, srcPos);
1066 symbols->appendComment(String8(itemIdent), comment, srcPos);
1067 //printf("Attribute %s comment: %s\n", String8(itemIdent).string(),
1068 // String8(comment).string());
1069 }
1070 } else if (code == ResXMLTree::END_TAG) {
1071 if (strcmp16(block.getElementName(&len), declare_styleable16.string()) == 0) {
1072 break;
1073 }
1074
1075 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1076 "Found tag </%s> where </attr> is expected\n",
1077 String8(block.getElementName(&len)).string());
1078 return UNKNOWN_ERROR;
1079 }
1080 }
1081 continue;
1082
1083 } else if (strcmp16(block.getElementName(&len), attr16.string()) == 0) {
1084 err = compileAttribute(in, block, myPackage, outTable, NULL);
1085 if (err != NO_ERROR) {
1086 hasErrors = true;
1087 }
1088 continue;
1089
1090 } else if (strcmp16(block.getElementName(&len), item16.string()) == 0) {
1091 curTag = &item16;
1092 ssize_t attri = block.indexOfAttribute(NULL, "type");
1093 if (attri >= 0) {
1094 curType = String16(block.getAttributeStringValue(attri, &len));
1095 ssize_t formatIdx = block.indexOfAttribute(NULL, "format");
1096 if (formatIdx >= 0) {
1097 String16 formatStr = String16(block.getAttributeStringValue(
1098 formatIdx, &len));
1099 curFormat = parse_flags(formatStr.string(), formatStr.size(),
1100 gFormatFlags);
1101 if (curFormat == 0) {
1102 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1103 "Tag <item> 'format' attribute value \"%s\" not valid\n",
1104 String8(formatStr).string());
1105 hasErrors = localHasErrors = true;
1106 }
1107 }
1108 } else {
1109 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1110 "A 'type' attribute is required for <item>\n");
1111 hasErrors = localHasErrors = true;
1112 }
1113 curIsStyled = true;
1114 } else if (strcmp16(block.getElementName(&len), string16.string()) == 0) {
1115 // Note the existence and locale of every string we process
1116 char rawLocale[16];
1117 curParams.getLocale(rawLocale);
1118 String8 locale(rawLocale);
1119 String16 name;
1120 String16 translatable;
1121
1122 size_t n = block.getAttributeCount();
1123 for (size_t i = 0; i < n; i++) {
1124 size_t length;
1125 const uint16_t* attr = block.getAttributeName(i, &length);
1126 if (strcmp16(attr, name16.string()) == 0) {
1127 name.setTo(block.getAttributeStringValue(i, &length));
1128 } else if (strcmp16(attr, translatable16.string()) == 0) {
1129 translatable.setTo(block.getAttributeStringValue(i, &length));
1130 }
1131 }
1132
1133 if (name.size() > 0) {
1134 if (translatable == false16) {
1135 // Untranslatable strings must only exist in the default [empty] locale
1136 if (locale.size() > 0) {
1137 fprintf(stderr, "aapt: warning: string '%s' in %s marked untranslatable but exists"
1138 " in locale '%s'\n", String8(name).string(),
1139 bundle->getResourceSourceDirs()[0],
1140 locale.string());
1141 // hasErrors = localHasErrors = true;
1142 } else {
1143 // Intentionally empty block:
1144 //
1145 // Don't add untranslatable strings to the localization table; that
1146 // way if we later see localizations of them, they'll be flagged as
1147 // having no default translation.
1148 }
1149 } else {
1150 outTable->addLocalization(name, locale);
1151 }
1152 }
1153
1154 curTag = &string16;
1155 curType = string16;
1156 curFormat = ResTable_map::TYPE_REFERENCE|ResTable_map::TYPE_STRING;
1157 curIsStyled = true;
1158 curIsPseudolocalizable = true;
1159 } else if (strcmp16(block.getElementName(&len), drawable16.string()) == 0) {
1160 curTag = &drawable16;
1161 curType = drawable16;
1162 curFormat = ResTable_map::TYPE_REFERENCE|ResTable_map::TYPE_COLOR;
1163 } else if (strcmp16(block.getElementName(&len), color16.string()) == 0) {
1164 curTag = &color16;
1165 curType = color16;
1166 curFormat = ResTable_map::TYPE_REFERENCE|ResTable_map::TYPE_COLOR;
1167 } else if (strcmp16(block.getElementName(&len), bool16.string()) == 0) {
1168 curTag = &bool16;
1169 curType = bool16;
1170 curFormat = ResTable_map::TYPE_REFERENCE|ResTable_map::TYPE_BOOLEAN;
1171 } else if (strcmp16(block.getElementName(&len), integer16.string()) == 0) {
1172 curTag = &integer16;
1173 curType = integer16;
1174 curFormat = ResTable_map::TYPE_REFERENCE|ResTable_map::TYPE_INTEGER;
1175 } else if (strcmp16(block.getElementName(&len), dimen16.string()) == 0) {
1176 curTag = &dimen16;
1177 curType = dimen16;
1178 curFormat = ResTable_map::TYPE_REFERENCE|ResTable_map::TYPE_DIMENSION;
1179 } else if (strcmp16(block.getElementName(&len), fraction16.string()) == 0) {
1180 curTag = &fraction16;
1181 curType = fraction16;
1182 curFormat = ResTable_map::TYPE_REFERENCE|ResTable_map::TYPE_FRACTION;
1183 } else if (strcmp16(block.getElementName(&len), bag16.string()) == 0) {
1184 curTag = &bag16;
1185 curIsBag = true;
1186 ssize_t attri = block.indexOfAttribute(NULL, "type");
1187 if (attri >= 0) {
1188 curType = String16(block.getAttributeStringValue(attri, &len));
1189 } else {
1190 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1191 "A 'type' attribute is required for <bag>\n");
1192 hasErrors = localHasErrors = true;
1193 }
1194 } else if (strcmp16(block.getElementName(&len), style16.string()) == 0) {
1195 curTag = &style16;
1196 curType = style16;
1197 curIsBag = true;
1198 } else if (strcmp16(block.getElementName(&len), plurals16.string()) == 0) {
1199 curTag = &plurals16;
1200 curType = plurals16;
1201 curIsBag = true;
1202 } else if (strcmp16(block.getElementName(&len), array16.string()) == 0) {
1203 curTag = &array16;
1204 curType = array16;
1205 curIsBag = true;
1206 curIsBagReplaceOnOverwrite = true;
1207 ssize_t formatIdx = block.indexOfAttribute(NULL, "format");
1208 if (formatIdx >= 0) {
1209 String16 formatStr = String16(block.getAttributeStringValue(
1210 formatIdx, &len));
1211 curFormat = parse_flags(formatStr.string(), formatStr.size(),
1212 gFormatFlags);
1213 if (curFormat == 0) {
1214 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1215 "Tag <array> 'format' attribute value \"%s\" not valid\n",
1216 String8(formatStr).string());
1217 hasErrors = localHasErrors = true;
1218 }
1219 }
1220 } else if (strcmp16(block.getElementName(&len), string_array16.string()) == 0) {
1221 curTag = &string_array16;
1222 curType = array16;
1223 curFormat = ResTable_map::TYPE_REFERENCE|ResTable_map::TYPE_STRING;
1224 curIsBag = true;
1225 curIsBagReplaceOnOverwrite = true;
1226 curIsPseudolocalizable = true;
1227 } else if (strcmp16(block.getElementName(&len), integer_array16.string()) == 0) {
1228 curTag = &integer_array16;
1229 curType = array16;
1230 curFormat = ResTable_map::TYPE_REFERENCE|ResTable_map::TYPE_INTEGER;
1231 curIsBag = true;
1232 curIsBagReplaceOnOverwrite = true;
1233 } else {
1234 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1235 "Found tag %s where item is expected\n",
1236 String8(block.getElementName(&len)).string());
1237 return UNKNOWN_ERROR;
1238 }
1239
1240 String16 ident;
1241 ssize_t identIdx = block.indexOfAttribute(NULL, "name");
1242 if (identIdx >= 0) {
1243 ident = String16(block.getAttributeStringValue(identIdx, &len));
1244 } else {
1245 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1246 "A 'name' attribute is required for <%s>\n",
1247 String8(*curTag).string());
1248 hasErrors = localHasErrors = true;
1249 }
1250
1251 String16 comment(block.getComment(&len) ? block.getComment(&len) : nulStr);
1252
1253 if (curIsBag) {
1254 // Figure out the parent of this bag...
1255 String16 parentIdent;
1256 ssize_t parentIdentIdx = block.indexOfAttribute(NULL, "parent");
1257 if (parentIdentIdx >= 0) {
1258 parentIdent = String16(block.getAttributeStringValue(parentIdentIdx, &len));
1259 } else {
1260 ssize_t sep = ident.findLast('.');
1261 if (sep >= 0) {
1262 parentIdent.setTo(ident, sep);
1263 }
1264 }
1265
1266 if (!localHasErrors) {
1267 err = outTable->startBag(SourcePos(in->getPrintableSource(),
1268 block.getLineNumber()), myPackage, curType, ident,
1269 parentIdent, &curParams,
1270 overwrite, curIsBagReplaceOnOverwrite);
1271 if (err != NO_ERROR) {
1272 hasErrors = localHasErrors = true;
1273 }
1274 }
1275
1276 ssize_t elmIndex = 0;
1277 char elmIndexStr[14];
1278 while ((code=block.next()) != ResXMLTree::END_DOCUMENT
1279 && code != ResXMLTree::BAD_DOCUMENT) {
1280
1281 if (code == ResXMLTree::START_TAG) {
1282 if (strcmp16(block.getElementName(&len), item16.string()) != 0) {
1283 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1284 "Tag <%s> can not appear inside <%s>, only <item>\n",
1285 String8(block.getElementName(&len)).string(),
1286 String8(*curTag).string());
1287 return UNKNOWN_ERROR;
1288 }
1289
1290 String16 itemIdent;
1291 if (curType == array16) {
1292 sprintf(elmIndexStr, "^index_%d", (int)elmIndex++);
1293 itemIdent = String16(elmIndexStr);
1294 } else if (curType == plurals16) {
1295 ssize_t itemIdentIdx = block.indexOfAttribute(NULL, "quantity");
1296 if (itemIdentIdx >= 0) {
1297 String16 quantity16(block.getAttributeStringValue(itemIdentIdx, &len));
1298 if (quantity16 == other16) {
1299 itemIdent = quantityOther16;
1300 }
1301 else if (quantity16 == zero16) {
1302 itemIdent = quantityZero16;
1303 }
1304 else if (quantity16 == one16) {
1305 itemIdent = quantityOne16;
1306 }
1307 else if (quantity16 == two16) {
1308 itemIdent = quantityTwo16;
1309 }
1310 else if (quantity16 == few16) {
1311 itemIdent = quantityFew16;
1312 }
1313 else if (quantity16 == many16) {
1314 itemIdent = quantityMany16;
1315 }
1316 else {
1317 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1318 "Illegal 'quantity' attribute is <item> inside <plurals>\n");
1319 hasErrors = localHasErrors = true;
1320 }
1321 } else {
1322 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1323 "A 'quantity' attribute is required for <item> inside <plurals>\n");
1324 hasErrors = localHasErrors = true;
1325 }
1326 } else {
1327 ssize_t itemIdentIdx = block.indexOfAttribute(NULL, "name");
1328 if (itemIdentIdx >= 0) {
1329 itemIdent = String16(block.getAttributeStringValue(itemIdentIdx, &len));
1330 } else {
1331 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1332 "A 'name' attribute is required for <item>\n");
1333 hasErrors = localHasErrors = true;
1334 }
1335 }
1336
1337 ResXMLParser::ResXMLPosition parserPosition;
1338 block.getPosition(&parserPosition);
1339
1340 err = parseAndAddBag(bundle, in, &block, curParams, myPackage, curType,
1341 ident, parentIdent, itemIdent, curFormat,
1342 false, overwrite, outTable);
1343 if (err == NO_ERROR) {
1344 if (curIsPseudolocalizable && localeIsDefined(curParams)
1345 && bundle->getPseudolocalize()) {
1346 // pseudolocalize here
1347 #if 1
1348 block.setPosition(parserPosition);
1349 err = parseAndAddBag(bundle, in, &block, pseudoParams, myPackage,
1350 curType, ident, parentIdent, itemIdent, curFormat, true,
1351 overwrite, outTable);
1352 #endif
1353 }
1354 }
1355 if (err != NO_ERROR) {
1356 hasErrors = localHasErrors = true;
1357 }
1358 } else if (code == ResXMLTree::END_TAG) {
1359 if (strcmp16(block.getElementName(&len), curTag->string()) != 0) {
1360 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1361 "Found tag </%s> where </%s> is expected\n",
1362 String8(block.getElementName(&len)).string(),
1363 String8(*curTag).string());
1364 return UNKNOWN_ERROR;
1365 }
1366 break;
1367 }
1368 }
1369 } else {
1370 ResXMLParser::ResXMLPosition parserPosition;
1371 block.getPosition(&parserPosition);
1372
1373 err = parseAndAddEntry(bundle, in, &block, curParams, myPackage, curType, ident,
1374 *curTag, curIsStyled, curFormat, false, overwrite, outTable);
1375
1376 if (err < NO_ERROR) { // Why err < NO_ERROR instead of err != NO_ERROR?
1377 hasErrors = localHasErrors = true;
1378 }
1379 else if (err == NO_ERROR) {
1380 if (curIsPseudolocalizable && localeIsDefined(curParams)
1381 && bundle->getPseudolocalize()) {
1382 // pseudolocalize here
1383 block.setPosition(parserPosition);
1384 err = parseAndAddEntry(bundle, in, &block, pseudoParams, myPackage, curType,
1385 ident, *curTag, curIsStyled, curFormat, true, overwrite, outTable);
1386 if (err != NO_ERROR) {
1387 hasErrors = localHasErrors = true;
1388 }
1389 }
1390 }
1391 }
1392
1393 #if 0
1394 if (comment.size() > 0) {
1395 printf("Comment for @%s:%s/%s: %s\n", String8(myPackage).string(),
1396 String8(curType).string(), String8(ident).string(),
1397 String8(comment).string());
1398 }
1399 #endif
1400 if (!localHasErrors) {
1401 outTable->appendComment(myPackage, curType, ident, comment, false);
1402 }
1403 }
1404 else if (code == ResXMLTree::END_TAG) {
1405 if (strcmp16(block.getElementName(&len), resources16.string()) != 0) {
1406 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1407 "Unexpected end tag %s\n", String8(block.getElementName(&len)).string());
1408 return UNKNOWN_ERROR;
1409 }
1410 }
1411 else if (code == ResXMLTree::START_NAMESPACE || code == ResXMLTree::END_NAMESPACE) {
1412 }
1413 else if (code == ResXMLTree::TEXT) {
1414 if (isWhitespace(block.getText(&len))) {
1415 continue;
1416 }
1417 SourcePos(in->getPrintableSource(), block.getLineNumber()).error(
1418 "Found text \"%s\" where item tag is expected\n",
1419 String8(block.getText(&len)).string());
1420 return UNKNOWN_ERROR;
1421 }
1422 }
1423
1424 return hasErrors ? UNKNOWN_ERROR : NO_ERROR;
1425 }
1426
1427 ResourceTable::ResourceTable(Bundle* bundle, const String16& assetsPackage)
1428 : mAssetsPackage(assetsPackage), mNextPackageId(1), mHaveAppPackage(false),
1429 mIsAppPackage(!bundle->getExtending()),
1430 mNumLocal(0),
1431 mBundle(bundle)
1432 {
1433 }
1434
1435 status_t ResourceTable::addIncludedResources(Bundle* bundle, const sp<AaptAssets>& assets)
1436 {
1437 status_t err = assets->buildIncludedResources(bundle);
1438 if (err != NO_ERROR) {
1439 return err;
1440 }
1441
1442 // For future reference to included resources.
1443 mAssets = assets;
1444
1445 const ResTable& incl = assets->getIncludedResources();
1446
1447 // Retrieve all the packages.
1448 const size_t N = incl.getBasePackageCount();
1449 for (size_t phase=0; phase<2; phase++) {
1450 for (size_t i=0; i<N; i++) {
1451 String16 name(incl.getBasePackageName(i));
1452 uint32_t id = incl.getBasePackageId(i);
1453 // First time through: only add base packages (id
1454 // is not 0); second time through add the other
1455 // packages.
1456 if (phase != 0) {
1457 if (id != 0) {
1458 // Skip base packages -- already one.
1459 id = 0;
1460 } else {
1461 // Assign a dynamic id.
1462 id = mNextPackageId;
1463 }
1464 } else if (id != 0) {
1465 if (id == 127) {
1466 if (mHaveAppPackage) {
1467 fprintf(stderr, "Included resources have two application packages!\n");
1468 return UNKNOWN_ERROR;
1469 }
1470 mHaveAppPackage = true;
1471 }
1472 if (mNextPackageId > id) {
1473 fprintf(stderr, "Included base package ID %d already in use!\n", id);
1474 return UNKNOWN_ERROR;
1475 }
1476 }
1477 if (id != 0) {
1478 NOISY(printf("Including package %s with ID=%d\n",
1479 String8(name).string(), id));
1480 sp<Package> p = new Package(name, id);
1481 mPackages.add(name, p);
1482 mOrderedPackages.add(p);
1483
1484 if (id >= mNextPackageId) {
1485 mNextPackageId = id+1;
1486 }
1487 }
1488 }
1489 }
1490
1491 // Every resource table always has one first entry, the bag attributes.
1492 const SourcePos unknown(String8("????"), 0);
1493 sp<Type> attr = getType(mAssetsPackage, String16("attr"), unknown);
1494
1495 return NO_ERROR;
1496 }
1497
1498 status_t ResourceTable::addPublic(const SourcePos& sourcePos,
1499 const String16& package,
1500 const String16& type,
1501 const String16& name,
1502 const uint32_t ident)
1503 {
1504 uint32_t rid = mAssets->getIncludedResources()
1505 .identifierForName(name.string(), name.size(),
1506 type.string(), type.size(),
1507 package.string(), package.size());
1508 if (rid != 0) {
1509 sourcePos.error("Error declaring public resource %s/%s for included package %s\n",
1510 String8(type).string(), String8(name).string(),
1511 String8(package).string());
1512 return UNKNOWN_ERROR;
1513 }
1514
1515 sp<Type> t = getType(package, type, sourcePos);
1516 if (t == NULL) {
1517 return UNKNOWN_ERROR;
1518 }
1519 return t->addPublic(sourcePos, name, ident);
1520 }
1521
1522 status_t ResourceTable::addEntry(const SourcePos& sourcePos,
1523 const String16& package,
1524 const String16& type,
1525 const String16& name,
1526 const String16& value,
1527 const Vector<StringPool::entry_style_span>* style,
1528 const ResTable_config* params,
1529 const bool doSetIndex,
1530 const int32_t format,
1531 const bool overwrite)
1532 {
1533 // Check for adding entries in other packages... for now we do
1534 // nothing. We need to do the right thing here to support skinning.
1535 uint32_t rid = mAssets->getIncludedResources()
1536 .identifierForName(name.string(), name.size(),
1537 type.string(), type.size(),
1538 package.string(), package.size());
1539 if (rid != 0) {
1540 return NO_ERROR;
1541 }
1542
1543 #if 0
1544 if (name == String16("left")) {
1545 printf("Adding entry left: file=%s, line=%d, type=%s, value=%s\n",
1546 sourcePos.file.string(), sourcePos.line, String8(type).string(),
1547 String8(value).string());
1548 }
1549 #endif
1550
1551 sp<Entry> e = getEntry(package, type, name, sourcePos, overwrite,
1552 params, doSetIndex);
1553 if (e == NULL) {
1554 return UNKNOWN_ERROR;
1555 }
1556 status_t err = e->setItem(sourcePos, value, style, format, overwrite);
1557 if (err == NO_ERROR) {
1558 mNumLocal++;
1559 }
1560 return err;
1561 }
1562
1563 status_t ResourceTable::startBag(const SourcePos& sourcePos,
1564 const String16& package,
1565 const String16& type,
1566 const String16& name,
1567 const String16& bagParent,
1568 const ResTable_config* params,
1569 bool overlay,
1570 bool replace, bool isId)
1571 {
1572 status_t result = NO_ERROR;
1573
1574 // Check for adding entries in other packages... for now we do
1575 // nothing. We need to do the right thing here to support skinning.
1576 uint32_t rid = mAssets->getIncludedResources()
1577 .identifierForName(name.string(), name.size(),
1578 type.string(), type.size(),
1579 package.string(), package.size());
1580 if (rid != 0) {
1581 return NO_ERROR;
1582 }
1583
1584 #if 0
1585 if (name == String16("left")) {
1586 printf("Adding bag left: file=%s, line=%d, type=%s\n",
1587 sourcePos.file.striing(), sourcePos.line, String8(type).string());
1588 }
1589 #endif
1590 if (overlay && !hasBagOrEntry(package, type, name)) {
1591 bool canAdd = false;
1592 sp<Package> p = mPackages.valueFor(package);
1593 if (p != NULL) {
1594 sp<Type> t = p->getTypes().valueFor(type);
1595 if (t != NULL) {
1596 if (t->getCanAddEntries().indexOf(name) >= 0) {
1597 canAdd = true;
1598 }
1599 }
1600 }
1601 if (!canAdd) {
1602 sourcePos.error("Resource does not already exist in overlay at '%s'; use <add-resource> to add.\n",
1603 String8(name).string());
1604 return UNKNOWN_ERROR;
1605 }
1606 }
1607 sp<Entry> e = getEntry(package, type, name, sourcePos, overlay, params);
1608 if (e == NULL) {
1609 return UNKNOWN_ERROR;
1610 }
1611
1612 // If a parent is explicitly specified, set it.
1613 if (bagParent.size() > 0) {
1614 String16 curPar = e->getParent();
1615 if (curPar.size() > 0 && curPar != bagParent) {
1616 sourcePos.error("Conflicting parents specified, was '%s', now '%s'\n",
1617 String8(e->getParent()).string(),
1618 String8(bagParent).string());
1619 return UNKNOWN_ERROR;
1620 }
1621 e->setParent(bagParent);
1622 }
1623
1624 if ((result = e->makeItABag(sourcePos)) != NO_ERROR) {
1625 return result;
1626 }
1627
1628 if (overlay && replace) {
1629 return e->emptyBag(sourcePos);
1630 }
1631 return result;
1632 }
1633
1634 status_t ResourceTable::addBag(const SourcePos& sourcePos,
1635 const String16& package,
1636 const String16& type,
1637 const String16& name,
1638 const String16& bagParent,
1639 const String16& bagKey,
1640 const String16& value,
1641 const Vector<StringPool::entry_style_span>* style,
1642 const ResTable_config* params,
1643 bool replace, bool isId, const int32_t format)
1644 {
1645 // Check for adding entries in other packages... for now we do
1646 // nothing. We need to do the right thing here to support skinning.
1647 uint32_t rid = mAssets->getIncludedResources()
1648 .identifierForName(name.string(), name.size(),
1649 type.string(), type.size(),
1650 package.string(), package.size());
1651 if (rid != 0) {
1652 return NO_ERROR;
1653 }
1654
1655 #if 0
1656 if (name == String16("left")) {
1657 printf("Adding bag left: file=%s, line=%d, type=%s\n",
1658 sourcePos.file.striing(), sourcePos.line, String8(type).string());
1659 }
1660 #endif
1661 sp<Entry> e = getEntry(package, type, name, sourcePos, replace, params);
1662 if (e == NULL) {
1663 return UNKNOWN_ERROR;
1664 }
1665
1666 // If a parent is explicitly specified, set it.
1667 if (bagParent.size() > 0) {
1668 String16 curPar = e->getParent();
1669 if (curPar.size() > 0 && curPar != bagParent) {
1670 sourcePos.error("Conflicting parents specified, was '%s', now '%s'\n",
1671 String8(e->getParent()).string(),
1672 String8(bagParent).string());
1673 return UNKNOWN_ERROR;
1674 }
1675 e->setParent(bagParent);
1676 }
1677
1678 const bool first = e->getBag().indexOfKey(bagKey) < 0;
1679 status_t err = e->addToBag(sourcePos, bagKey, value, style, replace, isId, format);
1680 if (err == NO_ERROR && first) {
1681 mNumLocal++;
1682 }
1683 return err;
1684 }
1685
1686 bool ResourceTable::hasBagOrEntry(const String16& package,
1687 const String16& type,
1688 const String16& name) const
1689 {
1690 // First look for this in the included resources...
1691 uint32_t rid = mAssets->getIncludedResources()
1692 .identifierForName(name.string(), name.size(),
1693 type.string(), type.size(),
1694 package.string(), package.size());
1695 if (rid != 0) {
1696 return true;
1697 }
1698
1699 sp<Package> p = mPackages.valueFor(package);
1700 if (p != NULL) {
1701 sp<Type> t = p->getTypes().valueFor(type);
1702 if (t != NULL) {
1703 sp<ConfigList> c = t->getConfigs().valueFor(name);
1704 if (c != NULL) return true;
1705 }
1706 }
1707
1708 return false;
1709 }
1710
1711 bool ResourceTable::hasBagOrEntry(const String16& ref,
1712 const String16* defType,
1713 const String16* defPackage)
1714 {
1715 String16 package, type, name;
1716 if (!ResTable::expandResourceRef(ref.string(), ref.size(), &package, &type, &name,
1717 defType, defPackage ? defPackage:&mAssetsPackage, NULL)) {
1718 return false;
1719 }
1720 return hasBagOrEntry(package, type, name);
1721 }
1722
1723 bool ResourceTable::appendComment(const String16& package,
1724 const String16& type,
1725 const String16& name,
1726 const String16& comment,
1727 bool onlyIfEmpty)
1728 {
1729 if (comment.size() <= 0) {
1730 return true;
1731 }
1732
1733 sp<Package> p = mPackages.valueFor(package);
1734 if (p != NULL) {
1735 sp<Type> t = p->getTypes().valueFor(type);
1736 if (t != NULL) {
1737 sp<ConfigList> c = t->getConfigs().valueFor(name);
1738 if (c != NULL) {
1739 c->appendComment(comment, onlyIfEmpty);
1740 return true;
1741 }
1742 }
1743 }
1744 return false;
1745 }
1746
1747 bool ResourceTable::appendTypeComment(const String16& package,
1748 const String16& type,
1749 const String16& name,
1750 const String16& comment)
1751 {
1752 if (comment.size() <= 0) {
1753 return true;
1754 }
1755
1756 sp<Package> p = mPackages.valueFor(package);
1757 if (p != NULL) {
1758 sp<Type> t = p->getTypes().valueFor(type);
1759 if (t != NULL) {
1760 sp<ConfigList> c = t->getConfigs().valueFor(name);
1761 if (c != NULL) {
1762 c->appendTypeComment(comment);
1763 return true;
1764 }
1765 }
1766 }
1767 return false;
1768 }
1769
1770 void ResourceTable::canAddEntry(const SourcePos& pos,
1771 const String16& package, const String16& type, const String16& name)
1772 {
1773 sp<Type> t = getType(package, type, pos);
1774 if (t != NULL) {
1775 t->canAddEntry(name);
1776 }
1777 }
1778
1779 size_t ResourceTable::size() const {
1780 return mPackages.size();
1781 }
1782
1783 size_t ResourceTable::numLocalResources() const {
1784 return mNumLocal;
1785 }
1786
1787 bool ResourceTable::hasResources() const {
1788 return mNumLocal > 0;
1789 }
1790
1791 sp<AaptFile> ResourceTable::flatten(Bundle* bundle)
1792 {
1793 sp<AaptFile> data = new AaptFile(String8(), AaptGroupEntry(), String8());
1794 status_t err = flatten(bundle, data);
1795 return err == NO_ERROR ? data : NULL;
1796 }
1797
1798 inline uint32_t ResourceTable::getResId(const sp<Package>& p,
1799 const sp<Type>& t,
1800 uint32_t nameId)
1801 {
1802 return makeResId(p->getAssignedId(), t->getIndex(), nameId);
1803 }
1804
1805 uint32_t ResourceTable::getResId(const String16& package,
1806 const String16& type,
1807 const String16& name,
1808 bool onlyPublic) const
1809 {
1810 sp<Package> p = mPackages.valueFor(package);
1811 if (p == NULL) return 0;
1812
1813 // First look for this in the included resources...
1814 uint32_t specFlags = 0;
1815 uint32_t rid = mAssets->getIncludedResources()
1816 .identifierForName(name.string(), name.size(),
1817 type.string(), type.size(),
1818 package.string(), package.size(),
1819 &specFlags);
1820 if (rid != 0) {
1821 if (onlyPublic) {
1822 if ((specFlags & ResTable_typeSpec::SPEC_PUBLIC) == 0) {
1823 return 0;
1824 }
1825 }
1826
1827 if (Res_INTERNALID(rid)) {
1828 return rid;
1829 }
1830 return Res_MAKEID(p->getAssignedId()-1,
1831 Res_GETTYPE(rid),
1832 Res_GETENTRY(rid));
1833 }
1834
1835 sp<Type> t = p->getTypes().valueFor(type);
1836 if (t == NULL) return 0;
1837 sp<ConfigList> c = t->getConfigs().valueFor(name);
1838 if (c == NULL) return 0;
1839 int32_t ei = c->getEntryIndex();
1840 if (ei < 0) return 0;
1841 return getResId(p, t, ei);
1842 }
1843
1844 uint32_t ResourceTable::getResId(const String16& ref,
1845 const String16* defType,
1846 const String16* defPackage,
1847 const char** outErrorMsg,
1848 bool onlyPublic) const
1849 {
1850 String16 package, type, name;
1851 if (!ResTable::expandResourceRef(
1852 ref.string(), ref.size(), &package, &type, &name,
1853 defType, defPackage ? defPackage:&mAssetsPackage,
1854 outErrorMsg)) {
1855 NOISY(printf("Expanding resource: ref=%s\n",
1856 String8(ref).string()));
1857 NOISY(printf("Expanding resource: defType=%s\n",
1858 defType ? String8(*defType).string() : "NULL"));
1859 NOISY(printf("Expanding resource: defPackage=%s\n",
1860 defPackage ? String8(*defPackage).string() : "NULL"));
1861 NOISY(printf("Expanding resource: ref=%s\n", String8(ref).string()));
1862 NOISY(printf("Expanded resource: p=%s, t=%s, n=%s, res=0\n",
1863 String8(package).string(), String8(type).string(),
1864 String8(name).string()));
1865 return 0;
1866 }
1867 uint32_t res = getResId(package, type, name, onlyPublic);
1868 NOISY(printf("Expanded resource: p=%s, t=%s, n=%s, res=%d\n",
1869 String8(package).string(), String8(type).string(),
1870 String8(name).string(), res));
1871 if (res == 0) {
1872 if (outErrorMsg)
1873 *outErrorMsg = "No resource found that matches the given name";
1874 }
1875 return res;
1876 }
1877
1878 bool ResourceTable::isValidResourceName(const String16& s)
1879 {
1880 const char16_t* p = s.string();
1881 bool first = true;
1882 while (*p) {
1883 if ((*p >= 'a' && *p <= 'z')
1884 || (*p >= 'A' && *p <= 'Z')
1885 || *p == '_'
1886 || (!first && *p >= '0' && *p <= '9')) {
1887 first = false;
1888 p++;
1889 continue;
1890 }
1891 return false;
1892 }
1893 return true;
1894 }
1895
1896 bool ResourceTable::stringToValue(Res_value* outValue, StringPool* pool,
1897 const String16& str,
1898 bool preserveSpaces, bool coerceType,
1899 uint32_t attrID,
1900 const Vector<StringPool::entry_style_span>* style,
1901 String16* outStr, void* accessorCookie,
1902 uint32_t attrType)
1903 {
1904 String16 finalStr;
1905
1906 bool res = true;
1907 if (style == NULL || style->size() == 0) {
1908 // Text is not styled so it can be any type... let's figure it out.
1909 res = mAssets->getIncludedResources()
1910 .stringToValue(outValue, &finalStr, str.string(), str.size(), preserveSpaces,
1911 coerceType, attrID, NULL, &mAssetsPackage, this,
1912 accessorCookie, attrType);
1913 } else {
1914 // Styled text can only be a string, and while collecting the style
1915 // information we have already processed that string!
1916 outValue->size = sizeof(Res_value);
1917 outValue->res0 = 0;
1918 outValue->dataType = outValue->TYPE_STRING;
1919 outValue->data = 0;
1920 finalStr = str;
1921 }
1922
1923 if (!res) {
1924 return false;
1925 }
1926
1927 if (outValue->dataType == outValue->TYPE_STRING) {
1928 // Should do better merging styles.
1929 if (pool) {
1930 if (style != NULL && style->size() > 0) {
1931 outValue->data = pool->add(finalStr, *style);
1932 } else {
1933 outValue->data = pool->add(finalStr, true);
1934 }
1935 } else {
1936 // Caller will fill this in later.
1937 outValue->data = 0;
1938 }
1939
1940 if (outStr) {
1941 *outStr = finalStr;
1942 }
1943
1944 }
1945
1946 return true;
1947 }
1948
1949 uint32_t ResourceTable::getCustomResource(
1950 const String16& package, const String16& type, const String16& name) const
1951 {
1952 //printf("getCustomResource: %s %s %s\n", String8(package).string(),
1953 // String8(type).string(), String8(name).string());
1954 sp<Package> p = mPackages.valueFor(package);
1955 if (p == NULL) return 0;
1956 sp<Type> t = p->getTypes().valueFor(type);
1957 if (t == NULL) return 0;
1958 sp<ConfigList> c = t->getConfigs().valueFor(name);
1959 if (c == NULL) return 0;
1960 int32_t ei = c->getEntryIndex();
1961 if (ei < 0) return 0;
1962 return getResId(p, t, ei);
1963 }
1964
1965 uint32_t ResourceTable::getCustomResourceWithCreation(
1966 const String16& package, const String16& type, const String16& name,
1967 const bool createIfNotFound)
1968 {
1969 uint32_t resId = getCustomResource(package, type, name);
1970 if (resId != 0 || !createIfNotFound) {
1971 return resId;
1972 }
1973 String16 value("false");
1974
1975 status_t status = addEntry(mCurrentXmlPos, package, type, name, value, NULL, NULL, true);
1976 if (status == NO_ERROR) {
1977 resId = getResId(package, type, name);
1978 return resId;
1979 }
1980 return 0;
1981 }
1982
1983 uint32_t ResourceTable::getRemappedPackage(uint32_t origPackage) const
1984 {
1985 return origPackage;
1986 }
1987
1988 bool ResourceTable::getAttributeType(uint32_t attrID, uint32_t* outType)
1989 {
1990 //printf("getAttributeType #%08x\n", attrID);
1991 Res_value value;
1992 if (getItemValue(attrID, ResTable_map::ATTR_TYPE, &value)) {
1993 //printf("getAttributeType #%08x (%s): #%08x\n", attrID,
1994 // String8(getEntry(attrID)->getName()).string(), value.data);
1995 *outType = value.data;
1996 return true;
1997 }
1998 return false;
1999 }
2000
2001 bool ResourceTable::getAttributeMin(uint32_t attrID, uint32_t* outMin)
2002 {
2003 //printf("getAttributeMin #%08x\n", attrID);
2004 Res_value value;
2005 if (getItemValue(attrID, ResTable_map::ATTR_MIN, &value)) {
2006 *outMin = value.data;
2007 return true;
2008 }
2009 return false;
2010 }
2011
2012 bool ResourceTable::getAttributeMax(uint32_t attrID, uint32_t* outMax)
2013 {
2014 //printf("getAttributeMax #%08x\n", attrID);
2015 Res_value value;
2016 if (getItemValue(attrID, ResTable_map::ATTR_MAX, &value)) {
2017 *outMax = value.data;
2018 return true;
2019 }
2020 return false;
2021 }
2022
2023 uint32_t ResourceTable::getAttributeL10N(uint32_t attrID)
2024 {
2025 //printf("getAttributeL10N #%08x\n", attrID);
2026 Res_value value;
2027 if (getItemValue(attrID, ResTable_map::ATTR_L10N, &value)) {
2028 return value.data;
2029 }
2030 return ResTable_map::L10N_NOT_REQUIRED;
2031 }
2032
2033 bool ResourceTable::getLocalizationSetting()
2034 {
2035 return mBundle->getRequireLocalization();
2036 }
2037
2038 void ResourceTable::reportError(void* accessorCookie, const char* fmt, ...)
2039 {
2040 if (accessorCookie != NULL && fmt != NULL) {
2041 AccessorCookie* ac = (AccessorCookie*)accessorCookie;
2042 int retval=0;
2043 char buf[1024];
2044 va_list ap;
2045 va_start(ap, fmt);
2046 retval = vsnprintf(buf, sizeof(buf), fmt, ap);
2047 va_end(ap);
2048 ac->sourcePos.error("Error: %s (at '%s' with value '%s').\n",
2049 buf, ac->attr.string(), ac->value.string());
2050 }
2051 }
2052
2053 bool ResourceTable::getAttributeKeys(
2054 uint32_t attrID, Vector<String16>* outKeys)
2055 {
2056 sp<const Entry> e = getEntry(attrID);
2057 if (e != NULL) {
2058 const size_t N = e->getBag().size();
2059 for (size_t i=0; i<N; i++) {
2060 const String16& key = e->getBag().keyAt(i);
2061 if (key.size() > 0 && key.string()[0] != '^') {
2062 outKeys->add(key);
2063 }
2064 }
2065 return true;
2066 }
2067 return false;
2068 }
2069
2070 bool ResourceTable::getAttributeEnum(
2071 uint32_t attrID, const char16_t* name, size_t nameLen,
2072 Res_value* outValue)
2073 {
2074 //printf("getAttributeEnum #%08x %s\n", attrID, String8(name, nameLen).string());
2075 String16 nameStr(name, nameLen);
2076 sp<const Entry> e = getEntry(attrID);
2077 if (e != NULL) {
2078 const size_t N = e->getBag().size();
2079 for (size_t i=0; i<N; i++) {
2080 //printf("Comparing %s to %s\n", String8(name, nameLen).string(),
2081 // String8(e->getBag().keyAt(i)).string());
2082 if (e->getBag().keyAt(i) == nameStr) {
2083 return getItemValue(attrID, e->getBag().valueAt(i).bagKeyId, outValue);
2084 }
2085 }
2086 }
2087 return false;
2088 }
2089
2090 bool ResourceTable::getAttributeFlags(
2091 uint32_t attrID, const char16_t* name, size_t nameLen,
2092 Res_value* outValue)
2093 {
2094 outValue->dataType = Res_value::TYPE_INT_HEX;
2095 outValue->data = 0;
2096
2097 //printf("getAttributeFlags #%08x %s\n", attrID, String8(name, nameLen).string());
2098 String16 nameStr(name, nameLen);
2099 sp<const Entry> e = getEntry(attrID);
2100 if (e != NULL) {
2101 const size_t N = e->getBag().size();
2102
2103 const char16_t* end = name + nameLen;
2104 const char16_t* pos = name;
2105 bool failed = false;
2106 while (pos < end && !failed) {
2107 const char16_t* start = pos;
2108 end++;
2109 while (pos < end && *pos != '|') {
2110 pos++;
2111 }
2112
2113 String16 nameStr(start, pos-start);
2114 size_t i;
2115 for (i=0; i<N; i++) {
2116 //printf("Comparing \"%s\" to \"%s\"\n", String8(nameStr).string(),
2117 // String8(e->getBag().keyAt(i)).string());
2118 if (e->getBag().keyAt(i) == nameStr) {
2119 Res_value val;
2120 bool got = getItemValue(attrID, e->getBag().valueAt(i).bagKeyId, &val);
2121 if (!got) {
2122 return false;
2123 }
2124 //printf("Got value: 0x%08x\n", val.data);
2125 outValue->data |= val.data;
2126 break;
2127 }
2128 }
2129
2130 if (i >= N) {
2131 // Didn't find this flag identifier.
2132 return false;
2133 }
2134 if (pos < end) {
2135 pos++;
2136 }
2137 }
2138
2139 return true;
2140 }
2141 return false;
2142 }
2143
2144 status_t ResourceTable::assignResourceIds()
2145 {
2146 const size_t N = mOrderedPackages.size();
2147 size_t pi;
2148 status_t firstError = NO_ERROR;
2149
2150 // First generate all bag attributes and assign indices.
2151 for (pi=0; pi<N; pi++) {
2152 sp<Package> p = mOrderedPackages.itemAt(pi);
2153 if (p == NULL || p->getTypes().size() == 0) {
2154 // Empty, skip!
2155 continue;
2156 }
2157
2158 status_t err = p->applyPublicTypeOrder();
2159 if (err != NO_ERROR && firstError == NO_ERROR) {
2160 firstError = err;
2161 }
2162
2163 // Generate attributes...
2164 const size_t N = p->getOrderedTypes().size();
2165 size_t ti;
2166 for (ti=0; ti<N; ti++) {
2167 sp<Type> t = p->getOrderedTypes().itemAt(ti);
2168 if (t == NULL) {
2169 continue;
2170 }
2171 const size_t N = t->getOrderedConfigs().size();
2172 for (size_t ci=0; ci<N; ci++) {
2173 sp<ConfigList> c = t->getOrderedConfigs().itemAt(ci);
2174 if (c == NULL) {
2175 continue;
2176 }
2177 const size_t N = c->getEntries().size();
2178 for (size_t ei=0; ei<N; ei++) {
2179 sp<Entry> e = c->getEntries().valueAt(ei);
2180 if (e == NULL) {
2181 continue;
2182 }
2183 status_t err = e->generateAttributes(this, p->getName());
2184 if (err != NO_ERROR && firstError == NO_ERROR) {
2185 firstError = err;
2186 }
2187 }
2188 }
2189 }
2190
2191 const SourcePos unknown(String8("????"), 0);
2192 sp<Type> attr = p->getType(String16("attr"), unknown);
2193
2194 // Assign indices...
2195 for (ti=0; ti<N; ti++) {
2196 sp<Type> t = p->getOrderedTypes().itemAt(ti);
2197 if (t == NULL) {
2198 continue;
2199 }
2200 err = t->applyPublicEntryOrder();
2201 if (err != NO_ERROR && firstError == NO_ERROR) {
2202 firstError = err;
2203 }
2204
2205 const size_t N = t->getOrderedConfigs().size();
2206 t->setIndex(ti+1);
2207
2208 LOG_ALWAYS_FATAL_IF(ti == 0 && attr != t,
2209 "First type is not attr!");
2210
2211 for (size_t ei=0; ei<N; ei++) {
2212 sp<ConfigList> c = t->getOrderedConfigs().itemAt(ei);
2213 if (c == NULL) {
2214 continue;
2215 }
2216 c->setEntryIndex(ei);
2217 }
2218 }
2219
2220 // Assign resource IDs to keys in bags...
2221 for (ti=0; ti<N; ti++) {
2222 sp<Type> t = p->getOrderedTypes().itemAt(ti);
2223 if (t == NULL) {
2224 continue;
2225 }
2226 const size_t N = t->getOrderedConfigs().size();
2227 for (size_t ci=0; ci<N; ci++) {
2228 sp<ConfigList> c = t->getOrderedConfigs().itemAt(ci);
2229 //printf("Ordered config #%d: %p\n", ci, c.get());
2230 const size_t N = c->getEntries().size();
2231 for (size_t ei=0; ei<N; ei++) {
2232 sp<Entry> e = c->getEntries().valueAt(ei);
2233 if (e == NULL) {
2234 continue;
2235 }
2236 status_t err = e->assignResourceIds(this, p->getName());
2237 if (err != NO_ERROR && firstError == NO_ERROR) {
2238 firstError = err;
2239 }
2240 }
2241 }
2242 }
2243 }
2244 return firstError;
2245 }
2246
2247 status_t ResourceTable::addSymbols(const sp<AaptSymbols>& outSymbols) {
2248 const size_t N = mOrderedPackages.size();
2249 size_t pi;
2250
2251 for (pi=0; pi<N; pi++) {
2252 sp<Package> p = mOrderedPackages.itemAt(pi);
2253 if (p->getTypes().size() == 0) {
2254 // Empty, skip!
2255 continue;
2256 }
2257
2258 const size_t N = p->getOrderedTypes().size();
2259 size_t ti;
2260
2261 for (ti=0; ti<N; ti++) {
2262 sp<Type> t = p->getOrderedTypes().itemAt(ti);
2263 if (t == NULL) {
2264 continue;
2265 }
2266 const size_t N = t->getOrderedConfigs().size();
2267 sp<AaptSymbols> typeSymbols;
2268 typeSymbols = outSymbols->addNestedSymbol(String8(t->getName()), t->getPos());
2269 for (size_t ci=0; ci<N; ci++) {
2270 sp<ConfigList> c = t->getOrderedConfigs().itemAt(ci);
2271 if (c == NULL) {
2272 continue;
2273 }
2274 uint32_t rid = getResId(p, t, ci);
2275 if (rid == 0) {
2276 return UNKNOWN_ERROR;
2277 }
2278 if (Res_GETPACKAGE(rid) == (size_t)(p->getAssignedId()-1)) {
2279 typeSymbols->addSymbol(String8(c->getName()), rid, c->getPos());
2280
2281 String16 comment(c->getComment());
2282 typeSymbols->appendComment(String8(c->getName()), comment, c->getPos());
2283 //printf("Type symbol %s comment: %s\n", String8(e->getName()).string(),
2284 // String8(comment).string());
2285 comment = c->getTypeComment();
2286 typeSymbols->appendTypeComment(String8(c->getName()), comment);
2287 } else {
2288 #if 0
2289 printf("**** NO MATCH: 0x%08x vs 0x%08x\n",
2290 Res_GETPACKAGE(rid), p->getAssignedId());
2291 #endif
2292 }
2293 }
2294 }
2295 }
2296 return NO_ERROR;
2297 }
2298
2299
2300 void
2301 ResourceTable::addLocalization(const String16& name, const String8& locale)
2302 {
2303 mLocalizations[name].insert(locale);
2304 }
2305
2306
2307 /*!
2308 * Flag various sorts of localization problems. '+' indicates checks already implemented;
2309 * '-' indicates checks that will be implemented in the future.
2310 *
2311 * + A localized string for which no default-locale version exists => warning
2312 * + A string for which no version in an explicitly-requested locale exists => warning
2313 * + A localized translation of an translateable="false" string => warning
2314 * - A localized string not provided in every locale used by the table
2315 */
2316 status_t
2317 ResourceTable::validateLocalizations(void)
2318 {
2319 status_t err = NO_ERROR;
2320 const String8 defaultLocale;
2321
2322 // For all strings...
2323 for (map<String16, set<String8> >::iterator nameIter = mLocalizations.begin();
2324 nameIter != mLocalizations.end();
2325 nameIter++) {
2326 const set<String8>& configSet = nameIter->second; // naming convenience
2327
2328 // Look for strings with no default localization
2329 if (configSet.count(defaultLocale) == 0) {
2330 fprintf(stdout, "aapt: warning: string '%s' has no default translation in %s; found:",
2331 String8(nameIter->first).string(), mBundle->getResourceSourceDirs()[0]);
2332 for (set<String8>::iterator locales = configSet.begin();
2333 locales != configSet.end();
2334 locales++) {
2335 fprintf(stdout, " %s", (*locales).string());
2336 }
2337 fprintf(stdout, "\n");
2338 // !!! TODO: throw an error here in some circumstances
2339 }
2340
2341 // Check that all requested localizations are present for this string
2342 if (mBundle->getConfigurations() != NULL && mBundle->getRequireLocalization()) {
2343 const char* allConfigs = mBundle->getConfigurations();
2344 const char* start = allConfigs;
2345 const char* comma;
2346
2347 do {
2348 String8 config;
2349 comma = strchr(start, ',');
2350 if (comma != NULL) {
2351 config.setTo(start, comma - start);
2352 start = comma + 1;
2353 } else {
2354 config.setTo(start);
2355 }
2356
2357 // don't bother with the pseudolocale "zz_ZZ"
2358 if (config != "zz_ZZ") {
2359 if (configSet.find(config) == configSet.end()) {
2360 // okay, no specific localization found. it's possible that we are
2361 // requiring a specific regional localization [e.g. de_DE] but there is an
2362 // available string in the generic language localization [e.g. de];
2363 // consider that string to have fulfilled the localization requirement.
2364 String8 region(config.string(), 2);
2365 if (configSet.find(region) == configSet.end()) {
2366 if (configSet.count(defaultLocale) == 0) {
2367 fprintf(stdout, "aapt: error: "
2368 "*** string '%s' has no default or required localization "
2369 "for '%s' in %s\n",
2370 String8(nameIter->first).string(),
2371 config.string(),
2372 mBundle->getResourceSourceDirs()[0]);
2373 err = UNKNOWN_ERROR;
2374 }
2375 }
2376 }
2377 }
2378 } while (comma != NULL);
2379 }
2380 }
2381
2382 return err;
2383 }
2384
2385
2386 status_t
2387 ResourceFilter::parse(const char* arg)
2388 {
2389 if (arg == NULL) {
2390 return 0;
2391 }
2392
2393 const char* p = arg;
2394 const char* q;
2395
2396 while (true) {
2397 q = strchr(p, ',');
2398 if (q == NULL) {
2399 q = p + strlen(p);
2400 }
2401
2402 String8 part(p, q-p);
2403
2404 if (part == "zz_ZZ") {
2405 mContainsPseudo = true;
2406 }
2407 int axis;
2408 uint32_t value;
2409 if (AaptGroupEntry::parseNamePart(part, &axis, &value)) {
2410 fprintf(stderr, "Invalid configuration: %s\n", arg);
2411 fprintf(stderr, " ");
2412 for (int i=0; i<p-arg; i++) {
2413 fprintf(stderr, " ");
2414 }
2415 for (int i=0; i<q-p; i++) {
2416 fprintf(stderr, "^");
2417 }
2418 fprintf(stderr, "\n");
2419 return 1;
2420 }
2421
2422 ssize_t index = mData.indexOfKey(axis);
2423 if (index < 0) {
2424 mData.add(axis, SortedVector<uint32_t>());
2425 }
2426 SortedVector<uint32_t>& sv = mData.editValueFor(axis);
2427 sv.add(value);
2428 // if it's a locale with a region, also match an unmodified locale of the
2429 // same language
2430 if (axis == AXIS_LANGUAGE) {
2431 if (value & 0xffff0000) {
2432 sv.add(value & 0x0000ffff);
2433 }
2434 }
2435 p = q;
2436 if (!*p) break;
2437 p++;
2438 }
2439
2440 return NO_ERROR;
2441 }
2442
2443 bool
2444 ResourceFilter::match(int axis, uint32_t value)
2445 {
2446 if (value == 0) {
2447 // they didn't specify anything so take everything
2448 return true;
2449 }
2450 ssize_t index = mData.indexOfKey(axis);
2451 if (index < 0) {
2452 // we didn't request anything on this axis so take everything
2453 return true;
2454 }
2455 const SortedVector<uint32_t>& sv = mData.valueAt(index);
2456 return sv.indexOf(value) >= 0;
2457 }
2458
2459 bool
2460 ResourceFilter::match(const ResTable_config& config)
2461 {
2462 if (config.locale) {
2463 uint32_t locale = (config.country[1] << 24) | (config.country[0] << 16)
2464 | (config.language[1] << 8) | (config.language[0]);
2465 if (!match(AXIS_LANGUAGE, locale)) {
2466 return false;
2467 }
2468 }
2469 if (!match(AXIS_ORIENTATION, config.orientation)) {
2470 return false;
2471 }
2472 if (!match(AXIS_DENSITY, config.density)) {
2473 return false;
2474 }
2475 if (!match(AXIS_TOUCHSCREEN, config.touchscreen)) {
2476 return false;
2477 }
2478 if (!match(AXIS_KEYSHIDDEN, config.inputFlags)) {
2479 return false;
2480 }
2481 if (!match(AXIS_KEYBOARD, config.keyboard)) {
2482 return false;
2483 }
2484 if (!match(AXIS_NAVIGATION, config.navigation)) {
2485 return false;
2486 }
2487 if (!match(AXIS_SCREENSIZE, config.screenSize)) {
2488 return false;
2489 }
2490 if (!match(AXIS_VERSION, config.version)) {
2491 return false;
2492 }
2493 return true;
2494 }
2495
2496 status_t ResourceTable::flatten(Bundle* bundle, const sp<AaptFile>& dest)
2497 {
2498 ResourceFilter filter;
2499 status_t err = filter.parse(bundle->getConfigurations());
2500 if (err != NO_ERROR) {
2501 return err;
2502 }
2503
2504 const size_t N = mOrderedPackages.size();
2505 size_t pi;
2506
2507 // Iterate through all data, collecting all values (strings,
2508 // references, etc).
2509 StringPool valueStrings;
2510 for (pi=0; pi<N; pi++) {
2511 sp<Package> p = mOrderedPackages.itemAt(pi);
2512 if (p->getTypes().size() == 0) {
2513 // Empty, skip!
2514 continue;
2515 }
2516
2517 StringPool typeStrings;
2518 StringPool keyStrings;
2519
2520 const size_t N = p->getOrderedTypes().size();
2521 for (size_t ti=0; ti<N; ti++) {
2522 sp<Type> t = p->getOrderedTypes().itemAt(ti);
2523 if (t == NULL) {
2524 typeStrings.add(String16("<empty>"), false);
2525 continue;
2526 }
2527 typeStrings.add(t->getName(), false);
2528
2529 const size_t N = t->getOrderedConfigs().size();
2530 for (size_t ci=0; ci<N; ci++) {
2531 sp<ConfigList> c = t->getOrderedConfigs().itemAt(ci);
2532 if (c == NULL) {
2533 continue;
2534 }
2535 const size_t N = c->getEntries().size();
2536 for (size_t ei=0; ei<N; ei++) {
2537 ConfigDescription config = c->getEntries().keyAt(ei);
2538 if (!filter.match(config)) {
2539 continue;
2540 }
2541 sp<Entry> e = c->getEntries().valueAt(ei);
2542 if (e == NULL) {
2543 continue;
2544 }
2545 e->setNameIndex(keyStrings.add(e->getName(), true));
2546 status_t err = e->prepareFlatten(&valueStrings, this);
2547 if (err != NO_ERROR) {
2548 return err;
2549 }
2550 }
2551 }
2552 }
2553
2554 p->setTypeStrings(typeStrings.createStringBlock());
2555 p->setKeyStrings(keyStrings.createStringBlock());
2556 }
2557
2558 ssize_t strAmt = 0;
2559
2560 // Now build the array of package chunks.
2561 Vector<sp<AaptFile> > flatPackages;
2562 for (pi=0; pi<N; pi++) {
2563 sp<Package> p = mOrderedPackages.itemAt(pi);
2564 if (p->getTypes().size() == 0) {
2565 // Empty, skip!
2566 continue;
2567 }
2568
2569 const size_t N = p->getTypeStrings().size();
2570
2571 const size_t baseSize = sizeof(ResTable_package);
2572
2573 // Start the package data.
2574 sp<AaptFile> data = new AaptFile(String8(), AaptGroupEntry(), String8());
2575 ResTable_package* header = (ResTable_package*)data->editData(baseSize);
2576 if (header == NULL) {
2577 fprintf(stderr, "ERROR: out of memory creating ResTable_package\n");
2578 return NO_MEMORY;
2579 }
2580 memset(header, 0, sizeof(*header));
2581 header->header.type = htods(RES_TABLE_PACKAGE_TYPE);
2582 header->header.headerSize = htods(sizeof(*header));
2583 header->id = htodl(p->getAssignedId());
2584 strcpy16_htod(header->name, p->getName().string());
2585
2586 // Write the string blocks.
2587 const size_t typeStringsStart = data->getSize();
2588 sp<AaptFile> strFile = p->getTypeStringsData();
2589 ssize_t amt = data->writeData(strFile->getData(), strFile->getSize());
2590 #if PRINT_STRING_METRICS
2591 fprintf(stderr, "**** type strings: %d\n", amt);
2592 #endif
2593 strAmt += amt;
2594 if (amt < 0) {
2595 return amt;
2596 }
2597 const size_t keyStringsStart = data->getSize();
2598 strFile = p->getKeyStringsData();
2599 amt = data->writeData(strFile->getData(), strFile->getSize());
2600 #if PRINT_STRING_METRICS
2601 fprintf(stderr, "**** key strings: %d\n", amt);
2602 #endif
2603 strAmt += amt;
2604 if (amt < 0) {
2605 return amt;
2606 }
2607
2608 // Build the type chunks inside of this package.
2609 for (size_t ti=0; ti<N; ti++) {
2610 // Retrieve them in the same order as the type string block.
2611 size_t len;
2612 String16 typeName(p->getTypeStrings().stringAt(ti, &len));
2613 sp<Type> t = p->getTypes().valueFor(typeName);
2614 LOG_ALWAYS_FATAL_IF(t == NULL && typeName != String16("<empty>"),
2615 "Type name %s not found",
2616 String8(typeName).string());
2617
2618 const size_t N = t != NULL ? t->getOrderedConfigs().size() : 0;
2619
2620 // First write the typeSpec chunk, containing information about
2621 // each resource entry in this type.
2622 {
2623 const size_t typeSpecSize = sizeof(ResTable_typeSpec) + sizeof(uint32_t)*N;
2624 const size_t typeSpecStart = data->getSize();
2625 ResTable_typeSpec* tsHeader = (ResTable_typeSpec*)
2626 (((uint8_t*)data->editData(typeSpecStart+typeSpecSize)) + typeSpecStart);
2627 if (tsHeader == NULL) {
2628 fprintf(stderr, "ERROR: out of memory creating ResTable_typeSpec\n");
2629 return NO_MEMORY;
2630 }
2631 memset(tsHeader, 0, sizeof(*tsHeader));
2632 tsHeader->header.type = htods(RES_TABLE_TYPE_SPEC_TYPE);
2633 tsHeader->header.headerSize = htods(sizeof(*tsHeader));
2634 tsHeader->header.size = htodl(typeSpecSize);
2635 tsHeader->id = ti+1;
2636 tsHeader->entryCount = htodl(N);
2637
2638 uint32_t* typeSpecFlags = (uint32_t*)
2639 (((uint8_t*)data->editData())
2640 + typeSpecStart + sizeof(ResTable_typeSpec));
2641 memset(typeSpecFlags, 0, sizeof(uint32_t)*N);
2642
2643 for (size_t ei=0; ei<N; ei++) {
2644 sp<ConfigList> cl = t->getOrderedConfigs().itemAt(ei);
2645 if (cl->getPublic()) {
2646 typeSpecFlags[ei] |= htodl(ResTable_typeSpec::SPEC_PUBLIC);
2647 }
2648 const size_t CN = cl->getEntries().size();
2649 for (size_t ci=0; ci<CN; ci++) {
2650 if (!filter.match(cl->getEntries().keyAt(ci))) {
2651 continue;
2652 }
2653 for (size_t cj=ci+1; cj<CN; cj++) {
2654 if (!filter.match(cl->getEntries().keyAt(cj))) {
2655 continue;
2656 }
2657 typeSpecFlags[ei] |= htodl(
2658 cl->getEntries().keyAt(ci).diff(cl->getEntries().keyAt(cj)));
2659 }
2660 }
2661 }
2662 }
2663
2664 // We need to write one type chunk for each configuration for
2665 // which we have entries in this type.
2666 const size_t NC = t->getUniqueConfigs().size();
2667
2668 const size_t typeSize = sizeof(ResTable_type) + sizeof(uint32_t)*N;
2669
2670 for (size_t ci=0; ci<NC; ci++) {
2671 ConfigDescription config = t->getUniqueConfigs().itemAt(ci);
2672
2673 NOISY(printf("Writing config %d config: imsi:%d/%d lang:%c%c cnt:%c%c "
2674 "orien:%d touch:%d density:%d key:%d inp:%d nav:%d w:%d h:%d\n",
2675 ti+1,
2676 config.mcc, config.mnc,
2677 config.language[0] ? config.language[0] : '-',
2678 config.language[1] ? config.language[1] : '-',
2679 config.country[0] ? config.country[0] : '-',
2680 config.country[1] ? config.country[1] : '-',
2681 config.orientation,
2682 config.touchscreen,
2683 config.density,
2684 config.keyboard,
2685 config.inputFlags,
2686 config.navigation,
2687 config.screenWidth,
2688 config.screenHeight));
2689
2690 if (!filter.match(config)) {
2691 continue;
2692 }
2693
2694 const size_t typeStart = data->getSize();
2695
2696 ResTable_type* tHeader = (ResTable_type*)
2697 (((uint8_t*)data->editData(typeStart+typeSize)) + typeStart);
2698 if (tHeader == NULL) {
2699 fprintf(stderr, "ERROR: out of memory creating ResTable_type\n");
2700 return NO_MEMORY;
2701 }
2702
2703 memset(tHeader, 0, sizeof(*tHeader));
2704 tHeader->header.type = htods(RES_TABLE_TYPE_TYPE);
2705 tHeader->header.headerSize = htods(sizeof(*tHeader));
2706 tHeader->id = ti+1;
2707 tHeader->entryCount = htodl(N);
2708 tHeader->entriesStart = htodl(typeSize);
2709 tHeader->config = config;
2710 NOISY(printf("Writing type %d config: imsi:%d/%d lang:%c%c cnt:%c%c "
2711 "orien:%d touch:%d density:%d key:%d inp:%d nav:%d w:%d h:%d\n",
2712 ti+1,
2713 tHeader->config.mcc, tHeader->config.mnc,
2714 tHeader->config.language[0] ? tHeader->config.language[0] : '-',
2715 tHeader->config.language[1] ? tHeader->config.language[1] : '-',
2716 tHeader->config.country[0] ? tHeader->config.country[0] : '-',
2717 tHeader->config.country[1] ? tHeader->config.country[1] : '-',
2718 tHeader->config.orientation,
2719 tHeader->config.touchscreen,
2720 tHeader->config.density,
2721 tHeader->config.keyboard,
2722 tHeader->config.inputFlags,
2723 tHeader->config.navigation,
2724 tHeader->config.screenWidth,
2725 tHeader->config.screenHeight));
2726 tHeader->config.swapHtoD();
2727
2728 // Build the entries inside of this type.
2729 for (size_t ei=0; ei<N; ei++) {
2730 sp<ConfigList> cl = t->getOrderedConfigs().itemAt(ei);
2731 sp<Entry> e = cl->getEntries().valueFor(config);
2732
2733 // Set the offset for this entry in its type.
2734 uint32_t* index = (uint32_t*)
2735 (((uint8_t*)data->editData())
2736 + typeStart + sizeof(ResTable_type));
2737 if (e != NULL) {
2738 index[ei] = htodl(data->getSize()-typeStart-typeSize);
2739
2740 // Create the entry.
2741 ssize_t amt = e->flatten(bundle, data, cl->getPublic());
2742 if (amt < 0) {
2743 return amt;
2744 }
2745 } else {
2746 index[ei] = htodl(ResTable_type::NO_ENTRY);
2747 }
2748 }
2749
2750 // Fill in the rest of the type information.
2751 tHeader = (ResTable_type*)
2752 (((uint8_t*)data->editData()) + typeStart);
2753 tHeader->header.size = htodl(data->getSize()-typeStart);
2754 }
2755 }
2756
2757 // Fill in the rest of the package information.
2758 header = (ResTable_package*)data->editData();
2759 header->header.size = htodl(data->getSize());
2760 header->typeStrings = htodl(typeStringsStart);
2761 header->lastPublicType = htodl(p->getTypeStrings().size());
2762 header->keyStrings = htodl(keyStringsStart);
2763 header->lastPublicKey = htodl(p->getKeyStrings().size());
2764
2765 flatPackages.add(data);
2766 }
2767
2768 // And now write out the final chunks.
2769 const size_t dataStart = dest->getSize();
2770
2771 {
2772 // blah
2773 ResTable_header header;
2774 memset(&header, 0, sizeof(header));
2775 header.header.type = htods(RES_TABLE_TYPE);
2776 header.header.headerSize = htods(sizeof(header));
2777 header.packageCount = htodl(flatPackages.size());
2778 status_t err = dest->writeData(&header, sizeof(header));
2779 if (err != NO_ERROR) {
2780 fprintf(stderr, "ERROR: out of memory creating ResTable_header\n");
2781 return err;
2782 }
2783 }
2784
2785 ssize_t strStart = dest->getSize();
2786 err = valueStrings.writeStringBlock(dest);
2787 if (err != NO_ERROR) {
2788 return err;
2789 }
2790
2791 ssize_t amt = (dest->getSize()-strStart);
2792 strAmt += amt;
2793 #if PRINT_STRING_METRICS
2794 fprintf(stderr, "**** value strings: %d\n", amt);
2795 fprintf(stderr, "**** total strings: %d\n", strAmt);
2796 #endif
2797
2798 for (pi=0; pi<flatPackages.size(); pi++) {
2799 err = dest->writeData(flatPackages[pi]->getData(),
2800 flatPackages[pi]->getSize());
2801 if (err != NO_ERROR) {
2802 fprintf(stderr, "ERROR: out of memory creating package chunk for ResTable_header\n");
2803 return err;
2804 }
2805 }
2806
2807 ResTable_header* header = (ResTable_header*)
2808 (((uint8_t*)dest->getData()) + dataStart);
2809 header->header.size = htodl(dest->getSize() - dataStart);
2810
2811 NOISY(aout << "Resource table:"
2812 << HexDump(dest->getData(), dest->getSize()) << endl);
2813
2814 #if PRINT_STRING_METRICS
2815 fprintf(stderr, "**** total resource table size: %d / %d%% strings\n",
2816 dest->getSize(), (strAmt*100)/dest->getSize());
2817 #endif
2818
2819 return NO_ERROR;
2820 }
2821
2822 void ResourceTable::writePublicDefinitions(const String16& package, FILE* fp)
2823 {
2824 fprintf(fp,
2825 "<!-- This file contains <public> resource definitions for all\n"
2826 " resources that were generated from the source data. -->\n"
2827 "\n"
2828 "<resources>\n");
2829
2830 writePublicDefinitions(package, fp, true);
2831 writePublicDefinitions(package, fp, false);
2832
2833 fprintf(fp,
2834 "\n"
2835 "</resources>\n");
2836 }
2837
2838 void ResourceTable::writePublicDefinitions(const String16& package, FILE* fp, bool pub)
2839 {
2840 bool didHeader = false;
2841
2842 sp<Package> pkg = mPackages.valueFor(package);
2843 if (pkg != NULL) {
2844 const size_t NT = pkg->getOrderedTypes().size();
2845 for (size_t i=0; i<NT; i++) {
2846 sp<Type> t = pkg->getOrderedTypes().itemAt(i);
2847 if (t == NULL) {
2848 continue;
2849 }
2850
2851 bool didType = false;
2852
2853 const size_t NC = t->getOrderedConfigs().size();
2854 for (size_t j=0; j<NC; j++) {
2855 sp<ConfigList> c = t->getOrderedConfigs().itemAt(j);
2856 if (c == NULL) {
2857 continue;
2858 }
2859
2860 if (c->getPublic() != pub) {
2861 continue;
2862 }
2863
2864 if (!didType) {
2865 fprintf(fp, "\n");
2866 didType = true;
2867 }
2868 if (!didHeader) {
2869 if (pub) {
2870 fprintf(fp," <!-- PUBLIC SECTION. These resources have been declared public.\n");
2871 fprintf(fp," Changes to these definitions will break binary compatibility. -->\n\n");
2872 } else {
2873 fprintf(fp," <!-- PRIVATE SECTION. These resources have not been declared public.\n");
2874 fprintf(fp," You can make them public my moving these lines into a file in res/values. -->\n\n");
2875 }
2876 didHeader = true;
2877 }
2878 if (!pub) {
2879 const size_t NE = c->getEntries().size();
2880 for (size_t k=0; k<NE; k++) {
2881 const SourcePos& pos = c->getEntries().valueAt(k)->getPos();
2882 if (pos.file != "") {
2883 fprintf(fp," <!-- Declared at %s:%d -->\n",
2884 pos.file.string(), pos.line);
2885 }
2886 }
2887 }
2888 fprintf(fp, " <public type=\"%s\" name=\"%s\" id=\"0x%08x\" />\n",
2889 String8(t->getName()).string(),
2890 String8(c->getName()).string(),
2891 getResId(pkg, t, c->getEntryIndex()));
2892 }
2893 }
2894 }
2895 }
2896
2897 ResourceTable::Item::Item(const SourcePos& _sourcePos,
2898 bool _isId,
2899 const String16& _value,
2900 const Vector<StringPool::entry_style_span>* _style,
2901 int32_t _format)
2902 : sourcePos(_sourcePos)
2903 , isId(_isId)
2904 , value(_value)
2905 , format(_format)
2906 , bagKeyId(0)
2907 , evaluating(false)
2908 {
2909 if (_style) {
2910 style = *_style;
2911 }
2912 }
2913
2914 status_t ResourceTable::Entry::makeItABag(const SourcePos& sourcePos)
2915 {
2916 if (mType == TYPE_BAG) {
2917 return NO_ERROR;
2918 }
2919 if (mType == TYPE_UNKNOWN) {
2920 mType = TYPE_BAG;
2921 return NO_ERROR;
2922 }
2923 sourcePos.error("Resource entry %s is already defined as a single item.\n"
2924 "%s:%d: Originally defined here.\n",
2925 String8(mName).string(),
2926 mItem.sourcePos.file.string(), mItem.sourcePos.line);
2927 return UNKNOWN_ERROR;
2928 }
2929
2930 status_t ResourceTable::Entry::setItem(const SourcePos& sourcePos,
2931 const String16& value,
2932 const Vector<StringPool::entry_style_span>* style,
2933 int32_t format,
2934 const bool overwrite)
2935 {
2936 Item item(sourcePos, false, value, style);
2937
2938 if (mType == TYPE_BAG) {
2939 const Item& item(mBag.valueAt(0));
2940 sourcePos.error("Resource entry %s is already defined as a bag.\n"
2941 "%s:%d: Originally defined here.\n",
2942 String8(mName).string(),
2943 item.sourcePos.file.string(), item.sourcePos.line);
2944 return UNKNOWN_ERROR;
2945 }
2946 if ( (mType != TYPE_UNKNOWN) && (overwrite == false) ) {
2947 sourcePos.error("Resource entry %s is already defined.\n"
2948 "%s:%d: Originally defined here.\n",
2949 String8(mName).string(),
2950 mItem.sourcePos.file.string(), mItem.sourcePos.line);
2951 return UNKNOWN_ERROR;
2952 }
2953
2954 mType = TYPE_ITEM;
2955 mItem = item;
2956 mItemFormat = format;
2957 return NO_ERROR;
2958 }
2959
2960 status_t ResourceTable::Entry::addToBag(const SourcePos& sourcePos,
2961 const String16& key, const String16& value,
2962 const Vector<StringPool::entry_style_span>* style,
2963 bool replace, bool isId, int32_t format)
2964 {
2965 status_t err = makeItABag(sourcePos);
2966 if (err != NO_ERROR) {
2967 return err;
2968 }
2969
2970 Item item(sourcePos, isId, value, style, format);
2971
2972 // XXX NOTE: there is an error if you try to have a bag with two keys,
2973 // one an attr and one an id, with the same name. Not something we
2974 // currently ever have to worry about.
2975 ssize_t origKey = mBag.indexOfKey(key);
2976 if (origKey >= 0) {
2977 if (!replace) {
2978 const Item& item(mBag.valueAt(origKey));
2979 sourcePos.error("Resource entry %s already has bag item %s.\n"
2980 "%s:%d: Originally defined here.\n",
2981 String8(mName).string(), String8(key).string(),
2982 item.sourcePos.file.string(), item.sourcePos.line);
2983 return UNKNOWN_ERROR;
2984 }
2985 //printf("Replacing %s with %s\n",
2986 // String8(mBag.valueFor(key).value).string(), String8(value).string());
2987 mBag.replaceValueFor(key, item);
2988 }
2989
2990 mBag.add(key, item);
2991 return NO_ERROR;
2992 }
2993
2994 status_t ResourceTable::Entry::emptyBag(const SourcePos& sourcePos)
2995 {
2996 status_t err = makeItABag(sourcePos);
2997 if (err != NO_ERROR) {
2998 return err;
2999 }
3000
3001 mBag.clear();
3002 return NO_ERROR;
3003 }
3004
3005 status_t ResourceTable::Entry::generateAttributes(ResourceTable* table,
3006 const String16& package)
3007 {
3008 const String16 attr16("attr");
3009 const String16 id16("id");
3010 const size_t N = mBag.size();
3011 for (size_t i=0; i<N; i++) {
3012 const String16& key = mBag.keyAt(i);
3013 const Item& it = mBag.valueAt(i);
3014 if (it.isId) {
3015 if (!table->hasBagOrEntry(key, &id16, &package)) {
3016 String16 value("false");
3017 status_t err = table->addEntry(SourcePos(String8("<generated>"), 0), package,
3018 id16, key, value);
3019 if (err != NO_ERROR) {
3020 return err;
3021 }
3022 }
3023 } else if (!table->hasBagOrEntry(key, &attr16, &package)) {
3024
3025 #if 1
3026 // fprintf(stderr, "ERROR: Bag attribute '%s' has not been defined.\n",
3027 // String8(key).string());
3028 // const Item& item(mBag.valueAt(i));
3029 // fprintf(stderr, "Referenced from file %s line %d\n",
3030 // item.sourcePos.file.string(), item.sourcePos.line);
3031 // return UNKNOWN_ERROR;
3032 #else
3033 char numberStr[16];
3034 sprintf(numberStr, "%d", ResTable_map::TYPE_ANY);
3035 status_t err = table->addBag(SourcePos("<generated>", 0), package,
3036 attr16, key, String16(""),
3037 String16("^type"),
3038 String16(numberStr), NULL, NULL);
3039 if (err != NO_ERROR) {
3040 return err;
3041 }
3042 #endif
3043 }
3044 }
3045 return NO_ERROR;
3046 }
3047
3048 status_t ResourceTable::Entry::assignResourceIds(ResourceTable* table,
3049 const String16& package)
3050 {
3051 bool hasErrors = false;
3052
3053 if (mType == TYPE_BAG) {
3054 const char* errorMsg;
3055 const String16 style16("style");
3056 const String16 attr16("attr");
3057 const String16 id16("id");
3058 mParentId = 0;
3059 if (mParent.size() > 0) {
3060 mParentId = table->getResId(mParent, &style16, NULL, &errorMsg);
3061 if (mParentId == 0) {
3062 mPos.error("Error retrieving parent for item: %s '%s'.\n",
3063 errorMsg, String8(mParent).string());
3064 hasErrors = true;
3065 }
3066 }
3067 const size_t N = mBag.size();
3068 for (size_t i=0; i<N; i++) {
3069 const String16& key = mBag.keyAt(i);
3070 Item& it = mBag.editValueAt(i);
3071 it.bagKeyId = table->getResId(key,
3072 it.isId ? &id16 : &attr16, NULL, &errorMsg);
3073 //printf("Bag key of %s: #%08x\n", String8(key).string(), it.bagKeyId);
3074 if (it.bagKeyId == 0) {
3075 it.sourcePos.error("Error: %s: %s '%s'.\n", errorMsg,
3076 String8(it.isId ? id16 : attr16).string(),
3077 String8(key).string());
3078 hasErrors = true;
3079 }
3080 }
3081 }
3082 return hasErrors ? UNKNOWN_ERROR : NO_ERROR;
3083 }
3084
3085 status_t ResourceTable::Entry::prepareFlatten(StringPool* strings, ResourceTable* table)
3086 {
3087 if (mType == TYPE_ITEM) {
3088 Item& it = mItem;
3089 AccessorCookie ac(it.sourcePos, String8(mName), String8(it.value));
3090 if (!table->stringToValue(&it.parsedValue, strings,
3091 it.value, false, true, 0,
3092 &it.style, NULL, &ac, mItemFormat)) {
3093 return UNKNOWN_ERROR;
3094 }
3095 } else if (mType == TYPE_BAG) {
3096 const size_t N = mBag.size();
3097 for (size_t i=0; i<N; i++) {
3098 const String16& key = mBag.keyAt(i);
3099 Item& it = mBag.editValueAt(i);
3100 AccessorCookie ac(it.sourcePos, String8(key), String8(it.value));
3101 if (!table->stringToValue(&it.parsedValue, strings,
3102 it.value, false, true, it.bagKeyId,
3103 &it.style, NULL, &ac, it.format)) {
3104 return UNKNOWN_ERROR;
3105 }
3106 }
3107 } else {
3108 mPos.error("Error: entry %s is not a single item or a bag.\n",
3109 String8(mName).string());
3110 return UNKNOWN_ERROR;
3111 }
3112 return NO_ERROR;
3113 }
3114
3115 ssize_t ResourceTable::Entry::flatten(Bundle* bundle, const sp<AaptFile>& data, bool isPublic)
3116 {
3117 size_t amt = 0;
3118 ResTable_entry header;
3119 memset(&header, 0, sizeof(header));
3120 header.size = htods(sizeof(header));
3121 const type ty = this != NULL ? mType : TYPE_ITEM;
3122 if (this != NULL) {
3123 if (ty == TYPE_BAG) {
3124 header.flags |= htods(header.FLAG_COMPLEX);
3125 }
3126 if (isPublic) {
3127 header.flags |= htods(header.FLAG_PUBLIC);
3128 }
3129 header.key.index = htodl(mNameIndex);
3130 }
3131 if (ty != TYPE_BAG) {
3132 status_t err = data->writeData(&header, sizeof(header));
3133 if (err != NO_ERROR) {
3134 fprintf(stderr, "ERROR: out of memory creating ResTable_entry\n");
3135 return err;
3136 }
3137
3138 const Item& it = mItem;
3139 Res_value par;
3140 memset(&par, 0, sizeof(par));
3141 par.size = htods(it.parsedValue.size);
3142 par.dataType = it.parsedValue.dataType;
3143 par.res0 = it.parsedValue.res0;
3144 par.data = htodl(it.parsedValue.data);
3145 #if 0
3146 printf("Writing item (%s): type=%d, data=0x%x, res0=0x%x\n",
3147 String8(mName).string(), it.parsedValue.dataType,
3148 it.parsedValue.data, par.res0);
3149 #endif
3150 err = data->writeData(&par, it.parsedValue.size);
3151 if (err != NO_ERROR) {
3152 fprintf(stderr, "ERROR: out of memory creating Res_value\n");
3153 return err;
3154 }
3155 amt += it.parsedValue.size;
3156 } else {
3157 size_t N = mBag.size();
3158 size_t i;
3159 // Create correct ordering of items.
3160 KeyedVector<uint32_t, const Item*> items;
3161 for (i=0; i<N; i++) {
3162 const Item& it = mBag.valueAt(i);
3163 items.add(it.bagKeyId, &it);
3164 }
3165 N = items.size();
3166
3167 ResTable_map_entry mapHeader;
3168 memcpy(&mapHeader, &header, sizeof(header));
3169 mapHeader.size = htods(sizeof(mapHeader));
3170 mapHeader.parent.ident = htodl(mParentId);
3171 mapHeader.count = htodl(N);
3172 status_t err = data->writeData(&mapHeader, sizeof(mapHeader));
3173 if (err != NO_ERROR) {
3174 fprintf(stderr, "ERROR: out of memory creating ResTable_entry\n");
3175 return err;
3176 }
3177
3178 for (i=0; i<N; i++) {
3179 const Item& it = *items.valueAt(i);
3180 ResTable_map map;
3181 map.name.ident = htodl(it.bagKeyId);
3182 map.value.size = htods(it.parsedValue.size);
3183 map.value.dataType = it.parsedValue.dataType;
3184 map.value.res0 = it.parsedValue.res0;
3185 map.value.data = htodl(it.parsedValue.data);
3186 err = data->writeData(&map, sizeof(map));
3187 if (err != NO_ERROR) {
3188 fprintf(stderr, "ERROR: out of memory creating Res_value\n");
3189 return err;
3190 }
3191 amt += sizeof(map);
3192 }
3193 }
3194 return amt;
3195 }
3196
3197 void ResourceTable::ConfigList::appendComment(const String16& comment,
3198 bool onlyIfEmpty)
3199 {
3200 if (comment.size() <= 0) {
3201 return;
3202 }
3203 if (onlyIfEmpty && mComment.size() > 0) {
3204 return;
3205 }
3206 if (mComment.size() > 0) {
3207 mComment.append(String16("\n"));
3208 }
3209 mComment.append(comment);
3210 }
3211
3212 void ResourceTable::ConfigList::appendTypeComment(const String16& comment)
3213 {
3214 if (comment.size() <= 0) {
3215 return;
3216 }
3217 if (mTypeComment.size() > 0) {
3218 mTypeComment.append(String16("\n"));
3219 }
3220 mTypeComment.append(comment);
3221 }
3222
3223 status_t ResourceTable::Type::addPublic(const SourcePos& sourcePos,
3224 const String16& name,
3225 const uint32_t ident)
3226 {
3227 #if 0
3228 int32_t entryIdx = Res_GETENTRY(ident);
3229 if (entryIdx < 0) {
3230 sourcePos.error("Public resource %s/%s has an invalid 0 identifier (0x%08x).\n",
3231 String8(mName).string(), String8(name).string(), ident);
3232 return UNKNOWN_ERROR;
3233 }
3234 #endif
3235
3236 int32_t typeIdx = Res_GETTYPE(ident);
3237 if (typeIdx >= 0) {
3238 typeIdx++;
3239 if (mPublicIndex > 0 && mPublicIndex != typeIdx) {
3240 sourcePos.error("Public resource %s/%s has conflicting type codes for its"
3241 " public identifiers (0x%x vs 0x%x).\n",
3242 String8(mName).string(), String8(name).string(),
3243 mPublicIndex, typeIdx);
3244 return UNKNOWN_ERROR;
3245 }
3246 mPublicIndex = typeIdx;
3247 }
3248
3249 if (mFirstPublicSourcePos == NULL) {
3250 mFirstPublicSourcePos = new SourcePos(sourcePos);
3251 }
3252
3253 if (mPublic.indexOfKey(name) < 0) {
3254 mPublic.add(name, Public(sourcePos, String16(), ident));
3255 } else {
3256 Public& p = mPublic.editValueFor(name);
3257 if (p.ident != ident) {
3258 sourcePos.error("Public resource %s/%s has conflicting public identifiers"
3259 " (0x%08x vs 0x%08x).\n"
3260 "%s:%d: Originally defined here.\n",
3261 String8(mName).string(), String8(name).string(), p.ident, ident,
3262 p.sourcePos.file.string(), p.sourcePos.line);
3263 return UNKNOWN_ERROR;
3264 }
3265 }
3266
3267 return NO_ERROR;
3268 }
3269
3270 void ResourceTable::Type::canAddEntry(const String16& name)
3271 {
3272 mCanAddEntries.add(name);
3273 }
3274
3275 sp<ResourceTable::Entry> ResourceTable::Type::getEntry(const String16& entry,
3276 const SourcePos& sourcePos,
3277 const ResTable_config* config,
3278 bool doSetIndex,
3279 bool overlay)
3280 {
3281 int pos = -1;
3282 sp<ConfigList> c = mConfigs.valueFor(entry);
3283 if (c == NULL) {
3284 if (overlay == true && mCanAddEntries.indexOf(entry) < 0) {
3285 sourcePos.error("Resource at %s appears in overlay but not"
3286 " in the base package; use <add-resource> to add.\n",
3287 String8(entry).string());
3288 return NULL;
3289 }
3290 c = new ConfigList(entry, sourcePos);
3291 mConfigs.add(entry, c);
3292 pos = (int)mOrderedConfigs.size();
3293 mOrderedConfigs.add(c);
3294 if (doSetIndex) {
3295 c->setEntryIndex(pos);
3296 }
3297 }
3298
3299 ConfigDescription cdesc;
3300 if (config) cdesc = *config;
3301
3302 sp<Entry> e = c->getEntries().valueFor(cdesc);
3303 if (e == NULL) {
3304 if (config != NULL) {
3305 NOISY(printf("New entry at %s:%d: imsi:%d/%d lang:%c%c cnt:%c%c "
3306 "orien:%d touch:%d density:%d key:%d inp:%d nav:%d w:%d h:%d\n",
3307 sourcePos.file.string(), sourcePos.line,
3308 config->mcc, config->mnc,
3309 config->language[0] ? config->language[0] : '-',
3310 config->language[1] ? config->language[1] : '-',
3311 config->country[0] ? config->country[0] : '-',
3312 config->country[1] ? config->country[1] : '-',
3313 config->orientation,
3314 config->touchscreen,
3315 config->density,
3316 config->keyboard,
3317 config->inputFlags,
3318 config->navigation,
3319 config->screenWidth,
3320 config->screenHeight));
3321 } else {
3322 NOISY(printf("New entry at %s:%d: NULL config\n",
3323 sourcePos.file.string(), sourcePos.line));
3324 }
3325 e = new Entry(entry, sourcePos);
3326 c->addEntry(cdesc, e);
3327 /*
3328 if (doSetIndex) {
3329 if (pos < 0) {
3330 for (pos=0; pos<(int)mOrderedConfigs.size(); pos++) {
3331 if (mOrderedConfigs[pos] == c) {
3332 break;
3333 }
3334 }
3335 if (pos >= (int)mOrderedConfigs.size()) {
3336 sourcePos.error("Internal error: config not found in mOrderedConfigs when adding entry");
3337 return NULL;
3338 }
3339 }
3340 e->setEntryIndex(pos);
3341 }
3342 */
3343 }
3344
3345 mUniqueConfigs.add(cdesc);
3346
3347 return e;
3348 }
3349
3350 status_t ResourceTable::Type::applyPublicEntryOrder()
3351 {
3352 size_t N = mOrderedConfigs.size();
3353 Vector<sp<ConfigList> > origOrder(mOrderedConfigs);
3354 bool hasError = false;
3355
3356 size_t i;
3357 for (i=0; i<N; i++) {
3358 mOrderedConfigs.replaceAt(NULL, i);
3359 }
3360
3361 const size_t NP = mPublic.size();
3362 //printf("Ordering %d configs from %d public defs\n", N, NP);
3363 size_t j;
3364 for (j=0; j<NP; j++) {
3365 const String16& name = mPublic.keyAt(j);
3366 const Public& p = mPublic.valueAt(j);
3367 int32_t idx = Res_GETENTRY(p.ident);
3368 //printf("Looking for entry \"%s\"/\"%s\" (0x%08x) in %d...\n",
3369 // String8(mName).string(), String8(name).string(), p.ident, N);
3370 bool found = false;
3371 for (i=0; i<N; i++) {
3372 sp<ConfigList> e = origOrder.itemAt(i);
3373 //printf("#%d: \"%s\"\n", i, String8(e->getName()).string());
3374 if (e->getName() == name) {
3375 if (idx >= (int32_t)mOrderedConfigs.size()) {
3376 p.sourcePos.error("Public entry identifier 0x%x entry index "
3377 "is larger than available symbols (index %d, total symbols %d).\n",
3378 p.ident, idx, mOrderedConfigs.size());
3379 hasError = true;
3380 } else if (mOrderedConfigs.itemAt(idx) == NULL) {
3381 e->setPublic(true);
3382 e->setPublicSourcePos(p.sourcePos);
3383 mOrderedConfigs.replaceAt(e, idx);
3384 origOrder.removeAt(i);
3385 N--;
3386 found = true;
3387 break;
3388 } else {
3389 sp<ConfigList> oe = mOrderedConfigs.itemAt(idx);
3390
3391 p.sourcePos.error("Multiple entry names declared for public entry"
3392 " identifier 0x%x in type %s (%s vs %s).\n"
3393 "%s:%d: Originally defined here.",
3394 idx+1, String8(mName).string(),
3395 String8(oe->getName()).string(),
3396 String8(name).string(),
3397 oe->getPublicSourcePos().file.string(),
3398 oe->getPublicSourcePos().line);
3399 hasError = true;
3400 }
3401 }
3402 }
3403
3404 if (!found) {
3405 p.sourcePos.error("Public symbol %s/%s declared here is not defined.",
3406 String8(mName).string(), String8(name).string());
3407 hasError = true;
3408 }
3409 }
3410
3411 //printf("Copying back in %d non-public configs, have %d\n", N, origOrder.size());
3412
3413 if (N != origOrder.size()) {
3414 printf("Internal error: remaining private symbol count mismatch\n");
3415 N = origOrder.size();
3416 }
3417
3418 j = 0;
3419 for (i=0; i<N; i++) {
3420 sp<ConfigList> e = origOrder.itemAt(i);
3421 // There will always be enough room for the remaining entries.
3422 while (mOrderedConfigs.itemAt(j) != NULL) {
3423 j++;
3424 }
3425 mOrderedConfigs.replaceAt(e, j);
3426 j++;
3427 }
3428
3429 return hasError ? UNKNOWN_ERROR : NO_ERROR;
3430 }
3431
3432 ResourceTable::Package::Package(const String16& name, ssize_t includedId)
3433 : mName(name), mIncludedId(includedId),
3434 mTypeStringsMapping(0xffffffff),
3435 mKeyStringsMapping(0xffffffff)
3436 {
3437 }
3438
3439 sp<ResourceTable::Type> ResourceTable::Package::getType(const String16& type,
3440 const SourcePos& sourcePos,
3441 bool doSetIndex)
3442 {
3443 sp<Type> t = mTypes.valueFor(type);
3444 if (t == NULL) {
3445 t = new Type(type, sourcePos);
3446 mTypes.add(type, t);
3447 mOrderedTypes.add(t);
3448 if (doSetIndex) {
3449 // For some reason the type's index is set to one plus the index
3450 // in the mOrderedTypes list, rather than just the index.
3451 t->setIndex(mOrderedTypes.size());
3452 }
3453 }
3454 return t;
3455 }
3456
3457 status_t ResourceTable::Package::setTypeStrings(const sp<AaptFile>& data)
3458 {
3459 mTypeStringsData = data;
3460 status_t err = setStrings(data, &mTypeStrings, &mTypeStringsMapping);
3461 if (err != NO_ERROR) {
3462 fprintf(stderr, "ERROR: Type string data is corrupt!\n");
3463 }
3464 return err;
3465 }
3466
3467 status_t ResourceTable::Package::setKeyStrings(const sp<AaptFile>& data)
3468 {
3469 mKeyStringsData = data;
3470 status_t err = setStrings(data, &mKeyStrings, &mKeyStringsMapping);
3471 if (err != NO_ERROR) {
3472 fprintf(stderr, "ERROR: Key string data is corrupt!\n");
3473 }
3474 return err;
3475 }
3476
3477 status_t ResourceTable::Package::setStrings(const sp<AaptFile>& data,
3478 ResStringPool* strings,
3479 DefaultKeyedVector<String16, uint32_t>* mappings)
3480 {
3481 if (data->getData() == NULL) {
3482 return UNKNOWN_ERROR;
3483 }
3484
3485 NOISY(aout << "Setting restable string pool: "
3486 << HexDump(data->getData(), data->getSize()) << endl);
3487
3488 status_t err = strings->setTo(data->getData(), data->getSize());
3489 if (err == NO_ERROR) {
3490 const size_t N = strings->size();
3491 for (size_t i=0; i<N; i++) {
3492 size_t len;
3493 mappings->add(String16(strings->stringAt(i, &len)), i);
3494 }
3495 }
3496 return err;
3497 }
3498
3499 status_t ResourceTable::Package::applyPublicTypeOrder()
3500 {
3501 size_t N = mOrderedTypes.size();
3502 Vector<sp<Type> > origOrder(mOrderedTypes);
3503
3504 size_t i;
3505 for (i=0; i<N; i++) {
3506 mOrderedTypes.replaceAt(NULL, i);
3507 }
3508
3509 for (i=0; i<N; i++) {
3510 sp<Type> t = origOrder.itemAt(i);
3511 int32_t idx = t->getPublicIndex();
3512 if (idx > 0) {
3513 idx--;
3514 while (idx >= (int32_t)mOrderedTypes.size()) {
3515 mOrderedTypes.add();
3516 }
3517 if (mOrderedTypes.itemAt(idx) != NULL) {
3518 sp<Type> ot = mOrderedTypes.itemAt(idx);
3519 t->getFirstPublicSourcePos().error("Multiple type names declared for public type"
3520 " identifier 0x%x (%s vs %s).\n"
3521 "%s:%d: Originally defined here.",
3522 idx, String8(ot->getName()).string(),
3523 String8(t->getName()).string(),
3524 ot->getFirstPublicSourcePos().file.string(),
3525 ot->getFirstPublicSourcePos().line);
3526 return UNKNOWN_ERROR;
3527 }
3528 mOrderedTypes.replaceAt(t, idx);
3529 origOrder.removeAt(i);
3530 i--;
3531 N--;
3532 }
3533 }
3534
3535 size_t j=0;
3536 for (i=0; i<N; i++) {
3537 sp<Type> t = origOrder.itemAt(i);
3538 // There will always be enough room for the remaining types.
3539 while (mOrderedTypes.itemAt(j) != NULL) {
3540 j++;
3541 }
3542 mOrderedTypes.replaceAt(t, j);
3543 }
3544
3545 return NO_ERROR;
3546 }
3547
3548 sp<ResourceTable::Package> ResourceTable::getPackage(const String16& package)
3549 {
3550 sp<Package> p = mPackages.valueFor(package);
3551 if (p == NULL) {
3552 if (mIsAppPackage) {
3553 if (mHaveAppPackage) {
3554 fprintf(stderr, "Adding multiple application package resources; only one is allowed.\n"
3555 "Use -x to create extended resources.\n");
3556 return NULL;
3557 }
3558 mHaveAppPackage = true;
3559 p = new Package(package, 127);
3560 } else {
3561 p = new Package(package, mNextPackageId);
3562 }
3563 //printf("*** NEW PACKAGE: \"%s\" id=%d\n",
3564 // String8(package).string(), p->getAssignedId());
3565 mPackages.add(package, p);
3566 mOrderedPackages.add(p);
3567 mNextPackageId++;
3568 }
3569 return p;
3570 }
3571
3572 sp<ResourceTable::Type> ResourceTable::getType(const String16& package,
3573 const String16& type,
3574 const SourcePos& sourcePos,
3575 bool doSetIndex)
3576 {
3577 sp<Package> p = getPackage(package);
3578 if (p == NULL) {
3579 return NULL;
3580 }
3581 return p->getType(type, sourcePos, doSetIndex);
3582 }
3583
3584 sp<ResourceTable::Entry> ResourceTable::getEntry(const String16& package,
3585 const String16& type,
3586 const String16& name,
3587 const SourcePos& sourcePos,
3588 bool overlay,
3589 const ResTable_config* config,
3590 bool doSetIndex)
3591 {
3592 sp<Type> t = getType(package, type, sourcePos, doSetIndex);
3593 if (t == NULL) {
3594 return NULL;
3595 }
3596 return t->getEntry(name, sourcePos, config, doSetIndex, overlay);
3597 }
3598
3599 sp<const ResourceTable::Entry> ResourceTable::getEntry(uint32_t resID,
3600 const ResTable_config* config) const
3601 {
3602 int pid = Res_GETPACKAGE(resID)+1;
3603 const size_t N = mOrderedPackages.size();
3604 size_t i;
3605 sp<Package> p;
3606 for (i=0; i<N; i++) {
3607 sp<Package> check = mOrderedPackages[i];
3608 if (check->getAssignedId() == pid) {
3609 p = check;
3610 break;
3611 }
3612
3613 }
3614 if (p == NULL) {
3615 fprintf(stderr, "warning: Package not found for resource #%08x\n", resID);
3616 return NULL;
3617 }
3618
3619 int tid = Res_GETTYPE(resID);
3620 if (tid < 0 || tid >= (int)p->getOrderedTypes().size()) {
3621 fprintf(stderr, "warning: Type not found for resource #%08x\n", resID);
3622 return NULL;
3623 }
3624 sp<Type> t = p->getOrderedTypes()[tid];
3625
3626 int eid = Res_GETENTRY(resID);
3627 if (eid < 0 || eid >= (int)t->getOrderedConfigs().size()) {
3628 fprintf(stderr, "warning: Entry not found for resource #%08x\n", resID);
3629 return NULL;
3630 }
3631
3632 sp<ConfigList> c = t->getOrderedConfigs()[eid];
3633 if (c == NULL) {
3634 fprintf(stderr, "warning: Entry not found for resource #%08x\n", resID);
3635 return NULL;
3636 }
3637
3638 ConfigDescription cdesc;
3639 if (config) cdesc = *config;
3640 sp<Entry> e = c->getEntries().valueFor(cdesc);
3641 if (c == NULL) {
3642 fprintf(stderr, "warning: Entry configuration not found for resource #%08x\n", resID);
3643 return NULL;
3644 }
3645
3646 return e;
3647 }
3648
3649 const ResourceTable::Item* ResourceTable::getItem(uint32_t resID, uint32_t attrID) const
3650 {
3651 sp<const Entry> e = getEntry(resID);
3652 if (e == NULL) {
3653 return NULL;
3654 }
3655
3656 const size_t N = e->getBag().size();
3657 for (size_t i=0; i<N; i++) {
3658 const Item& it = e->getBag().valueAt(i);
3659 if (it.bagKeyId == 0) {
3660 fprintf(stderr, "warning: ID not yet assigned to '%s' in bag '%s'\n",
3661 String8(e->getName()).string(),
3662 String8(e->getBag().keyAt(i)).string());
3663 }
3664 if (it.bagKeyId == attrID) {
3665 return &it;
3666 }
3667 }
3668
3669 return NULL;
3670 }
3671
3672 bool ResourceTable::getItemValue(
3673 uint32_t resID, uint32_t attrID, Res_value* outValue)
3674 {
3675 const Item* item = getItem(resID, attrID);
3676
3677 bool res = false;
3678 if (item != NULL) {
3679 if (item->evaluating) {
3680 sp<const Entry> e = getEntry(resID);
3681 const size_t N = e->getBag().size();
3682 size_t i;
3683 for (i=0; i<N; i++) {
3684 if (&e->getBag().valueAt(i) == item) {
3685 break;
3686 }
3687 }
3688 fprintf(stderr, "warning: Circular reference detected in key '%s' of bag '%s'\n",
3689 String8(e->getName()).string(),
3690 String8(e->getBag().keyAt(i)).string());
3691 return false;
3692 }
3693 item->evaluating = true;
3694 res = stringToValue(outValue, NULL, item->value, false, false, item->bagKeyId);
3695 NOISY(
3696 if (res) {
3697 printf("getItemValue of #%08x[#%08x] (%s): type=#%08x, data=#%08x\n",
3698 resID, attrID, String8(getEntry(resID)->getName()).string(),
3699 outValue->dataType, outValue->data);
3700 } else {
3701 printf("getItemValue of #%08x[#%08x]: failed\n",
3702 resID, attrID);
3703 }
3704 );
3705 item->evaluating = false;
3706 }
3707 return res;
3708 }
mirror of aapt