//

// Copyright 2006 The Android Open Source Project

//

// Build resource files from raw assets.

//

#include "ResourceTable.h"

#include "XMLNode.h"

#include "ResourceFilter.h"

#include "ResourceIdCache.h"

#include <androidfw/ResourceTypes.h>

#include <utils/ByteOrder.h>

#include <stdarg.h>

#define NOISY(x) //x

status_t compileXmlFile(const sp<AaptAssets>& assets,

const sp<AaptFile>& target,

ResourceTable* table,

int options)

{

sp<XMLNode> root = XMLNode::parse(target);

if (root == NULL) {

return UNKNOWN_ERROR;

}

return compileXmlFile(assets, root, target, table, options);

}

status_t compileXmlFile(const sp<AaptAssets>& assets,

const sp<AaptFile>& target,

const sp<AaptFile>& outTarget,

ResourceTable* table,

int options)

{

sp<XMLNode> root = XMLNode::parse(target);

if (root == NULL) {

return UNKNOWN_ERROR;

}

return compileXmlFile(assets, root, outTarget, table, options);

}

status_t compileXmlFile(const sp<AaptAssets>& assets,

const sp<XMLNode>& root,

const sp<AaptFile>& target,

ResourceTable* table,

int options)

{

if ((options&XML_COMPILE_STRIP_WHITESPACE) != 0) {

root->removeWhitespace(true, NULL);

} else if ((options&XML_COMPILE_COMPACT_WHITESPACE) != 0) {

root->removeWhitespace(false, NULL);

}

if ((options&XML_COMPILE_UTF8) != 0) {

root->setUTF8(true);

}

bool hasErrors = false;

if ((options&XML_COMPILE_ASSIGN_ATTRIBUTE_IDS) != 0) {

status_t err = root->assignResourceIds(assets, table);

if (err != NO_ERROR) {

hasErrors = true;

}

}

status_t err = root->parseValues(assets, table);

if (err != NO_ERROR) {

hasErrors = true;

}

if (hasErrors) {

return UNKNOWN_ERROR;

}

NOISY(printf("Input XML Resource:\n"));

NOISY(root->print());

err = root->flatten(target,

(options&XML_COMPILE_STRIP_COMMENTS) != 0,

(options&XML_COMPILE_STRIP_RAW_VALUES) != 0);

if (err != NO_ERROR) {

return err;

}

NOISY(printf("Output XML Resource:\n"));

NOISY(ResXMLTree tree;

tree.setTo(target->getData(), target->getSize());

printXMLBlock(&tree));

target->setCompressionMethod(ZipEntry::kCompressDeflated);

return err;

}

#undef NOISY

#define NOISY(x) //x

struct flag_entry

{

const char16_t* name;

size_t nameLen;

uint32_t value;

const char* description;

};

static const char16_t referenceArray[] =

{ 'r', 'e', 'f', 'e', 'r', 'e', 'n', 'c', 'e' };

static const char16_t stringArray[] =

{ 's', 't', 'r', 'i', 'n', 'g' };

static const char16_t integerArray[] =

{ 'i', 'n', 't', 'e', 'g', 'e', 'r' };

static const char16_t booleanArray[] =

{ 'b', 'o', 'o', 'l', 'e', 'a', 'n' };

static const char16_t colorArray[] =

{ 'c', 'o', 'l', 'o', 'r' };

static const char16_t floatArray[] =

{ 'f', 'l', 'o', 'a', 't' };

static const char16_t dimensionArray[] =

{ 'd', 'i', 'm', 'e', 'n', 's', 'i', 'o', 'n' };

static const char16_t fractionArray[] =

{ 'f', 'r', 'a', 'c', 't', 'i', 'o', 'n' };

static const char16_t enumArray[] =

{ 'e', 'n', 'u', 'm' };

static const char16_t flagsArray[] =

{ 'f', 'l', 'a', 'g', 's' };

