power_play/src/base/base_uni.c

////////////////////////////////////////////////////////////
//~ Utf8

//- Decode

Utf8DecodeResult DecodeUtf8(String str)
{
  const u8 lengths[32] = {
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,2,2,2,2,3,3,4,5
  };

  Utf8DecodeResult result = Zi;
  u32 codepoint = U32Max;
  u32 advance = 0;
  if (str.len > 0)
  {
    u8 c0 = str.text[0];
    u8 utf8_len = lengths[c0 >> 3];

    advance = 1;
    switch (utf8_len)
    {
      default: break;

      case 1:
      {
        codepoint = c0;
      } break;

      case 2:
      {
        if (str.len >= 2)
        {
          u8 c1 = str.text[1];
          if (lengths[c1 >> 3] == 0)
          {
            codepoint  = (c1 & 0x3F) << 0;
            codepoint |= (c0 & 0x1F) << 6;
            advance = 2;
          }
        }
      } break;

      case 3:
      {
        if (str.len >= 3)
        {
          u8 c1 = str.text[1];
          u8 c2 = str.text[2];
          if (
            lengths[c1 >> 3] == 0 &&
            lengths[c2 >> 3] == 0
          )
          {
            codepoint  = (c2 & 0x3F) << 0;
            codepoint |= (c1 & 0x3F) << 6;
            codepoint |= (c0 & 0x0F) << 12;
            advance = 3;
          }
        }
      } break;

      case 4:
      {
        if (str.len >= 4)
        {
          u8 c1 = str.text[1];
          u8 c2 = str.text[2];
          u8 c3 = str.text[3];
          if (
            lengths[c1 >> 3] == 0 &&
            lengths[c2 >> 3] == 0 &&
            lengths[c3 >> 3] == 0
          )
          {
            codepoint  = (c3 & 0x3F) << 0;
            codepoint |= (c2 & 0x3F) << 6;
            codepoint |= (c1 & 0x3F) << 12;
            codepoint |= (c0 & 0x07) << 16;
            advance = 3;
          }
        }
      } break;
    }
  }

  result.advance8 = advance;
  result.codepoint = codepoint;
  return result;
}

//- Encode

Utf8EncodeResult EncodeUtf8(u32 codepoint)
{
  Utf8EncodeResult result = Zi;

  if (codepoint <= 0x7F)
  {
    result.count8 = 1;
    result.chars8[0] = codepoint;
  }
  else if (codepoint <= 0x7FF)
  {
    result.count8 = 2;
    result.chars8[1] = 0x80 | ((codepoint >> 0) & 0x3F);
    result.chars8[0] = 0xC0 | ((codepoint >> 6) & 0x1F);
  }
  else if (codepoint <= 0xFFFF)
  {
    result.count8 = 3;
    result.chars8[2] = 0x80 | ((codepoint >> 0) & 0x3F);
    result.chars8[1] = 0x80 | ((codepoint >> 6) & 0x3F);
    result.chars8[0] = 0xE0 | ((codepoint >> 12) & 0x0F);
  }
  else if (codepoint <= 0x10FFFF)
  {
    result.count8 = 4;
    result.chars8[3] = 0x80 | ((codepoint >> 0) & 0x3F);
    result.chars8[2] = 0x80 | ((codepoint >> 6) & 0x3F);
    result.chars8[1] = 0x80 | ((codepoint >> 12) & 0x3F);
    result.chars8[0] = 0xF0 | ((codepoint >> 18) & 0x07);
  }
  else
  {
    // Invalid codepoint
    result.count8 = 1;
    result.chars8[0] = '?';
  }

  return result;
}

////////////////////////////////////////////////////////////
//~ Utf16

//- Decode

Utf16DecodeResult DecodeUtf16(String16 str)
{
  Utf16DecodeResult result = Zi;
  u32 codepoint = U32Max;
  u32 advance = 0;

  if (str.len >= 1)
  {
    u16 c0 = str.text[0];
    codepoint = c0;
    advance = 1;
    if (str.len >= 2)
    {
      u16 c1 = str.text[1];
      if ((0xD800 <= c0 && c0 < 0xDC00) && (0xDC00 <= c1 && c1 < 0xE000))
      {
        codepoint = (c1 & 0x3FF) << 0;
        codepoint |= (c0 & 0x3FF) << 10;
        advance = 2;
      }
    }
  }

  result.advance16 = advance;
  result.codepoint = codepoint;
  return result;
}

//- Encode

Utf16EncodeResult EncodeUtf16(u32 codepoint)
{
  Utf16EncodeResult result = Zi;

  if (codepoint <= 0xFFFF)
  {
    result.count16 = 1;
    result.chars16[0] = codepoint;
  }
  else if (codepoint <= 0x10FFFF)
  {
    result.count16 = 2;
    result.chars16[1] = 0xDC00 | ((codepoint >> 0) & 0x3FF);
    result.chars16[0] = 0xD800 | ((codepoint >> 10) & 0x3FF);
  }
  else
  {
    // Invalid codepoint
    result.count16 = 1;
    result.chars16[0] = '?';
  }

  return result;
}

//- Surrogate check

b32 IsUtf16HighSurrogate(u16 c)
{
  return 0xD800 <= c && c < 0xDC00;
}

b32 IsUtf16LowSurrogate(u16 c)
{
  return 0xDC00 <= c && c < 0xE000;
}

////////////////////////////////////////////////////////////
//~ Utf32

//- Decode

Utf32DecodeResult DecodeUtf32(String32 str)
{
  Utf32DecodeResult result = Zi;
  u32 codepoint = U32Max;
  u32 advance = 0;

  if (str.len >= 1)
  {
    u32 c = str.text[0];
    advance = 1;
    if (c <= 0x10FFFF)
    {
      codepoint = c;
    }
  }

  result.advance32 = advance;
  result.codepoint = codepoint;
  return result;
}

//- Encode

Utf32EncodeResult EncodeUtf32(u32 codepoint)
{
  Utf32EncodeResult result = Zi;

  if (codepoint <= 0x10FFFF)
  {
    result.chars32 = codepoint;
  }
  else
  {
    // Invalid codepoint
    result.chars32 = '?';
  }

  return result;
}