Added utf-8 text stamp

Author: nataraj-hates-MS-for-stealing-github

include/blobstamper/stamp_text.h

@@ -40,6 +40,14 @@ class StampStringASCII: public StampBaseStr
     std::string ExtractStr(std::shared_ptr<Blob> blob) override;
 };
 
+class StampStringUTF8: public StampBaseStr
+{
+  public:
+    virtual int minSize() override { return  3; }
+    virtual int maxSize() override { return -1; }
+    std::string ExtractStr(std::shared_ptr<Blob> blob) override;
+};
+
 template<class T> class StampText: public GalleyVectorStrStampBase<T>
 {
   public:

src/stamp_text.cpp

@@ -54,3 +54,139 @@ StampStringASCII::ExtractStr(std::shared_ptr<Blob> blob)
     return res;
 }
 
+// FIXME: translate into English
+
+/* Эта функция "нормализует" три байта до utf-32 символа. */
+
+/* В utf-32 для кодировки одного символа используется три байта, четвертый всегда не используется */
+/* Первый и второй байт при этом используется полностью, а третий принимает значение от 0x00 до 0x10 */
+
+/*
+ * Нам надо нормолизовать первые три байта так, чтобы нормализованные значения были распределены равномерно
+ * если нормализованные данные были распределены равномерно, или блико к тому. Проблема в том, как равномерно
+ * распределить третий байт. Для значений 0x00..0x0F можно добиться равномерного распредеоения обнулив старшие
+ * 4 бита. Тогда вероятность каждого из значений бует 1/16
+ * Но у нас еще есть 0x10 который нельзя получить откидыванием бит, но который нам тоже нужен. При этом вероятонстью
+ * равной или схожей с 0x00..0x0F.
+ * Поэтому мы если старшие четыре бита принимают значение 0xF, то мы будем считать, что результат у нас 0x10. Вероятнсть этого 1/16
+ * Во всех остальных случаях будем возвращать значение младших бит. За счет вышеуказанного кейса вероятность каждого значения станет 1/16-1/256
+ * 1/256 -- это тот случай когда старшие четыре бита приняли значение 0xF
+ * Будем считать это распредеделение вероятностей достаточно равномерным для наших задач
+ */
+
+/*inline*/ uint32_t
+ThreeBytesToUtf32UInt(char *buf)
+{
+  uint32_t res = 0;
+  char * res_buf = (char *) &res;
+  res_buf[3] = 0; // Старший байт всегда ноль
+  res_buf[1] = buf[1];
+  res_buf[0] = buf[0];
+
+  if ( (buf[2] & 0xF0) == 0xF0) // вероятность этого 1/16
+  {
+    res_buf[2] = 0x10;
+  } else
+  {
+    res_buf[2] = buf[2] & 0x0F;  // Значения от 0 до 0x0F, вероятность каждого из них 1/16 - 1/256 (с учетом предыдущей ветки if'а)
+  }
+  if ( (res_buf[2] == 0) && ((res_buf[1] & 0xF8) == 0xD8))  // 0x0000FyXX y=8..F, X=0..F
+  {
+    // Это суррогатные UTF-16 символы нулевого плейна которые в одиночку встречаться не должны. https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates
+    // Заменяем их на подчеркивание
+    res_buf[1] = 0;
+  res_buf[0] = '_';
+  }
+  return res;
+}
+
+size_t
+append_with_utf8(unsigned char * buf, uint32_t c32)
+{
+  // check if sum in ascii diapazone
+  if(c32 <= 0x7F)
+  {
+    buf[0] = c32 & 0x7F;
+    return 1;
+  }
+
+  // if contains 2 bytes
+  if(c32 <= 0x7FF)
+  {
+    // get 1st byte
+    buf[0] = 6 << 5;
+    buf[0] += c32 >> 6;
+    // get 2nd byte
+    buf[1] = 2 << 6;
+    buf[1] += c32 & 0x3f;
+  return 2;
+  }
+
+  // if contains 3 bytes
+  if(c32 <= 0xffff)
+  {
+    buf[0] = 0xe << 4;
+    buf[0] += c32 >> 0xc;
+
+    buf[1] = 2 << 6;
+    buf[1] += (c32 >> 6) & 0x3f;
+
+    buf[2] = 2 << 6;
+    buf[2] += c32 & 0x3f;
+    return 3;
+  }
+
+  // if contains 4 bytes
+  if(c32 <= 0x10ffff)
+  {
+    buf[0] = 0x1e << 3;
+    buf[0] += (c32 >> 0x12) & 7;
+
+    buf[1] = 2 << 6;
+    buf[1] += (c32 >> 0xc) & 0x3f;
+
+    buf[2] = 2 << 6;
+    buf[2] += (c32 >> 6) & 0x3f;
+
+    buf[3] = 2 << 6;
+    buf[3] += c32 & 0x3f;
+    return 4;
+
+  } else {
+    /* FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME                FIXME  */
+    printf("error in parsing utf32, maybe its not utf32?");
+    return 0;
+  }
+}
+
+void
+utf24_to_utf8(char * in, size_t in_size, char **out, size_t *out_size)
+{
+  in_size = (in_size / 3) * 3;
+  *out_size = (in_size / 3) * 4 + 1; // +1 for final zero
+  *out = (char *) malloc(*out_size);
+
+  unsigned char * p = (unsigned char*) *out;
+  for(int i=0; i<in_size; i+=3)
+  {
+    uint32_t utf32 = ThreeBytesToUtf32UInt(in + i);
+    p = p + append_with_utf8(p, utf32);
+  }
+  *p = '\0'; // final zero
+}
+
+std::string
+StampStringUTF8::ExtractStr(std::shared_ptr<Blob> blob)
+{
+    std::vector<char> data = blob->Chop(minSize(), maxSize())->AsByteVector();
+
+    char * raw_res;
+    size_t raw_res_size;
+
+    utf24_to_utf8(&data[0], data.size(), &raw_res, &raw_res_size);
+
+    std::string res = raw_res;
+    free(raw_res);
+
+    return res;
+}

