Merge "Output proguard keep flags for fragment classes." into gingerbread

[android/aapt.git] / ResourceTable.cpp

diff --git a/ResourceTable.cpp b/ResourceTable.cpp
index 85665e0c17b371ec318267368a1230fe40b9143d..755b93bc24c54b83bb64efb3545629e3ef67645d 100644 (file)
--- a/ResourceTable.cpp
+++ b/ResourceTable.cpp
@@ -13,7 +13,6 @@
 #include <stdarg.h>
 
 #define NOISY(x) //x
 #include <stdarg.h>
 
 #define NOISY(x) //x

-#define NOISY_REF(x) //x

 
 status_t compileXmlFile(const sp<AaptAssets>& assets,
                         const sp<AaptFile>& target,
 
 status_t compileXmlFile(const sp<AaptAssets>& assets,
                         const sp<AaptFile>& target,


@@ -574,6 +573,7 @@ status_t parseAndAddBag(Bundle* bundle,
                         const String16& parentIdent,
                         const String16& itemIdent,
                         int32_t curFormat,
                         const String16& parentIdent,
                         const String16& itemIdent,
                         int32_t curFormat,

+                        bool isFormatted,

                         bool pseudolocalize,
                         const bool overwrite,
                         ResourceTable* outTable)
                         bool pseudolocalize,
                         const bool overwrite,
                         ResourceTable* outTable)


@@ -584,7 +584,7 @@ status_t parseAndAddBag(Bundle* bundle,
     String16 str;
     Vector<StringPool::entry_style_span> spans;
     err = parseStyledString(bundle, in->getPrintableSource().string(),
     String16 str;
     Vector<StringPool::entry_style_span> spans;
     err = parseStyledString(bundle, in->getPrintableSource().string(),

-                            block, item16, &str, &spans,
+                            block, item16, &str, &spans, isFormatted,

                             pseudolocalize);
     if (err != NO_ERROR) {
         return err;
                             pseudolocalize);
     if (err != NO_ERROR) {
         return err;


@@ -617,6 +617,7 @@ status_t parseAndAddEntry(Bundle* bundle,
                         const String16& curTag,
                         bool curIsStyled,
                         int32_t curFormat,
                         const String16& curTag,
                         bool curIsStyled,
                         int32_t curFormat,

+                        bool isFormatted,

                         bool pseudolocalize,
                         const bool overwrite,
                         ResourceTable* outTable)
                         bool pseudolocalize,
                         const bool overwrite,
                         ResourceTable* outTable)


@@ -627,7 +628,7 @@ status_t parseAndAddEntry(Bundle* bundle,
     Vector<StringPool::entry_style_span> spans;
     err = parseStyledString(bundle, in->getPrintableSource().string(), block,
                             curTag, &str, curIsStyled ? &spans : NULL,
     Vector<StringPool::entry_style_span> spans;
     err = parseStyledString(bundle, in->getPrintableSource().string(), block,
                             curTag, &str, curIsStyled ? &spans : NULL,

-                            pseudolocalize);
+                            isFormatted, pseudolocalize);

 
     if (err < NO_ERROR) { 
         return err;
 
     if (err < NO_ERROR) { 
         return err;


@@ -710,12 +711,18 @@ status_t compileResourceFile(Bundle* bundle,
     // useful attribute names and special values
     const String16 name16("name");
     const String16 translatable16("translatable");
     // 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;
     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);
 
     ResXMLTree::event_code_t code;
     DefaultKeyedVector<String16, uint32_t> nextPublicId(0);
 
     ResXMLTree::event_code_t code;


@@ -752,6 +759,7 @@ status_t compileResourceFile(Bundle* bundle,
             bool curIsBagReplaceOnOverwrite = false;
             bool curIsStyled = false;
             bool curIsPseudolocalizable = false;
             bool curIsBagReplaceOnOverwrite = false;
             bool curIsStyled = false;
             bool curIsPseudolocalizable = false;

+            bool curIsFormatted = fileIsTranslatable;

             bool localHasErrors = false;
 
             if (strcmp16(block.getElementName(&len), skip16.string()) == 0) {
             bool localHasErrors = false;
 
             if (strcmp16(block.getElementName(&len), skip16.string()) == 0) {


@@ -1137,6 +1145,7 @@ status_t compileResourceFile(Bundle* bundle,
                 String8 locale(rawLocale);
                 String16 name;
                 String16 translatable;
                 String8 locale(rawLocale);
                 String16 name;
                 String16 translatable;

+                String16 formatted;

 
                 size_t n = block.getAttributeCount();
                 for (size_t i = 0; i < n; i++) {
 
                 size_t n = block.getAttributeCount();
                 for (size_t i = 0; i < n; i++) {


@@ -1146,11 +1155,14 @@ status_t compileResourceFile(Bundle* bundle,
                         name.setTo(block.getAttributeStringValue(i, &length));
                     } else if (strcmp16(attr, translatable16.string()) == 0) {
                         translatable.setTo(block.getAttributeStringValue(i, &length));
                         name.setTo(block.getAttributeStringValue(i, &length));
                     } else if (strcmp16(attr, translatable16.string()) == 0) {
                         translatable.setTo(block.getAttributeStringValue(i, &length));

+                    } else if (strcmp16(attr, formatted16.string()) == 0) {
+                        formatted.setTo(block.getAttributeStringValue(i, &length));

                     }
                 }
                 
                 if (name.size() > 0) {
                     if (translatable == false16) {
                     }
                 }
                 
                 if (name.size() > 0) {
                     if (translatable == false16) {

+                        curIsFormatted = false;

                         // Untranslatable strings must only exist in the default [empty] locale
                         if (locale.size() > 0) {
                             fprintf(stderr, "aapt: warning: string '%s' in %s marked untranslatable but exists"
                         // Untranslatable strings must only exist in the default [empty] locale
                         if (locale.size() > 0) {
                             fprintf(stderr, "aapt: warning: string '%s' in %s marked untranslatable but exists"


@@ -1168,6 +1180,10 @@ status_t compileResourceFile(Bundle* bundle,
                     } else {
                         outTable->addLocalization(name, locale);
                     }
                     } else {
                         outTable->addLocalization(name, locale);
                     }

+
+                    if (formatted == false16) {
+                        curIsFormatted = false;
+                    }

                 }
 
                 curTag = &string16;
                 }
 
                 curTag = &string16;


@@ -1357,7 +1373,7 @@ status_t compileResourceFile(Bundle* bundle,
                         block.getPosition(&parserPosition);
 
                         err = parseAndAddBag(bundle, in, &block, curParams, myPackage, curType,
                         block.getPosition(&parserPosition);
 
                         err = parseAndAddBag(bundle, in, &block, curParams, myPackage, curType,

-                                ident, parentIdent, itemIdent, curFormat, 
+                                ident, parentIdent, itemIdent, curFormat, curIsFormatted,

                                 false, overwrite, outTable);
                         if (err == NO_ERROR) {
                             if (curIsPseudolocalizable && localeIsDefined(curParams)
                                 false, overwrite, outTable);
                         if (err == NO_ERROR) {
                             if (curIsPseudolocalizable && localeIsDefined(curParams)


@@ -1366,8 +1382,8 @@ status_t compileResourceFile(Bundle* bundle,
 #if 1
                                 block.setPosition(parserPosition);
                                 err = parseAndAddBag(bundle, in, &block, pseudoParams, myPackage,
 #if 1
                                 block.setPosition(parserPosition);
                                 err = parseAndAddBag(bundle, in, &block, pseudoParams, myPackage,

-                                        curType, ident, parentIdent, itemIdent, curFormat, true,
-                                        overwrite, outTable);
+                                        curType, ident, parentIdent, itemIdent, curFormat,
+                                        curIsFormatted, true, overwrite, outTable);

 #endif
                             }
                         } 
 #endif
                             }
                         } 


@@ -1390,7 +1406,8 @@ status_t compileResourceFile(Bundle* bundle,
                 block.getPosition(&parserPosition);
 
                 err = parseAndAddEntry(bundle, in, &block, curParams, myPackage, curType, ident,
                 block.getPosition(&parserPosition);
 
                 err = parseAndAddEntry(bundle, in, &block, curParams, myPackage, curType, ident,

-                        *curTag, curIsStyled, curFormat, false, overwrite, outTable);
+                        *curTag, curIsStyled, curFormat, curIsFormatted,
+                        false, overwrite, outTable);

 
                 if (err < NO_ERROR) { // Why err < NO_ERROR instead of err != NO_ERROR?
                     hasErrors = localHasErrors = true;
 
                 if (err < NO_ERROR) { // Why err < NO_ERROR instead of err != NO_ERROR?
                     hasErrors = localHasErrors = true;


@@ -1401,7 +1418,8 @@ status_t compileResourceFile(Bundle* bundle,
                         // pseudolocalize here
                         block.setPosition(parserPosition);
                         err = parseAndAddEntry(bundle, in, &block, pseudoParams, myPackage, curType,
                         // pseudolocalize here
                         block.setPosition(parserPosition);
                         err = parseAndAddEntry(bundle, in, &block, pseudoParams, myPackage, curType,

-                                ident, *curTag, curIsStyled, curFormat, true, overwrite, outTable);
+                                ident, *curTag, curIsStyled, curFormat,
+                                curIsFormatted, true, overwrite, outTable);

                         if (err != NO_ERROR) {
                             hasErrors = localHasErrors = true;
                         }
                         if (err != NO_ERROR) {
                             hasErrors = localHasErrors = true;
                         }


@@ -1934,7 +1952,7 @@ bool ResourceTable::stringToValue(Res_value* outValue, StringPool* pool,
         // information we have already processed that string!
         outValue->size = sizeof(Res_value);
         outValue->res0 = 0;
         // information we have already processed that string!
         outValue->size = sizeof(Res_value);
         outValue->res0 = 0;

-        outValue->dataType = Res_value::TYPE_STRING;
+        outValue->dataType = outValue->TYPE_STRING;

         outValue->data = 0;
         finalStr = str;
     }
         outValue->data = 0;
         finalStr = str;
     }


@@ -1943,7 +1961,7 @@ bool ResourceTable::stringToValue(Res_value* outValue, StringPool* pool,
         return false;
     }
 
         return false;
     }
 

-    if (outValue->dataType == Res_value::TYPE_STRING) {
+    if (outValue->dataType == outValue->TYPE_STRING) {

         // Should do better merging styles.
         if (pool) {
             if (style != NULL && style->size() > 0) {
         // Should do better merging styles.
         if (pool) {
             if (style != NULL && style->size() > 0) {


@@ -2528,10 +2546,11 @@ status_t ResourceTable::flatten(Bundle* bundle, const sp<AaptFile>& dest)
     const size_t N = mOrderedPackages.size();
     size_t pi;
 
     const size_t N = mOrderedPackages.size();
     size_t pi;
 

+    bool useUTF8 = !bundle->getWantUTF16() && bundle->isMinSdkAtLeast(SDK_FROYO);
+

     // Iterate through all data, collecting all values (strings,
     // references, etc).
     // Iterate through all data, collecting all values (strings,
     // references, etc).

-    StringPool valueStrings = StringPool(false, bundle->getUTF8());
-    ResourceConfigReferences configRefs;
+    StringPool valueStrings = StringPool(false, useUTF8);

     for (pi=0; pi<N; pi++) {
         sp<Package> p = mOrderedPackages.itemAt(pi);
         if (p->getTypes().size() == 0) {
     for (pi=0; pi<N; pi++) {
         sp<Package> p = mOrderedPackages.itemAt(pi);
         if (p->getTypes().size() == 0) {


@@ -2539,8 +2558,8 @@ status_t ResourceTable::flatten(Bundle* bundle, const sp<AaptFile>& dest)
             continue;
         }
 
             continue;
         }
 

-        StringPool typeStrings = StringPool(false, bundle->getUTF8());
-        StringPool keyStrings = StringPool(false, bundle->getUTF8());
+        StringPool typeStrings = StringPool(false, useUTF8);
+        StringPool keyStrings = StringPool(false, useUTF8);

 
         const size_t N = p->getOrderedTypes().size();
         for (size_t ti=0; ti<N; ti++) {
 
         const size_t N = p->getOrderedTypes().size();
         for (size_t ti=0; ti<N; ti++) {


@@ -2572,13 +2591,6 @@ status_t ResourceTable::flatten(Bundle* bundle, const sp<AaptFile>& dest)
                     if (err != NO_ERROR) {
                         return err;
                     }
                     if (err != NO_ERROR) {
                         return err;
                     }

-                    if (e->getType() == Entry::TYPE_ITEM) {
-                        const Item* item = e->getItem();
-                        if (item != NULL) {
-                            uint32_t poolIndex = item->parsedValue.data;
-                            configRefs.add(poolIndex, config);
-                        }
-                    }

                 }
             }
         }
                 }
             }
         }


@@ -2587,70 +2599,6 @@ status_t ResourceTable::flatten(Bundle* bundle, const sp<AaptFile>& dest)
         p->setKeyStrings(keyStrings.createStringBlock());
     }
 
         p->setKeyStrings(keyStrings.createStringBlock());
     }
 

-    NOISY_REF(configRefs.dump();)
-
-    // Trim all entries in config tables that are not roots for that string.
-    // i.e., rely on the resource system to grab the string from the more
-    // generic pool during runtime to save space.
-    for (pi=0; pi<N; pi++) {
-        sp<Package> p = mOrderedPackages.itemAt(pi);
-        if (p->getTypes().size() == 0) {
-            // Empty, skip!
-            continue;
-        }
-        const size_t TN = p->getOrderedTypes().size();
-        for (size_t ti=0; ti<TN; ti++) {
-            sp<Type> t = p->getOrderedTypes().itemAt(ti);
-            if (t == NULL) {
-                continue;
-            }
-            size_t CN = t->getOrderedConfigs().size();
-            for (size_t ci=0; ci<CN; ci++) {
-                sp<ConfigList> c = t->getOrderedConfigs().itemAt(ci);
-                if (c == NULL) {
-                    continue;
-                }
-                DefaultKeyedVector<ConfigDescription, sp<Entry> > newEntries;
-                size_t EN = c->getEntries().size();
-                for (size_t ei=0; ei<EN; ++ei) {
-                    ConfigDescription config = c->getEntries().keyAt(ei);
-                    if (!filter.match(config)) {
-                        continue;
-                    }
-                    sp<Entry> e = c->getEntries().valueAt(ei);
-                    if (e == NULL) {
-                        continue;
-                    }
-                    if (e->getType() == Entry::TYPE_ITEM) {
-                        const Item* item = e->getItem();
-                        if (item != NULL) {
-                            uint32_t poolIndex = item->parsedValue.data;
-                            if (!configRefs.isRoot(poolIndex, config)) {
-                                NOISY_REF(
-                                    printf("  ConfigRef %d: removing ", poolIndex);
-                                    DEBUG_LANG(config)
-                                    printf("\n");
-                                )
-                                c->removeEntryAt(ei);
-                                t->removeUniqueConfig(config);
-                                --ei; --EN;
-                            }
-                        }
-                    }
-                }
-                if (EN == 0) {
-                    // We removed all the entries from a config, so remove the
-                    // config itself.
-                    NOISY_REF(
-                        printf("  ConfigRef REMOVED ENTIRE CONFIG\n");
-                    )
-                    t->removeOrderedConfigAt(ci);
-                    --ci; --CN;
-                }
-            }
-        }
-    }
-

     ssize_t strAmt = 0;
     
     // Now build the array of package chunks.
     ssize_t strAmt = 0;
     
     // Now build the array of package chunks.


@@ -3805,95 +3753,3 @@ bool ResourceTable::getItemValue(
     }
     return res;
 }
     }
     return res;
 }

-
-#define DEBUG_LANG(x) printf("lang=%c%c cnt=%c%c ", \
-        (x).language[0] ? (x).language[0] : '-', \
-        (x).language[1] ? (x).language[1] : '-', \
-        (x).country[0] ? (x).country[0] : '-', \
-        (x).country[1] ? (x).country[1] : '-');
-
-status_t ResourceConfigReferences::add(uint32_t id, const ResTable_config& config)
-{
-    ssize_t index = mRoots.indexOfKey(id);
-    if (index < 0) {
-        index = mRoots.add(id, Vector<const ResTable_config*>());
-    }
-    Vector<const ResTable_config*>& configRoots = mRoots.editValueFor(id);
-
-    if (!configRoots.isEmpty()) {
-        ssize_t NR = configRoots.size();
-        for (int ri=0; ri<NR; ++ri) {
-            const ResTable_config* current = configRoots[ri];
-
-            if (config.match(*current)) {
-                // We already have something more generic than our incoming string.
-                NOISY_REF(
-                    printf("  ConfigRef %d: ignoring ", id);
-                    DEBUG_LANG(config)
-                    printf("\n");
-                )
-                return NO_ERROR;
-            } else if (current->match(config)) {
-                // more generic
-                NOISY_REF(
-                    printf("  ConfigRef %d: remove ", id);
-                    DEBUG_LANG(current)
-                    printf("\n");
-                )
-                configRoots.removeItemsAt(ri);
-                --ri; --NR;
-            }
-        }
-    }
-    NOISY_REF(
-        printf("  ConfigRef %d: add ", id);
-        DEBUG_LANG(config)
-        printf("\n");
-    )
-    ResTable_config *configCopy = (ResTable_config*)malloc(sizeof(ResTable_config));
-    memcpy(configCopy, &config, sizeof(ResTable_config));
-    configRoots.add(configCopy);
-
-    return NO_ERROR;
-}
-
-void ResourceConfigReferences::dump()
-{
-    printf("ResourceConfigReferences\n");
-    const ssize_t NR = mRoots.size();
-    for (int ri=0; ri<NR; ++ri) {
-        const Vector<const ResTable_config*>& configRoots = mRoots.valueAt(ri);
-        printf("  String %d\n", mRoots.keyAt(ri));
-        const ssize_t NC = configRoots.size();
-        for (int ci=0; ci<NC; ++ci) {
-            printf("    ");
-            DEBUG_LANG(*configRoots[ci])
-            printf("\n");
-        }
-    }
-}
-
-bool ResourceConfigReferences::isRoot(uint32_t id, const ResTable_config& config)
-{
-    const Vector<const ResTable_config*>& configRoots = mRoots.editValueFor(id);
-    const ssize_t NR = configRoots.size();
-    for (int ri = 0; ri<NR; ++ri) {
-        if (configRoots[ri]->match(config)) {
-            return true;
-        }
-    }
-    return false;
-}
-
-ResourceConfigReferences::~ResourceConfigReferences()
-{
-    const ssize_t NR = mRoots.size();
-    for (int ri=0; ri<NR; ++ri) {
-        Vector<const ResTable_config*> configRoots = mRoots.editValueAt(ri);
-        const ssize_t NC = configRoots.size();
-        for (int ci=0; ci<NC; ++ci) {
-            ResTable_config* config = const_cast<ResTable_config*>(configRoots[ci]);
-            free(config);
-        }
-    }
-}