Merge branch 'debian/sid' into debian/experimental

[apt.git] / apt-pkg / contrib / strutl.cc

diff --git a/apt-pkg/contrib/strutl.cc b/apt-pkg/contrib/strutl.cc
index 9f794927d0e3280f1a3f9e5072b28c0c896d533a..0f48860b1864a0ee706c289b9d016ee326f92dda 100644 (file)
--- a/apt-pkg/contrib/strutl.cc
+++ b/apt-pkg/contrib/strutl.cc
@@ -21,6 +21,11 @@
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/error.h>
 
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/error.h>
 

+#include <stddef.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string>
+#include <vector>

 #include <ctype.h>
 #include <string.h>
 #include <sstream>
 #include <ctype.h>
 #include <string.h>
 #include <sstream>


@@ -33,9 +38,9 @@
 #include <iconv.h>
 
 #include <apti18n.h>
 #include <iconv.h>
 
 #include <apti18n.h>

-
-using namespace std;

                                                                        /*}}}*/
                                                                        /*}}}*/

+using namespace std;
+

 // Strip - Remove white space from the front and back of a string       /*{{{*/
 // ---------------------------------------------------------------------
 namespace APT {
 // Strip - Remove white space from the front and back of a string       /*{{{*/
 // ---------------------------------------------------------------------
 namespace APT {


@@ -49,6 +54,14 @@ std::string Strip(const std::string &s)
    size_t end = s.find_last_not_of(" \t\n");
    return s.substr(start, end-start+1);
 }
    size_t end = s.find_last_not_of(" \t\n");
    return s.substr(start, end-start+1);
 }

+
+bool Endswith(const std::string &s, const std::string &end)
+{
+   if (end.size() > s.size())
+      return false;
+   return (s.substr(s.size() - end.size(), s.size()) == end);
+}
+

 }
 }
                                                                        /*}}}*/
 }
 }
                                                                        /*}}}*/


@@ -145,7 +158,7 @@ char *_strrstrip(char *String)
    End++;
    *End = 0;
    return String;
    End++;
    *End = 0;
    return String;

-};
+}

                                                                        /*}}}*/
 // strtabexpand - Converts tabs into 8 spaces                          /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // strtabexpand - Converts tabs into 8 spaces                          /*{{{*/
 // ---------------------------------------------------------------------


@@ -418,26 +431,33 @@ string TimeToStr(unsigned long Sec)
                                                                        /*}}}*/
 // SubstVar - Substitute a string for another string                   /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // SubstVar - Substitute a string for another string                   /*{{{*/
 // ---------------------------------------------------------------------

-/* This replaces all occurances of Subst with Contents in Str. */
+/* This replaces all occurrences of Subst with Contents in Str. */

 string SubstVar(const string &Str,const string &Subst,const string &Contents)
 {
 string SubstVar(const string &Str,const string &Subst,const string &Contents)
 {

+   if (Subst.empty() == true)
+      return Str;
+

    string::size_type Pos = 0;
    string::size_type OldPos = 0;
    string Temp;
    string::size_type Pos = 0;
    string::size_type OldPos = 0;
    string Temp;

-   
-   while (OldPos < Str.length() && 
+
+   while (OldPos < Str.length() &&

          (Pos = Str.find(Subst,OldPos)) != string::npos)
    {
          (Pos = Str.find(Subst,OldPos)) != string::npos)
    {

-      Temp += string(Str,OldPos,Pos) + Contents;
-      OldPos = Pos + Subst.length();      
+      if (OldPos != Pos)
+        Temp.append(Str, OldPos, Pos - OldPos);
+      if (Contents.empty() == false)
+        Temp.append(Contents);
+      OldPos = Pos + Subst.length();

    }
    }

-   
+

    if (OldPos == 0)
       return Str;
    if (OldPos == 0)
       return Str;

-   
+
+   if (OldPos >= Str.length())
+      return Temp;

    return Temp + string(Str,OldPos);
 }
    return Temp + string(Str,OldPos);
 }