static const flag_entry gFormatFlags[] = {

{ referenceArray, sizeof(referenceArray)/2, ResTable_map::TYPE_REFERENCE,

"a reference to another resource, in the form \"<code>@[+][<i>package</i>:]<i>type</i>:<i>name</i></code>\"\n"

"or to a theme attribute in the form \"<code>?[<i>package</i>:][<i>type</i>:]<i>name</i></code>\"."},

{ stringArray, sizeof(stringArray)/2, ResTable_map::TYPE_STRING,

"a string value, using '\\\\;' to escape characters such as '\\\\n' or '\\\\uxxxx' for a unicode character." },

{ integerArray, sizeof(integerArray)/2, ResTable_map::TYPE_INTEGER,

"an integer value, such as \"<code>100</code>\"." },

{ booleanArray, sizeof(booleanArray)/2, ResTable_map::TYPE_BOOLEAN,

"a boolean value, either \"<code>true</code>\" or \"<code>false</code>\"." },

{ colorArray, sizeof(colorArray)/2, ResTable_map::TYPE_COLOR,

"a color value, in the form of \"<code>#<i>rgb</i></code>\", \"<code>#<i>argb</i></code>\",\n"

"\"<code>#<i>rrggbb</i></code>\", or \"<code>#<i>aarrggbb</i></code>\"." },

{ floatArray, sizeof(floatArray)/2, ResTable_map::TYPE_FLOAT,

"a floating point value, such as \"<code>1.2</code>\"."},

{ dimensionArray, sizeof(dimensionArray)/2, ResTable_map::TYPE_DIMENSION,

"a dimension value, which is a floating point number appended with a unit such as \"<code>14.5sp</code>\".\n"

"Available units are: px (pixels), dp (density-independent pixels), sp (scaled pixels based on preferred font size),\n"

"in (inches), mm (millimeters)." },

{ fractionArray, sizeof(fractionArray)/2, ResTable_map::TYPE_FRACTION,

"a fractional value, which is a floating point number appended with either % or %p, such as \"<code>14.5%</code>\".\n"

"The % suffix always means a percentage of the base size; the optional %p suffix provides a size relative to\n"

"some parent container." },

{ enumArray, sizeof(enumArray)/2, ResTable_map::TYPE_ENUM, NULL },

{ flagsArray, sizeof(flagsArray)/2, ResTable_map::TYPE_FLAGS, NULL },

{ NULL, 0, 0, NULL }

};

static const char16_t suggestedArray[] = { 's', 'u', 'g', 'g', 'e', 's', 't', 'e', 'd' };

static const flag_entry l10nRequiredFlags[] = {

{ suggestedArray, sizeof(suggestedArray)/2, ResTable_map::L10N_SUGGESTED, NULL },

{ NULL, 0, 0, NULL }

};

static const char16_t nulStr[] = { 0 };

static uint32_t parse_flags(const char16_t* str, size_t len,

const flag_entry* flags, bool* outError = NULL)

{

while (len > 0 && isspace(*str)) {

str++;

len--;

}

while (len > 0 && isspace(str[len-1])) {

len--;

}

const char16_t* const end = str + len;

uint32_t value = 0;

while (str < end) {

const char16_t* div = str;

while (div < end && *div != '|') {

div++;

}

const flag_entry* cur = flags;

while (cur->name) {

if (strzcmp16(cur->name, cur->nameLen, str, div-str) == 0) {

value |= cur->value;

break;

}

cur++;

}

if (!cur->name) {

if (outError) *outError = true;

return 0;

}

str = div < end ? div+1 : div;

}

if (outError) *outError = false;

return value;

}

static String16 mayOrMust(int type, int flags)

{

if ((type&(~flags)) == 0) {

return String16("<p>Must");

}

return String16("<p>May");

}

static void appendTypeInfo(ResourceTable* outTable, const String16& pkg,

const String16& typeName, const String16& ident, int type,

const flag_entry* flags)

{

bool hadType = false;

while (flags->name) {

if ((type&flags->value) != 0 && flags->description != NULL) {

String16 fullMsg(mayOrMust(type, flags->value));

fullMsg.append(String16(" be "));

fullMsg.append(String16(flags->description));

outTable->appendTypeComment(pkg, typeName, ident, fullMsg);

hadType = true;

}

flags++;

}

if (hadType && (type&ResTable_map::TYPE_REFERENCE) == 0) {

outTable->appendTypeComment(pkg, typeName, ident,

String16("<p>This may also be a reference to a resource (in the form\n"

"\"<code>@[<i>package</i>:]<i>type</i>:<i>name</i></code>\") or\n"

"theme attribute (in the form\n"

"\"<code>?[<i>package</i>:][<i>type</i>:]<i>name</i></code>\")\n"

"containing a value of this type."));

}

}

