Fix #1783: repeated error message on console

[simgear.git] / simgear / misc / strutils.cxx

diff --git a/simgear/misc/strutils.cxx b/simgear/misc/strutils.cxx
index 10a4c67941cd1031c528464aa7ebb95ed3ad3109..86418b4c1daf665a78734e16644c1ca6fb419368 100644 (file)
--- a/simgear/misc/strutils.cxx
+++ b/simgear/misc/strutils.cxx
@@ -23,10 +23,12 @@
 #include <ctype.h>
 #include <cstring>
 #include <sstream>
+#include <algorithm>
 
 #include "strutils.hxx"
 
 #include <simgear/debug/logstream.hxx>
+#include <simgear/package/md5.h>
 
 using std::string;
 using std::vector;
@@ -35,6 +37,43 @@ using std::stringstream;
 namespace simgear {
     namespace strutils {
 
+       /*
+        * utf8ToLatin1() convert utf8 to latin, useful for accent character (i.e éâàîè...)
+        */
+       template <typename Iterator> size_t get_length (Iterator p) {
+               unsigned char c = static_cast<unsigned char> (*p);
+               if (c < 0x80) return 1;
+               else if (!(c & 0x20)) return 2;
+               else if (!(c & 0x10)) return 3;
+               else if (!(c & 0x08)) return 4;
+               else if (!(c & 0x04)) return 5;
+               else return 6;
+       }
+
+       typedef unsigned int value_type;
+       template <typename Iterator> value_type get_value (Iterator p) {
+               size_t len = get_length (p);
+               if (len == 1) return *p;
+               value_type res = static_cast<unsigned char> ( *p & (0xff >> (len + 1))) << ((len - 1) * 6 );
+               for (--len; len; --len) {
+                       value_type next_byte = static_cast<unsigned char> (*(++p)) - 0x80;
+                       if (next_byte & 0xC0) return 0x00ffffff; // invalid UTF-8
+                       res |= next_byte << ((len - 1) * 6);
+                       }
+               return res;
+       }
+
+       string utf8ToLatin1( string& s_utf8 ) {
+               string s_latin1;
+               for (string::iterator p = s_utf8.begin(); p != s_utf8.end(); ++p) {
+                       value_type value = get_value<string::iterator&>(p);
+                       if (value > 0x10ffff) return s_utf8; // invalid UTF-8: guess that the input was already Latin-1
+                       if (value > 0xff) SG_LOG(SG_IO, SG_WARN, "utf8ToLatin1: wrong char value: " << value);
+                       s_latin1 += static_cast<char>(value);
+               }
+               return s_latin1;
+       }
+
        /**
         * 
         */
@@ -305,26 +344,51 @@ namespace simgear {
       return rslt;
     }
 
+    string lowercase(const string &s) {
+      string rslt(s);
+      for(string::iterator p = rslt.begin(); p != rslt.end(); p++){
+        *p = tolower(*p);
+      }
+      return rslt;
+    }
+
+    void lowercase(string &s) {
+      for(string::iterator p = s.begin(); p != s.end(); p++){
+        *p = tolower(*p);
+      }
+    }
+    
+#if defined(SG_WINDOWS)
+
+#include <windows.h>
+    
+static WCharVec convertMultiByteToWString(DWORD encoding, const std::string& a)
+{
+    WCharVec result;
+    DWORD flags = 0;
+    int requiredWideChars = MultiByteToWideChar(encoding, flags, 
+                        a.c_str(), a.size(),
+                        NULL, 0);
+    result.resize(requiredWideChars);
+    MultiByteToWideChar(encoding, flags, a.c_str(), a.size(),
+                        result.data(), result.size());
+    return result;
+}
+
+WCharVec convertUtf8ToWString(const std::string& a)
+{
+    return convertMultiByteToWString(CP_UTF8, a);
+}
 
-#ifdef SG_WINDOWS
-    #include <windows.h>
 #endif
-        
+
 std::string convertWindowsLocal8BitToUtf8(const std::string& a)
 {
 #ifdef SG_WINDOWS
     DWORD flags = 0;
-    std::vector<wchar_t> wideString;
-
-    // call to query transform size
-    int requiredWideChars = MultiByteToWideChar(CP_ACP, flags, a.c_str(), a.size(),
-                        NULL, 0);
-    // allocate storage and call for real
-    wideString.resize(requiredWideChars);
-    MultiByteToWideChar(CP_ACP, flags, a.c_str(), a.size(),
-                        wideString.data(), wideString.size());
-    
-    // now convert back down to UTF-8
+    WCharVec wideString = convertMultiByteToWString(CP_ACP, a);
+   
+    // convert down to UTF-8
     std::vector<char> result;
     int requiredUTF8Chars = WideCharToMultiByte(CP_UTF8, flags,
                                                 wideString.data(), wideString.size(),
@@ -339,6 +403,32 @@ std::string convertWindowsLocal8BitToUtf8(const std::string& a)
 #endif
 }
 
+//------------------------------------------------------------------------------
+std::string md5(const unsigned char* data, size_t num)
+{
+  SG_MD5_CTX md5_ctx;
+  SG_MD5Init(&md5_ctx);
+  SG_MD5Update(&md5_ctx, data, num);
+
+  unsigned char digest[MD5_DIGEST_LENGTH];
+  SG_MD5Final(digest, &md5_ctx);
+
+  return encodeHex(digest, MD5_DIGEST_LENGTH);
+}
+
+//------------------------------------------------------------------------------
+std::string md5(const char* data, size_t num)
+{
+  return md5(reinterpret_cast<const unsigned char*>(data), num);
+}
+
+//------------------------------------------------------------------------------
+std::string md5(const std::string& str)
+{
+  return md5(reinterpret_cast<const unsigned char*>(str.c_str()), str.size());
+}
+
+//------------------------------------------------------------------------------
 static const std::string base64_chars =
 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 "abcdefghijklmnopqrstuvwxyz"
@@ -418,28 +508,24 @@ void decodeBase64(const std::string& encoded_string, std::vector<unsigned char>&
   }
 }  
 
+//------------------------------------------------------------------------------
 const char hexChar[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
 std::string encodeHex(const std::string& bytes)
 {
-  std::string hex;
-  size_t count = bytes.size();
-  for (unsigned int i=0; i<count;++i) {
-      unsigned char c = bytes[i];
-      hex.push_back(hexChar[c >> 4]);
-      hex.push_back(hexChar[c & 0x0f]);
-  }
-  
-  return hex;
+  return encodeHex(
+    reinterpret_cast<const unsigned char*>(bytes.c_str()),
+    bytes.size()
+  );
 }
 
 std::string encodeHex(const unsigned char* rawBytes, unsigned int length)
 {
-  std::string hex;
+  std::string hex(length * 2, '\0');
   for (unsigned int i=0; i<length;++i) {
       unsigned char c = *rawBytes++;
-      hex.push_back(hexChar[c >> 4]);
-      hex.push_back(hexChar[c & 0x0f]);
+      hex[i * 2] = hexChar[c >> 4];
+      hex[i * 2 + 1] = hexChar[c & 0x0f];
   }
   
   return hex;