-

 string SubstVar(string Str,const struct SubstVar *Vars)
 {
    for (; Vars->Subst != 0; Vars++)
 string SubstVar(string Str,const struct SubstVar *Vars)
 {
    for (; Vars->Subst != 0; Vars++)


@@ -918,7 +938,7 @@ bool FTPMDTMStrToTime(const char* const str,time_t &time)
                                                                        /*}}}*/
 // StrToTime - Converts a string into a time_t                         /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // StrToTime - Converts a string into a time_t                         /*{{{*/
 // ---------------------------------------------------------------------

-/* This handles all 3 populare time formats including RFC 1123, RFC 1036
+/* This handles all 3 popular time formats including RFC 1123, RFC 1036

    and the C library asctime format. It requires the GNU library function
    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
    reason the C library does not provide any such function :< This also
    and the C library asctime format. It requires the GNU library function
    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
    reason the C library does not provide any such function :< This also


@@ -1026,7 +1046,7 @@ bool StrToNum(const char *Str,unsigned long long &Res,unsigned Len,unsigned Base
 // ---------------------------------------------------------------------
 /* This is used in decoding the 256bit encoded fixed length fields in
    tar files */
 // ---------------------------------------------------------------------
 /* This is used in decoding the 256bit encoded fixed length fields in
    tar files */

-bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
+bool Base256ToNum(const char *Str,unsigned long long &Res,unsigned int Len)

 {
    if ((Str[0] & 0x80) == 0)
       return false;
 {
    if ((Str[0] & 0x80) == 0)
       return false;


@@ -1039,6 +1059,23 @@ bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
    }
 }
                                                                        /*}}}*/
    }
 }
                                                                        /*}}}*/

+// Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
+// ---------------------------------------------------------------------
+/* This is used in decoding the 256bit encoded fixed length fields in
+   tar files */
+bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
+{
+   unsigned long long Num;
+   bool rc;
+
+   rc = Base256ToNum(Str, Num, Len);
+   Res = Num;
+   if (Res != Num)
+      return false;
+
+   return rc;
+}
+                                                                       /*}}}*/

 // HexDigit - Convert a hex character into an integer                  /*{{{*/
 // ---------------------------------------------------------------------
 /* Helper for Hex2Num */
 // HexDigit - Convert a hex character into an integer                  /*{{{*/
 // ---------------------------------------------------------------------
 /* Helper for Hex2Num */


@@ -1122,9 +1159,11 @@ bool TokSplitString(char Tok,char *Input,char **List,
    also, but the advantage is that we have an iteratable vector */
 vector<string> VectorizeString(string const &haystack, char const &split)
 {
    also, but the advantage is that we have an iteratable vector */
 vector<string> VectorizeString(string const &haystack, char const &split)
 {

+   vector<string> exploded;
+   if (haystack.empty() == true)
+      return exploded;

    string::const_iterator start = haystack.begin();
    string::const_iterator end = start;
    string::const_iterator start = haystack.begin();
    string::const_iterator end = start;

-   vector<string> exploded;

    do {
       for (; end != haystack.end() && *end != split; ++end);
       exploded.push_back(string(start, end));
    do {
       for (; end != haystack.end() && *end != split; ++end);
       exploded.push_back(string(start, end));


@@ -1174,7 +1213,7 @@ unsigned long RegexChoice(RxChoiceList *Rxs,const char **ListBegin,
       R->Hit = false;
 
    unsigned long Hits = 0;
       R->Hit = false;
 
    unsigned long Hits = 0;

-   for (; ListBegin != ListEnd; ListBegin++)
+   for (; ListBegin < ListEnd; ++ListBegin)

    {
       // Check if the name is a regex
       const char *I;
    {
       // Check if the name is a regex
       const char *I;


@@ -1305,7 +1344,7 @@ string StripEpoch(const string &VerStr)
 // tolower_ascii - tolower() function that ignores the locale          /*{{{*/
 // ---------------------------------------------------------------------
 /* This little function is the most called method we have and tries
 // tolower_ascii - tolower() function that ignores the locale          /*{{{*/
 // ---------------------------------------------------------------------
 /* This little function is the most called method we have and tries

-   therefore to do the absolut minimum - and is noteable faster than
+   therefore to do the absolut minimum - and is notable faster than

    standard tolower/toupper and as a bonus avoids problems with different
    locales - we only operate on ascii chars anyway. */
 int tolower_ascii(int const c)
    standard tolower/toupper and as a bonus avoids problems with different
    locales - we only operate on ascii chars anyway. */
 int tolower_ascii(int const c)


@@ -1316,9 +1355,9 @@ int tolower_ascii(int const c)
 }
                                                                        /*}}}*/
 
 }
                                                                        /*}}}*/
 

-// CheckDomainList - See if Host is in a , seperate list               /*{{{*/
+// CheckDomainList - See if Host is in a , separate list               /*{{{*/

 // ---------------------------------------------------------------------
 // ---------------------------------------------------------------------

-/* The domain list is a comma seperate list of domains that are suffix
+/* The domain list is a comma separate list of domains that are suffix

    matched against the argument */
 bool CheckDomainList(const string &Host,const string &List)
 {
    matched against the argument */
 bool CheckDomainList(const string &Host,const string &List)
 {