struct PendingAttribute

{

const String16 myPackage;

const SourcePos sourcePos;

const bool appendComment;

int32_t type;

String16 ident;

String16 comment;

bool hasErrors;

bool added;

PendingAttribute(String16 _package, const sp<AaptFile>& in,

ResXMLTree& block, bool _appendComment)

: myPackage(_package)

, sourcePos(in->getPrintableSource(), block.getLineNumber())

, appendComment(_appendComment)

, type(ResTable_map::TYPE_ANY)

, hasErrors(false)

, added(false)

{

}

status_t createIfNeeded(ResourceTable* outTable)

{

if (added || hasErrors) {

return NO_ERROR;

}

added = true;

String16 attr16("attr");

if (outTable->hasBagOrEntry(myPackage, attr16, ident)) {

sourcePos.error("Attribute \"%s\" has already been defined\n",

String8(ident).string());

hasErrors = true;

return UNKNOWN_ERROR;

}

char numberStr[16];

sprintf(numberStr, "%d", type);

status_t err = outTable->addBag(sourcePos, myPackage,

attr16, ident, String16(""),

String16("^type"),

String16(numberStr), NULL, NULL);

if (err != NO_ERROR) {

hasErrors = true;

return err;

}

outTable->appendComment(myPackage, attr16, ident, comment, appendComment);

//printf("Attribute %s comment: %s\n", String8(ident).string(),

// String8(comment).string());

return err;

}

};

static status_t compileAttribute(const sp<AaptFile>& in,

ResXMLTree& block,

const String16& myPackage,

ResourceTable* outTable,

String16* outIdent = NULL,

bool inStyleable = false)

