rewrite the pseudo package reinstaller to be more intelligent

[apt.git] / apt-pkg / aptconfiguration.cc

diff --git a/apt-pkg/aptconfiguration.cc b/apt-pkg/aptconfiguration.cc
index f1989599b2415a1c42cabbb6f438bd7477606f2b..2acf8dd9f08b64bcb2be328ef0e6351b9ae28a49 100644 (file)
--- a/apt-pkg/aptconfiguration.cc
+++ b/apt-pkg/aptconfiguration.cc
@@ -14,9 +14,12 @@
 #include <apt-pkg/macros.h>
 #include <apt-pkg/strutl.h>
 
 #include <apt-pkg/macros.h>
 #include <apt-pkg/strutl.h>
 

-#include <vector>
-#include <string>
+#include <sys/types.h>
+#include <dirent.h>
+

 #include <algorithm>
 #include <algorithm>

+#include <string>
+#include <vector>

                                                                        /*}}}*/
 namespace APT {
 // getCompressionTypes - Return Vector of usbale compressiontypes      /*{{{*/
                                                                        /*}}}*/
 namespace APT {
 // getCompressionTypes - Return Vector of usbale compressiontypes      /*{{{*/


@@ -119,6 +122,38 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
                }
        }
 
                }
        }
 

+       // Include all Language codes we have a Translation file for in /var/lib/apt/lists
+       // so they will be all included in the Cache.
+       std::vector<string> builtin;
+       DIR *D = opendir(_config->FindDir("Dir::State::lists").c_str());
+       if (D != 0) {
+               builtin.push_back("none");
+               for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D)) {
+                       string const name = Ent->d_name;
+                       size_t const foundDash = name.rfind("-");
+                       size_t const foundUnderscore = name.rfind("_");
+                       if (foundDash == string::npos || foundUnderscore == string::npos ||
+                           foundDash <= foundUnderscore ||
+                           name.substr(foundUnderscore+1, foundDash-(foundUnderscore+1)) != "Translation")
+                               continue;
+                       string const c = name.substr(foundDash+1);
+                       if (unlikely(c.empty() == true) || c == "en")
+                               continue;
+                       // Skip unusual files, like backups or that alike
+                       string::const_iterator s = c.begin();
+                       for (;s != c.end(); ++s) {
+                               if (isalpha(*s) == 0)
+                                       break;
+                       }
+                       if (s != c.end())
+                               continue;
+                       if (std::find(builtin.begin(), builtin.end(), c) != builtin.end())
+                               continue;
+                       builtin.push_back(c);
+               }
+       }
+       closedir(D);
+

        // get the environment language codes: LC_MESSAGES (and later LANGUAGE)
        // we extract both, a long and a short code and then we will
        // check if we actually need both (rare) or if the short is enough
        // get the environment language codes: LC_MESSAGES (and later LANGUAGE)
        // we extract both, a long and a short code and then we will
        // check if we actually need both (rare) or if the short is enough


@@ -134,7 +169,11 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
        if (envLong == "C") {
                codes.push_back("en");
                allCodes = codes;
        if (envLong == "C") {
                codes.push_back("en");
                allCodes = codes;

-               return codes;
+               allCodes.insert(allCodes.end(), builtin.begin(), builtin.end());
+               if (All == true)
+                       return allCodes;
+               else
+                       return codes;

        }
 
        // to save the servers from unneeded queries, we only try also long codes
        }
 
        // to save the servers from unneeded queries, we only try also long codes


@@ -159,8 +198,16 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
        if (oldAcquire.empty() == false && oldAcquire != "environment") {
                if (oldAcquire != "none")
                        codes.push_back(oldAcquire);
        if (oldAcquire.empty() == false && oldAcquire != "environment") {
                if (oldAcquire != "none")
                        codes.push_back(oldAcquire);

+               codes.push_back("en");

                allCodes = codes;
                allCodes = codes;

-               return codes;
+               for (std::vector<string>::const_iterator b = builtin.begin();
+                    b != builtin.end(); ++b)
+                       if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
+                               allCodes.push_back(*b);
+               if (All == true)
+                       return allCodes;
+               else
+                       return codes;

        }
 
        // It is very likely we will need to environment codes later,
        }
 
        // It is very likely we will need to environment codes later,


@@ -171,9 +218,10 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
                environment.push_back(envLong);
        environment.push_back(envShort);
        // take care of LANGUAGE
                environment.push_back(envLong);
        environment.push_back(envShort);
        // take care of LANGUAGE

-       string envLang = Locale == 0 ? getenv("LANGUAGE") : *(Locale+1);
+       const char *language_env = getenv("LANGUAGE") == 0 ? "" : getenv("LANGUAGE");
+       string envLang = Locale == 0 ? language_env : *(Locale+1);

        if (envLang.empty() == false) {
        if (envLang.empty() == false) {

-               std::vector<string> env = ExplodeString(envLang,':');
+               std::vector<string> env = VectorizeString(envLang,':');

                short addedLangs = 0; // add a maximum of 3 fallbacks from the environment
                for (std::vector<string>::const_iterator e = env.begin();
                     e != env.end() && addedLangs < 3; ++e) {
                short addedLangs = 0; // add a maximum of 3 fallbacks from the environment
                for (std::vector<string>::const_iterator e = env.begin();
                     e != env.end() && addedLangs < 3; ++e) {


@@ -207,7 +255,14 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
                } else if (forceLang != "none")
                        codes.push_back(forceLang);
                allCodes = codes;
                } else if (forceLang != "none")
                        codes.push_back(forceLang);
                allCodes = codes;

-               return codes;
+               for (std::vector<string>::const_iterator b = builtin.begin();
+                    b != builtin.end(); ++b)
+                       if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
+                               allCodes.push_back(*b);
+               if (All == true)
+                       return allCodes;
+               else
+                       return codes;

        }
 
        std::vector<string> const lang = _config->FindVector("Acquire::Languages");
        }
 
        std::vector<string> const lang = _config->FindVector("Acquire::Languages");


@@ -217,7 +272,14 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
                if (envShort != "en")
                        codes.push_back("en");
                allCodes = codes;
                if (envShort != "en")
                        codes.push_back("en");
                allCodes = codes;

-               return codes;
+               for (std::vector<string>::const_iterator b = builtin.begin();
+                    b != builtin.end(); ++b)
+                       if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
+                               allCodes.push_back(*b);
+               if (All == true)
+                       return allCodes;
+               else
+                       return codes;

        }
 
        // the configs define the order, so add the environment
        }
 
        // the configs define the order, so add the environment


@@ -245,6 +307,12 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
                        codes.push_back(*l);
                allCodes.push_back(*l);
        }
                        codes.push_back(*l);
                allCodes.push_back(*l);
        }

+
+       for (std::vector<string>::const_iterator b = builtin.begin();
+            b != builtin.end(); ++b)
+               if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
+                       allCodes.push_back(*b);
+

        if (All == true)
                return allCodes;
        else
        if (All == true)
                return allCodes;
        else