t/150-stamp_text.cpp

@@ -31,7 +31,7 @@ using namespace TAP;
 int
 main()
 {
-  TEST_START(5);
+  TEST_START(7);
   { /* 1..1 */
     char data[] = "папа\0мама\0бабушка\0дедушка\0братик\0сестричка";
     std::shared_ptr<Blob> blob = std::make_shared<Blob>(data, (sizeof data)-1);
@@ -51,28 +51,60 @@ main()
   }
 
   { /* 3..3 */
+    unsigned char data[] = {
+0x41, 0x00, 0x00, 0xB2, 0x03, 0x00, 0x14, 0x04, 0x00, 0x9C, 0x4E, 0x00, 0xC4, 0x30, 0x00, 0x36, 0xF4, 0x01, 0x23, 0x0E, 0x00, 0x0F, 0x00, 0x2C,
+0x03, 0x26, 0x00, 0xA9, 0xF4, 0x01, 0x19, 0x4E, 0x00, 0x1E, 0xF6, 0x01, 0x95, 0x0D, 0x00, 0xA5, 0x07, 0x00, 0x7D, 0x0F, 0x00, 0xD0, 0x05, 0x00,
+0x13, 0xF9, 0x01, 0xA9, 0x03, 0x00, 0x66, 0x5B, 0x00, 0x0A, 0x0E, 0x00, 0xE3, 0x53, 0x00, 0x30, 0x2B, 0x00, 0xB8, 0x30, 0x01, 0x7C, 0xF4, 0x01,
+0xA2, 0xF3, 0x01, 0x35, 0x0C, 0x00, 0x0D, 0x4E, 0x00, 0xB0, 0xF9, 0x01, 0xE6, 0x0C, 0x00, 0x8E, 0xF4, 0x01, 0xA9, 0x06, 0x00, 0xC7, 0xF4, 0x01,
+0x5C, 0x0B, 0x00, 0x4B, 0x4E, 0x00, 0xD2, 0x05, 0x00, 0x13, 0xF9, 0x01, 0x28, 0x0F, 0x00, 0xF4, 0xF3, 0x01, 0x95, 0x0B, 0x00, 0x80, 0x0D, 0x00,
+0x3E, 0xF3, 0x01, 0x7B,
+};
+    std::shared_ptr<Blob> blob = std::make_shared<Blob>((char *) data, (sizeof data)-1);
+    StampStringUTF8 stamp_str_ascii;
+    std::string s = stamp_str_ascii.ExtractStr(blob);
+    is(s, "AβД亜ツ🐶ร󀀏☃💩丙😞ඕޥཽא🤓Ω学ช口⬰𓂸👼🎢వ不🦰೦💎ک📇ଡ଼之ג🤓༨🏴க඀🌾",
+       "StampTextUTF8");
+  }
+
+  { /* 4..4 */
     char data[] = "dad\0mam\0granddad\0grandmam\0brother\0sister";
     std::shared_ptr<Blob> blob = std::make_shared<Blob>(data, (sizeof data)-1);
     StampText<StampStringLatin1> stamp;
     std::string s = stamp.ExtractStr(blob);
     is(s, "d dad gra n dmam broth er siste", "StampText<StampStringLatin1>");
   }
 
-  { /* 4..4 */
+  { /* 5..5 */
     char data[] = "abcdef" "abcdef" "ABCDEF" "012345";
     std::shared_ptr<Blob> blob = std::make_shared<Blob>(data, (sizeof data)-1);
     StampText<StampDictLCAlphaSmall> stamp;
     std::string s = stamp.ExtractStr(blob);
     is(s, "gleam godfather graffiti greened grouping gunshots gleam godfather graffiti greened grouping gunshots dismally dissented divested doorstep dread drunks convertors corpulent counterparts cranking crippled crusades", "StampText<StampDictLCAlphaSmall>");
   }
 
-  { /* 5..5 */
+  { /* 6..6 */
     char data[] = "Некоторый текст написанный русскими буквами в кодировке utf-8";
     std::shared_ptr<Blob> blob = std::make_shared<Blob>(data, (sizeof data)-1);
     StampText<StampStringASCII> stamp;
     std::string s = stamp.ExtractStr(blob);
     is(s, "P9  Q  Q\x3Q \x1Q \x1P: P8 P<P 8 P 1Q\x3 P:P 2P0 P<P 8 P 2  P: P>P 4P8 Q  P>P 2P :P5  ut f-8", "StampText<StampStringASCII>");
   }
 
+  { /* 7..7 */
+    unsigned char data[] = {
+0x41, 0x00, 0x00, 0xB2, 0x03, 0x00, 0x14, 0x04, 0x00, 0x9C, 0x4E, 0x00, 0xC4, 0x30, 0x00, 0x36, 0xF4, 0x01, 0x23, 0x0E, 0x00, 0x0F, 0x00, 0x2C,
+0x03, 0x26, 0x00, 0xA9, 0xF4, 0x01, 0x19, 0x4E, 0x00, 0x1E, 0xF6, 0x01, 0x95, 0x0D, 0x00, 0xA5, 0x07, 0x00, 0x7D, 0x0F, 0x00, 0xD0, 0x05, 0x00,
+0x13, 0xF9, 0x01, 0xA9, 0x03, 0x00, 0x66, 0x5B, 0x00, 0x0A, 0x0E, 0x00, 0xE3, 0x53, 0x00, 0x30, 0x2B, 0x00, 0xB8, 0x30, 0x01, 0x7C, 0xF4, 0x01,
+0xA2, 0xF3, 0x01, 0x35, 0x0C, 0x00, 0x0D, 0x4E, 0x00, 0xB0, 0xF9, 0x01, 0xE6, 0x0C, 0x00, 0x8E, 0xF4, 0x01, 0xA9, 0x06, 0x00, 0xC7, 0xF4, 0x01,
+0x5C, 0x0B, 0x00, 0x4B, 0x4E, 0x00, 0xD2, 0x05, 0x00, 0x13, 0xF9, 0x01, 0x28, 0x0F, 0x00, 0xF4, 0xF3, 0x01, 0x95, 0x0B, 0x00, 0x80, 0x0D, 0x00,
+0x3E, 0xF3, 0x01, 0x7B,
+};
+    std::shared_ptr<Blob> blob = std::make_shared<Blob>((char *)data, (sizeof data)-1);
+    StampText<StampStringUTF8> stamp;
+    std::string s = stamp.ExtractStr(blob);
+    is(s, "񀀃󀀄񀁎񠀰𰇴󰀎𲰀򐀦򐇴󠁎񐇶񐀍󐀇𰀅򐇹񠀃򠁛𰀎S򀀫󀄰𠇴񐇳󐀌N񠇹󠀌򐇴񰀆󀇴򰀋𠁎𰀅򀇹􀀏񐇳󠀍",
+        "StampText<StampStringUTF8>");
+  }
+
   TEST_END;
 }