{

PendingAttribute attr(myPackage, in, block, inStyleable);

const String16 attr16("attr");

const String16 id16("id");

// Attribute type constants.

const String16 enum16("enum");

const String16 flag16("flag");

ResXMLTree::event_code_t code;

size_t len;

status_t err;

ssize_t identIdx = block.indexOfAttribute(NULL, "name");

if (identIdx >= 0) {

attr.ident = String16(block.getAttributeStringValue(identIdx, &len));

if (outIdent) {

*outIdent = attr.ident;

}

} else {

attr.sourcePos.error("A 'name' attribute is required for <attr>\n");

attr.hasErrors = true;

}

attr.comment = String16(

block.getComment(&len) ? block.getComment(&len) : nulStr);

ssize_t typeIdx = block.indexOfAttribute(NULL, "format");

if (typeIdx >= 0) {

String16 typeStr = String16(block.getAttributeStringValue(typeIdx, &len));

attr.type = parse_flags(typeStr.string(), typeStr.size(), gFormatFlags);

if (attr.type == 0) {

attr.sourcePos.error("Tag <attr> 'format' attribute value \"%s\" not valid\n",

String8(typeStr).string());

attr.hasErrors = true;

}

attr.createIfNeeded(outTable);

} else if (!inStyleable) {

// Attribute definitions outside of styleables always define the

// attribute as a generic value.

attr.createIfNeeded(outTable);

}

//printf("Attribute %s: type=0x%08x\n", String8(attr.ident).string(), attr.type);

ssize_t minIdx = block.indexOfAttribute(NULL, "min");

if (minIdx >= 0) {

String16 val = String16(block.getAttributeStringValue(minIdx, &len));

if (!ResTable::stringToInt(val.string(), val.size(), NULL)) {

attr.sourcePos.error("Tag <attr> 'min' attribute must be a number, not \"%s\"\n",

String8(val).string());

attr.hasErrors = true;

}

attr.createIfNeeded(outTable);

if (!attr.hasErrors) {

err = outTable->addBag(attr.sourcePos, myPackage, attr16, attr.ident,

String16(""), String16("^min"), String16(val), NULL, NULL);

if (err != NO_ERROR) {

attr.hasErrors = true;

}

}

}

ssize_t maxIdx = block.indexOfAttribute(NULL, "max");

if (maxIdx >= 0) {

String16 val = String16(block.getAttributeStringValue(maxIdx, &len));

if (!ResTable::stringToInt(val.string(), val.size(), NULL)) {

attr.sourcePos.error("Tag <attr> 'max' attribute must be a number, not \"%s\"\n",

String8(val).string());

attr.hasErrors = true;

}

attr.createIfNeeded(outTable);

if (!attr.hasErrors) {

err = outTable->addBag(attr.sourcePos, myPackage, attr16, attr.ident,

String16(""), String16("^max"), String16(val), NULL, NULL);

attr.hasErrors = true;

}

}

if ((minIdx >= 0 || maxIdx >= 0) && (attr.type&ResTable_map::TYPE_INTEGER) == 0) {

attr.sourcePos.error("Tag <attr> must have format=integer attribute if using max or min\n");

attr.hasErrors = true;

}

ssize_t l10nIdx = block.indexOfAttribute(NULL, "localization");

if (l10nIdx >= 0) {

const uint16_t* str = block.getAttributeStringValue(l10nIdx, &len);

bool error;

uint32_t l10n_required = parse_flags(str, len, l10nRequiredFlags, &error);

if (error) {

attr.sourcePos.error("Tag <attr> 'localization' attribute value \"%s\" not valid\n",

String8(str).string());

attr.hasErrors = true;

}

attr.createIfNeeded(outTable);

if (!attr.hasErrors) {

char buf[11];

sprintf(buf, "%d", l10n_required);

err = outTable->addBag(attr.sourcePos, myPackage, attr16, attr.ident,

String16(""), String16("^l10n"), String16(buf), NULL, NULL);

if (err != NO_ERROR) {

attr.hasErrors = true;

}

}

}

String16 enumOrFlagsComment;

while ((code=block.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {

if (code == ResXMLTree::START_TAG) {

uint32_t localType = 0;

if (strcmp16(block.getElementName(&len), enum16.string()) == 0) {

localType = ResTable_map::TYPE_ENUM;

} else if (strcmp16(block.getElementName(&len), flag16.string()) == 0) {

localType = ResTable_map::TYPE_FLAGS;

} else {

SourcePos(in->getPrintableSource(), block.getLineNumber())

.error("Tag <%s> can not appear inside <attr>, only <enum> or <flag>\n",

String8(block.getElementName(&len)).string());

return UNKNOWN_ERROR;

}

attr.createIfNeeded(outTable);

if (attr.type == ResTable_map::TYPE_ANY) {

// No type was explicitly stated, so supplying enum tags

// implicitly creates an enum or flag.

attr.type = 0;

}

if ((attr.type&(ResTable_map::TYPE_ENUM|ResTable_map::TYPE_FLAGS)) == 0) {

// Wasn't originally specified as an enum, so update its type.

attr.type |= localType;

if (!attr.hasErrors) {

char numberStr[16];

sprintf(numberStr, "%d", attr.type);

err = outTable->addBag(SourcePos(in->getPrintableSource(), block.getLineNumber()),

myPackage, attr16, attr.ident, String16(""),

String16("^type"), String16(numberStr), NULL, NULL, true);

if (err != NO_ERROR) {

attr.hasErrors = true;

}

}

} else if ((uint32_t)(attr.type&(ResTable_map::TYPE_ENUM|ResTable_map::TYPE_FLAGS)) != localType) {

if (localType == ResTable_map::TYPE_ENUM) {

SourcePos(in->getPrintableSource(), block.getLineNumber())

.error("<enum> attribute can not be used inside a flags format\n");

attr.hasErrors = true;

} else {

SourcePos(in->getPrintableSource(), block.getLineNumber())

.error("<flag> attribute can not be used inside a enum format\n");

attr.hasErrors = true;

}

}

String16 itemIdent;

ssize_t itemIdentIdx = block.indexOfAttribute(NULL, "name");

if (itemIdentIdx >= 0) {

itemIdent = String16(block.getAttributeStringValue(itemIdentIdx, &len));

} else {

SourcePos(in->getPrintableSource(), block.getLineNumber())

.error("A 'name' attribute is required for <enum> or <flag>\n");

attr.hasErrors = true;

}

String16 value;

ssize_t valueIdx = block.indexOfAttribute(NULL, "value");

if (valueIdx >= 0) {

value = String16(block.getAttributeStringValue(valueIdx, &len));

} else {

SourcePos(in->getPrintableSource(), block.getLineNumber())

.error("A 'value' attribute is required for <enum> or <flag>\n");

attr.hasErrors = true;

}

if (!attr.hasErrors && !ResTable::stringToInt(value.string(), value.size(), NULL)) {

SourcePos(in->getPrintableSource(), block.getLineNumber())

.error("Tag <enum> or <flag> 'value' attribute must be a number,"

" not \"%s\"\n",

String8(value).string());

attr.hasErrors = true;

}

// Make sure an id is defined for this enum/flag identifier...

if (!attr.hasErrors && !outTable->hasBagOrEntry(itemIdent, &id16, &myPackage)) {

err = outTable->startBag(SourcePos(in->getPrintableSource(), block.getLineNumber()),

myPackage, id16, itemIdent, String16(), NULL);

if (err != NO_ERROR) {

attr.hasErrors = true;

}

}

if (!attr.hasErrors) {

if (enumOrFlagsComment.size() == 0) {

enumOrFlagsComment.append(mayOrMust(attr.type,

ResTable_map::TYPE_ENUM|ResTable_map::TYPE_FLAGS));

enumOrFlagsComment.append((attr.type&ResTable_map::TYPE_ENUM)

? String16(" be one of the following constant values.")

: String16(" be one or more (separated by '|') of the following constant values."));

enumOrFlagsComment.append(String16("</p>\n<table>\n"

"<colgroup align=\"left\" />\n"

"<colgroup align=\"left\" />\n"

"<colgroup align=\"left\" />\n"

"<tr><th>Constant</th><th>Value</th><th>Description</th></tr>"));

}

enumOrFlagsComment.append(String16("\n<tr><td><code>"));

enumOrFlagsComment.append(itemIdent);

enumOrFlagsComment.append(String16("</code></td><td>"));

enumOrFlagsComment.append(value);

enumOrFlagsComment.append(String16("</td><td>"));

if (block.getComment(&len)) {

enumOrFlagsComment.append(String16(block.getComment(&len)));

}

enumOrFlagsComment.append(String16("</td></tr>"));

err = outTable->addBag(SourcePos(in->getPrintableSource(), block.getLineNumber()),

myPackage,

attr16, attr.ident, String16(""),

itemIdent, value, NULL, NULL, false, true);

if (err != NO_ERROR) {

attr.hasErrors = true;

}

}

} else if (code == ResXMLTree::END_TAG) {

if (strcmp16(block.getElementName(&len), attr16.string()) == 0) {

break;

}

if ((attr.type&ResTable_map::TYPE_ENUM) != 0) {

if (strcmp16(block.getElementName(&len), enum16.string()) != 0) {

SourcePos(in->getPrintableSource(), block.getLineNumber())

.error("Found tag </%s> where </enum> is expected\n",

String8(block.getElementName(&len)).string());

return UNKNOWN_ERROR;

}

} else {

if (strcmp16(block.getElementName(&len), flag16.string()) != 0) {

SourcePos(in->getPrintableSource(), block.getLineNumber())

.error("Found tag </%s> where </flag> is expected\n",

String8(block.getElementName(&len)).string());

return UNKNOWN_ERROR;

}

}

}

}

if (!attr.hasErrors && attr.added) {

appendTypeInfo(outTable, myPackage, attr16, attr.ident, attr.type, gFormatFlags);

}

if (!attr.hasErrors && enumOrFlagsComment.size() > 0) {

enumOrFlagsComment.append(String16("\n</table>"));

outTable->appendTypeComment(myPackage, attr16, attr.ident, enumOrFlagsComment);

}

return NO_ERROR;

}

bool localeIsDefined(const ResTable_config& config)

{

return config.locale == 0;

}

status_t parseAndAddBag(Bundle* bundle,

const sp<AaptFile>& in,

ResXMLTree* block,

const ResTable_config& config,

const String16& myPackage,

const String16& curType,

const String16& ident,

const String16& parentIdent,

const String16& itemIdent,

int32_t curFormat,

bool isFormatted,

const String16& product,

PseudolocalizationMethod pseudolocalize,

const bool overwrite,

ResourceTable* outTable)

{

status_t err;

const String16 item16("item");

String16 str;

Vector<StringPool::entry_style_span> spans;

err = parseStyledString(bundle, in->getPrintableSource().string(),

block, item16, &str, &spans, isFormatted,

pseudolocalize);

if (err != NO_ERROR) {

return err;

}

NOISY(printf("Adding resource bag entry l=%c%c c=%c%c orien=%d d=%d "

" pid=%s, bag=%s, id=%s: %s\n",

config.language[0], config.language[1],

config.country[0], config.country[1],

config.orientation, config.density,

String8(parentIdent).string(),

String8(ident).string(),

String8(itemIdent).string(),

String8(str).string()));

err = outTable->addBag(SourcePos(in->getPrintableSource(), block->getLineNumber()),

myPackage, curType, ident, parentIdent, itemIdent, str,

&spans, &config, overwrite, false, curFormat);

return err;

}

/*

* Returns true if needle is one of the elements in the comma-separated list

* haystack, false otherwise.

*/

bool isInProductList(const String16& needle, const String16& haystack) {

const char16_t *needle2 = needle.string();

const char16_t *haystack2 = haystack.string();

size_t needlesize = needle.size();

while (*haystack2 != '\0') {

if (strncmp16(haystack2, needle2, needlesize) == 0) {

if (haystack2[needlesize] == '\0' || haystack2[needlesize] == ',') {

return true;

}

}

while (*haystack2 != '\0' && *haystack2 != ',') {

haystack2++;

}

if (*haystack2 == ',') {

haystack2++;

}

}

return false;

}

/*

* A simple container that holds a resource type and name. It is ordered first by type then

* by name.

*/

struct type_ident_pair_t {

String16 type;

String16 ident;

type_ident_pair_t() { };

type_ident_pair_t(const String16& t, const String16& i) : type(t), ident(i) { }

type_ident_pair_t(const type_ident_pair_t& o) : type(o.type), ident(o.ident) { }

inline bool operator < (const type_ident_pair_t& o) const {

int cmp = compare_type(type, o.type);

if (cmp < 0) {

return true;

} else if (cmp > 0) {

return false;

} else {

return strictly_order_type(ident, o.ident);

}

}

};

status_t parseAndAddEntry(Bundle* bundle,

const sp<AaptFile>& in,

ResXMLTree* block,

const ResTable_config& config,

const String16& myPackage,

const String16& curType,

const String16& ident,

const String16& curTag,

bool curIsStyled,

int32_t curFormat,

bool isFormatted,

const String16& product,

PseudolocalizationMethod pseudolocalize,

const bool overwrite,

KeyedVector<type_ident_pair_t, bool>* skippedResourceNames,

ResourceTable* outTable)

{

status_t err;

String16 str;

Vector<StringPool::entry_style_span> spans;

err = parseStyledString(bundle, in->getPrintableSource().string(), block,

curTag, &str, curIsStyled ? &spans : NULL,

isFormatted, pseudolocalize);

if (err < NO_ERROR) {

return err;

}

/*

* If a product type was specified on the command line

* and also in the string, and the two are not the same,

* return without adding the string.

*/

const char *bundleProduct = bundle->getProduct();

if (bundleProduct == NULL) {

bundleProduct = "";

}

if (product.size() != 0) {

/*

* If the command-line-specified product is empty, only "default"

* matches. Other variants are skipped. This is so generation

* of the R.java file when the product is not known is predictable.

*/

if (bundleProduct[0] == '\0') {

if (strcmp16(String16("default").string(), product.string()) != 0) {

/*

* This string has a product other than 'default'. Do not add it,

* but record it so that if we do not see the same string with

* product 'default' or no product, then report an error.

*/

skippedResourceNames->replaceValueFor(

type_ident_pair_t(curType, ident), true);

return NO_ERROR;

}

} else {

/*

* The command-line product is not empty.

* If the product for this string is on the command-line list,

* it matches. "default" also matches, but only if nothing

* else has matched already.

*/

if (isInProductList(product, String16(bundleProduct))) {

;

} else if (strcmp16(String16("default").string(), product.string()) == 0 &&

!outTable->hasBagOrEntry(myPackage, curType, ident, config)) {

;

} else {

return NO_ERROR;

}

}

}

NOISY(printf("Adding resource entry l=%c%c c=%c%c orien=%d d=%d id=%s: %s\n",

config.language[0], config.language[1],

config.country[0], config.country[1],

config.orientation, config.density,

String8(ident).string(), String8(str).string()));

err = outTable->addEntry(SourcePos(in->getPrintableSource(), block->getLineNumber()),

myPackage, curType, ident, str, &spans, &config,

false, curFormat, overwrite);

return err;

}

status_t compileResourceFile(Bundle* bundle,

const sp<AaptAssets>& assets,

const sp<AaptFile>& in,

const ResTable_config& defParams,

const bool overwrite,

ResourceTable* outTable)

{

ResXMLTree block;

status_t err = parseXMLResource(in, &block, false, true);

if (err != NO_ERROR) {

return err;

}

// Top-level tag.

const String16 resources16("resources");

// Identifier declaration tags.

const String16 declare_styleable16("declare-styleable");

const String16 attr16("attr");

// Data creation organizational tags.

const String16 string16("string");

const String16 drawable16("drawable");

const String16 color16("color");

const String16 bool16("bool");

const String16 integer16("integer");

const String16 dimen16("dimen");

const String16 fraction16("fraction");

const String16 style16("style");

const String16 plurals16("plurals");

const String16 array16("array");

const String16 string_array16("string-array");

const String16 integer_array16("integer-array");

const String16 public16("public");

const String16 public_padding16("public-padding");

const String16 private_symbols16("private-symbols");

const String16 java_symbol16("java-symbol");

const String16 add_resource16("add-resource");

const String16 skip16("skip");

const String16 eat_comment16("eat-comment");

// Data creation tags.

const String16 bag16("bag");

const String16 item16("item");

// Attribute type constants.

const String16 enum16("enum");

// plural values

const String16 other16("other");

const String16 quantityOther16("^other");

const String16 zero16("zero");

const String16 quantityZero16("^zero");

const String16 one16("one");

const String16 quantityOne16("^one");

const String16 two16("two");

const String16 quantityTwo16("^two");

const String16 few16("few");

const String16 quantityFew16("^few");

const String16 many16("many");

const String16 quantityMany16("^many");

// useful attribute names and special values

const String16 name16("name");

const String16 translatable16("translatable");

const String16 formatted16("formatted");

const String16 false16("false");

const String16 myPackage(assets->getPackage());

bool hasErrors = false;

bool fileIsTranslatable = true;

if (strstr(in->getPrintableSource().string(), "donottranslate") != NULL) {

fileIsTranslatable = false;

}

DefaultKeyedVector<String16, uint32_t> nextPublicId(0);

// Stores the resource names that were skipped. Typically this happens when

// AAPT is invoked without a product specified and a resource has no

// 'default' product attribute.

KeyedVector<type_ident_pair_t, bool> skippedResourceNames;

ResXMLTree::event_code_t code;

do {

code = block.next();

} while (code == ResXMLTree::START_NAMESPACE);

size_t len;

if (code != ResXMLTree::START_TAG) {

SourcePos(in->getPrintableSource(), block.getLineNumber()).error(

"No start tag found\n");

return UNKNOWN_ERROR;

}

if (strcmp16(block.getElementName(&len), resources16.string()) != 0) {

SourcePos(in->getPrintableSource(), block.getLineNumber()).error(

"Invalid start tag %s\n", String8(block.getElementName(&len)).string());

return UNKNOWN_ERROR;

}

ResTable_config curParams(defParams);

ResTable_config pseudoParams(curParams);

pseudoParams.language[0] = 'e';

pseudoParams.language[1] = 'n';

pseudoParams.country[0] = 'X';

pseudoParams.country[1] = 'A';

ResTable_config pseudoBidiParams(curParams);

pseudoBidiParams.language[0] = 'a';

pseudoBidiParams.language[1] = 'r';

pseudoBidiParams.country[0] = 'X';

pseudoBidiParams.country[1] = 'B';

// We should skip resources for pseudolocales if they were

// already added automatically. This is a fix for a transition period when

// manually pseudolocalized resources may be expected.

// TODO: remove this check after next SDK version release.

if ((bundle->getPseudolocalize() & PSEUDO_ACCENTED &&

curParams.locale == pseudoParams.locale) ||

(bundle->getPseudolocalize() & PSEUDO_BIDI &&

curParams.locale == pseudoBidiParams.locale)) {

SourcePos(in->getPrintableSource(), 0).warning(

"Resource file %s is skipped as pseudolocalization"

" was done automatically.",

in->getPrintableSource().string());

return NO_ERROR;

}

while ((code=block.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {

if (code == ResXMLTree::START_TAG) {

const String16* curTag = NULL;

String16 curType;

int32_t curFormat = ResTable_map::TYPE_ANY;

bool curIsBag = false;

bool curIsBagReplaceOnOverwrite = false;

bool curIsStyled = false;

bool curIsPseudolocalizable = false;

bool curIsFormatted = fileIsTranslatable;

bool localHasErrors = false;

if (strcmp16(block.getElementName(&len), skip16.string()) == 0) {

while ((code=block.next()) != ResXMLTree::END_DOCUMENT

&& code != ResXMLTree::BAD_DOCUMENT) {

if (code == ResXMLTree::END_TAG) {

if (strcmp16(block.getElementName(&len), skip16.string()) == 0) {

break;

}

}

}

continue;

} else if (strcmp16(block.getElementName(&len), eat_comment16.string()) == 0) {

while ((code=block.next()) != ResXMLTree::END_DOCUMENT

&& code != ResXMLTree::BAD_DOCUMENT) {

if (code == ResXMLTree::END_TAG) {

if (strcmp16(block.getElementName(&len), eat_comment16.string()) == 0) {

break;

}

}

}

continue;

} else if (strcmp16(block.getElementName(&len), public16.string()) == 0) {

SourcePos srcPos(in->getPrintableSource(), block.getLineNumber());

String16 type;

ssize_t typeIdx = block.indexOfAttribute(NULL, "type");

if (typeIdx < 0) {

srcPos.error("A 'type' attribute is required for <public>\n");

hasErrors = localHasErrors = true;

}

type = String16(block.getAttributeStringValue(typeIdx, &len));

String16 name;

ssize_t nameIdx = block.indexOfAttribute(NULL, "name");

if (nameIdx < 0) {

srcPos.error("A 'name' attribute is required for <public>\n");

hasErrors = localHasErrors = true;

}

name = String16(block.getAttributeStringValue(nameIdx, &len));

uint32_t ident = 0;

ssize_t identIdx = block.indexOfAttribute(NULL, "id");

if (identIdx >= 0) {

const char16_t* identStr = block.getAttributeStringValue(identIdx, &len);

Res_value identValue;

if (!ResTable::stringToInt(identStr, len, &identValue)) {

srcPos.error("Given 'id' attribute is not an integer: %s\n",

String8(block.getAttributeStringValue(identIdx, &len)).string());

hasErrors = localHasErrors = true;

} else {

ident = identValue.data;

nextPublicId.replaceValueFor(type, ident+1);

}

} else if (nextPublicId.indexOfKey(type) < 0) {

srcPos.error("No 'id' attribute supplied <public>,"

" and no previous id defined in this file.\n");

hasErrors = localHasErrors = true;

} else if (!localHasErrors) {

ident = nextPublicId.valueFor(type);

nextPublicId.replaceValueFor(type, ident+1);

}

if (!localHasErrors) {

err = outTable->addPublic(srcPos, myPackage, type, name, ident);

if (err < NO_ERROR) {

hasErrors = localHasErrors = true;

}

}

if (!localHasErrors) {

sp<AaptSymbols> symbols = assets->getSymbolsFor(String8("R"));

if (symbols != NULL) {

symbols = symbols->addNestedSymbol(String8(type), srcPos);

}

if (symbols != NULL) {

symbols->makeSymbolPublic(String8(name), srcPos);

String16 comment(

block.getComment(&len) ? block.getComment(&len) : nulStr);

symbols->appendComment(String8(name), comment, srcPos);

} else {

srcPos.error("Unable to create symbols!\n");

hasErrors = localHasErrors = true;

}

}

while ((code=block.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {

if (code == ResXMLTree::END_TAG) {

if (strcmp16(block.getElementName(&len), public16.string()) == 0) {

break;

}

}

}

continue;

} else if (strcmp16(block.getElementName(&len), public_padding16.string()) == 0) {

SourcePos srcPos(in->getPrintableSource(), block.getLineNumber());

String16 type;

ssize_t typeIdx = block.indexOfAttribute(NULL, "type");

if (typeIdx < 0) {

srcPos.error("A 'type' attribute is required for <public-padding>\n");

hasErrors = localHasErrors = true;

}

type = String16(block.getAttributeStringValue(typeIdx, &len));

String16 name;