charset.c 3.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156
  1. /*
  2. * charset conversion utils
  3. *
  4. * Copyright (c) 2017 Rob Clark
  5. *
  6. * SPDX-License-Identifier: GPL-2.0+
  7. */
  8. #include <charset.h>
  9. #include <malloc.h>
  10. /*
  11. * utf8/utf16 conversion mostly lifted from grub
  12. */
  13. size_t utf16_strlen(const uint16_t *in)
  14. {
  15. size_t i;
  16. for (i = 0; in[i]; i++);
  17. return i;
  18. }
  19. size_t utf16_strnlen(const uint16_t *in, size_t count)
  20. {
  21. size_t i;
  22. for (i = 0; count-- && in[i]; i++);
  23. return i;
  24. }
  25. uint16_t *utf16_strcpy(uint16_t *dest, const uint16_t *src)
  26. {
  27. uint16_t *tmp = dest;
  28. while ((*dest++ = *src++) != '\0')
  29. /* nothing */;
  30. return tmp;
  31. }
  32. uint16_t *utf16_strdup(const uint16_t *s)
  33. {
  34. uint16_t *new;
  35. if (!s || !(new = malloc((utf16_strlen(s) + 1) * 2)))
  36. return NULL;
  37. utf16_strcpy(new, s);
  38. return new;
  39. }
  40. /* Convert UTF-16 to UTF-8. */
  41. uint8_t *utf16_to_utf8(uint8_t *dest, const uint16_t *src, size_t size)
  42. {
  43. uint32_t code_high = 0;
  44. while (size--) {
  45. uint32_t code = *src++;
  46. if (code_high) {
  47. if (code >= 0xDC00 && code <= 0xDFFF) {
  48. /* Surrogate pair. */
  49. code = ((code_high - 0xD800) << 10) + (code - 0xDC00) + 0x10000;
  50. *dest++ = (code >> 18) | 0xF0;
  51. *dest++ = ((code >> 12) & 0x3F) | 0x80;
  52. *dest++ = ((code >> 6) & 0x3F) | 0x80;
  53. *dest++ = (code & 0x3F) | 0x80;
  54. } else {
  55. /* Error... */
  56. *dest++ = '?';
  57. /* *src may be valid. Don't eat it. */
  58. src--;
  59. }
  60. code_high = 0;
  61. } else {
  62. if (code <= 0x007F) {
  63. *dest++ = code;
  64. } else if (code <= 0x07FF) {
  65. *dest++ = (code >> 6) | 0xC0;
  66. *dest++ = (code & 0x3F) | 0x80;
  67. } else if (code >= 0xD800 && code <= 0xDBFF) {
  68. code_high = code;
  69. continue;
  70. } else if (code >= 0xDC00 && code <= 0xDFFF) {
  71. /* Error... */
  72. *dest++ = '?';
  73. } else if (code < 0x10000) {
  74. *dest++ = (code >> 12) | 0xE0;
  75. *dest++ = ((code >> 6) & 0x3F) | 0x80;
  76. *dest++ = (code & 0x3F) | 0x80;
  77. } else {
  78. *dest++ = (code >> 18) | 0xF0;
  79. *dest++ = ((code >> 12) & 0x3F) | 0x80;
  80. *dest++ = ((code >> 6) & 0x3F) | 0x80;
  81. *dest++ = (code & 0x3F) | 0x80;
  82. }
  83. }
  84. }
  85. return dest;
  86. }
  87. uint16_t *utf8_to_utf16(uint16_t *dest, const uint8_t *src, size_t size)
  88. {
  89. while (size--) {
  90. int extension_bytes;
  91. uint32_t code;
  92. extension_bytes = 0;
  93. if (*src <= 0x7f) {
  94. code = *src++;
  95. /* Exit on zero byte */
  96. if (!code)
  97. size = 0;
  98. } else if (*src <= 0xbf) {
  99. /* Illegal code */
  100. code = '?';
  101. } else if (*src <= 0xdf) {
  102. code = *src++ & 0x1f;
  103. extension_bytes = 1;
  104. } else if (*src <= 0xef) {
  105. code = *src++ & 0x0f;
  106. extension_bytes = 2;
  107. } else if (*src <= 0xf7) {
  108. code = *src++ & 0x07;
  109. extension_bytes = 3;
  110. } else {
  111. /* Illegal code */
  112. code = '?';
  113. }
  114. for (; extension_bytes && size; --size, --extension_bytes) {
  115. if ((*src & 0xc0) == 0x80) {
  116. code <<= 6;
  117. code |= *src++ & 0x3f;
  118. } else {
  119. /* Illegal code */
  120. code = '?';
  121. ++src;
  122. --size;
  123. break;
  124. }
  125. }
  126. if (code < 0x10000) {
  127. *dest++ = code;
  128. } else {
  129. /*
  130. * Simplified expression for
  131. * (((code - 0x10000) >> 10) & 0x3ff) | 0xd800
  132. */
  133. *dest++ = (code >> 10) + 0xd7c0;
  134. *dest++ = (code & 0x3ff) | 0xdc00;
  135. }
  136. }
  137. return dest;
  138. }