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