charset.c 9.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * charset conversion utils
  4. *
  5. * Copyright (c) 2017 Rob Clark
  6. */
  7. #include <common.h>
  8. #include <charset.h>
  9. #include <capitalization.h>
  10. #include <cp437.h>
  11. #include <efi_loader.h>
  12. #include <errno.h>
  13. #include <malloc.h>
  14. /**
  15. * codepage_437 - Unicode to codepage 437 translation table
  16. */
  17. const u16 codepage_437[128] = CP437;
  18. static struct capitalization_table capitalization_table[] =
  19. #ifdef CONFIG_EFI_UNICODE_CAPITALIZATION
  20. UNICODE_CAPITALIZATION_TABLE;
  21. #elif CONFIG_FAT_DEFAULT_CODEPAGE == 1250
  22. CP1250_CAPITALIZATION_TABLE;
  23. #else
  24. CP437_CAPITALIZATION_TABLE;
  25. #endif
  26. /**
  27. * get_code() - read Unicode code point from UTF-8 stream
  28. *
  29. * @read_u8: - stream reader
  30. * @src: - string buffer passed to stream reader, optional
  31. * Return: - Unicode code point, or -1
  32. */
  33. static int get_code(u8 (*read_u8)(void *data), void *data)
  34. {
  35. s32 ch = 0;
  36. ch = read_u8(data);
  37. if (!ch)
  38. return 0;
  39. if (ch >= 0xc2 && ch <= 0xf4) {
  40. int code = 0;
  41. if (ch >= 0xe0) {
  42. if (ch >= 0xf0) {
  43. /* 0xf0 - 0xf4 */
  44. ch &= 0x07;
  45. code = ch << 18;
  46. ch = read_u8(data);
  47. if (ch < 0x80 || ch > 0xbf)
  48. goto error;
  49. ch &= 0x3f;
  50. } else {
  51. /* 0xe0 - 0xef */
  52. ch &= 0x0f;
  53. }
  54. code += ch << 12;
  55. if ((code >= 0xD800 && code <= 0xDFFF) ||
  56. code >= 0x110000)
  57. goto error;
  58. ch = read_u8(data);
  59. if (ch < 0x80 || ch > 0xbf)
  60. goto error;
  61. }
  62. /* 0xc0 - 0xdf or continuation byte (0x80 - 0xbf) */
  63. ch &= 0x3f;
  64. code += ch << 6;
  65. ch = read_u8(data);
  66. if (ch < 0x80 || ch > 0xbf)
  67. goto error;
  68. ch &= 0x3f;
  69. ch += code;
  70. } else if (ch >= 0x80) {
  71. goto error;
  72. }
  73. return ch;
  74. error:
  75. return -1;
  76. }
  77. /**
  78. * read_string() - read byte from character string
  79. *
  80. * @data: - pointer to string
  81. * Return: - byte read
  82. *
  83. * The string pointer is incremented if it does not point to '\0'.
  84. */
  85. static u8 read_string(void *data)
  86. {
  87. const char **src = (const char **)data;
  88. u8 c;
  89. if (!src || !*src || !**src)
  90. return 0;
  91. c = **src;
  92. ++*src;
  93. return c;
  94. }
  95. /**
  96. * read_console() - read byte from console
  97. *
  98. * @data - not used, needed to match interface
  99. * Return: - byte read or 0 on error
  100. */
  101. static u8 read_console(void *data)
  102. {
  103. int ch;
  104. ch = getchar();
  105. if (ch < 0)
  106. ch = 0;
  107. return ch;
  108. }
  109. int console_read_unicode(s32 *code)
  110. {
  111. for (;;) {
  112. s32 c;
  113. if (!tstc()) {
  114. /* No input available */
  115. return 1;
  116. }
  117. /* Read Unicode code */
  118. c = get_code(read_console, NULL);
  119. if (c > 0) {
  120. *code = c;
  121. return 0;
  122. }
  123. }
  124. }
  125. s32 utf8_get(const char **src)
  126. {
  127. return get_code(read_string, src);
  128. }
  129. int utf8_put(s32 code, char **dst)
  130. {
  131. if (!dst || !*dst)
  132. return -1;
  133. if ((code >= 0xD800 && code <= 0xDFFF) || code >= 0x110000)
  134. return -1;
  135. if (code <= 0x007F) {
  136. **dst = code;
  137. } else {
  138. if (code <= 0x07FF) {
  139. **dst = code >> 6 | 0xC0;
  140. } else {
  141. if (code < 0x10000) {
  142. **dst = code >> 12 | 0xE0;
  143. } else {
  144. **dst = code >> 18 | 0xF0;
  145. ++*dst;
  146. **dst = (code >> 12 & 0x3F) | 0x80;
  147. }
  148. ++*dst;
  149. **dst = (code >> 6 & 0x3F) | 0x80;
  150. }
  151. ++*dst;
  152. **dst = (code & 0x3F) | 0x80;
  153. }
  154. ++*dst;
  155. return 0;
  156. }
  157. size_t utf8_utf16_strnlen(const char *src, size_t count)
  158. {
  159. size_t len = 0;
  160. for (; *src && count; --count) {
  161. s32 code = utf8_get(&src);
  162. if (!code)
  163. break;
  164. if (code < 0) {
  165. /* Reserve space for a replacement character */
  166. len += 1;
  167. } else if (code < 0x10000) {
  168. len += 1;
  169. } else {
  170. len += 2;
  171. }
  172. }
  173. return len;
  174. }
  175. int utf8_utf16_strncpy(u16 **dst, const char *src, size_t count)
  176. {
  177. if (!src || !dst || !*dst)
  178. return -1;
  179. for (; count && *src; --count) {
  180. s32 code = utf8_get(&src);
  181. if (code < 0)
  182. code = '?';
  183. utf16_put(code, dst);
  184. }
  185. **dst = 0;
  186. return 0;
  187. }
  188. s32 utf16_get(const u16 **src)
  189. {
  190. s32 code, code2;
  191. if (!src || !*src)
  192. return -1;
  193. if (!**src)
  194. return 0;
  195. code = **src;
  196. ++*src;
  197. if (code >= 0xDC00 && code <= 0xDFFF)
  198. return -1;
  199. if (code >= 0xD800 && code <= 0xDBFF) {
  200. if (!**src)
  201. return -1;
  202. code &= 0x3ff;
  203. code <<= 10;
  204. code += 0x10000;
  205. code2 = **src;
  206. ++*src;
  207. if (code2 <= 0xDC00 || code2 >= 0xDFFF)
  208. return -1;
  209. code2 &= 0x3ff;
  210. code += code2;
  211. }
  212. return code;
  213. }
  214. int utf16_put(s32 code, u16 **dst)
  215. {
  216. if (!dst || !*dst)
  217. return -1;
  218. if ((code >= 0xD800 && code <= 0xDFFF) || code >= 0x110000)
  219. return -1;
  220. if (code < 0x10000) {
  221. **dst = code;
  222. } else {
  223. code -= 0x10000;
  224. **dst = code >> 10 | 0xD800;
  225. ++*dst;
  226. **dst = (code & 0x3ff) | 0xDC00;
  227. }
  228. ++*dst;
  229. return 0;
  230. }
  231. size_t utf16_strnlen(const u16 *src, size_t count)
  232. {
  233. size_t len = 0;
  234. for (; *src && count; --count) {
  235. s32 code = utf16_get(&src);
  236. if (!code)
  237. break;
  238. /*
  239. * In case of an illegal sequence still reserve space for a
  240. * replacement character.
  241. */
  242. ++len;
  243. }
  244. return len;
  245. }
  246. size_t utf16_utf8_strnlen(const u16 *src, size_t count)
  247. {
  248. size_t len = 0;
  249. for (; *src && count; --count) {
  250. s32 code = utf16_get(&src);
  251. if (!code)
  252. break;
  253. if (code < 0)
  254. /* Reserve space for a replacement character */
  255. len += 1;
  256. else if (code < 0x80)
  257. len += 1;
  258. else if (code < 0x800)
  259. len += 2;
  260. else if (code < 0x10000)
  261. len += 3;
  262. else
  263. len += 4;
  264. }
  265. return len;
  266. }
  267. int utf16_utf8_strncpy(char **dst, const u16 *src, size_t count)
  268. {
  269. if (!src || !dst || !*dst)
  270. return -1;
  271. for (; count && *src; --count) {
  272. s32 code = utf16_get(&src);
  273. if (code < 0)
  274. code = '?';
  275. utf8_put(code, dst);
  276. }
  277. **dst = 0;
  278. return 0;
  279. }
  280. s32 utf_to_lower(const s32 code)
  281. {
  282. struct capitalization_table *pos = capitalization_table;
  283. s32 ret = code;
  284. if (code <= 0x7f) {
  285. if (code >= 'A' && code <= 'Z')
  286. ret += 0x20;
  287. return ret;
  288. }
  289. for (; pos->upper; ++pos) {
  290. if (pos->upper == code) {
  291. ret = pos->lower;
  292. break;
  293. }
  294. }
  295. return ret;
  296. }
  297. s32 utf_to_upper(const s32 code)
  298. {
  299. struct capitalization_table *pos = capitalization_table;
  300. s32 ret = code;
  301. if (code <= 0x7f) {
  302. if (code >= 'a' && code <= 'z')
  303. ret -= 0x20;
  304. return ret;
  305. }
  306. for (; pos->lower; ++pos) {
  307. if (pos->lower == code) {
  308. ret = pos->upper;
  309. break;
  310. }
  311. }
  312. return ret;
  313. }
  314. /*
  315. * u16_strncmp() - compare two u16 string
  316. *
  317. * @s1: first string to compare
  318. * @s2: second string to compare
  319. * @n: maximum number of u16 to compare
  320. * Return: 0 if the first n u16 are the same in s1 and s2
  321. * < 0 if the first different u16 in s1 is less than the
  322. * corresponding u16 in s2
  323. * > 0 if the first different u16 in s1 is greater than the
  324. * corresponding u16 in s2
  325. */
  326. int u16_strncmp(const u16 *s1, const u16 *s2, size_t n)
  327. {
  328. int ret = 0;
  329. for (; n; --n, ++s1, ++s2) {
  330. ret = *s1 - *s2;
  331. if (ret || !*s1)
  332. break;
  333. }
  334. return ret;
  335. }
  336. size_t u16_strlen(const void *in)
  337. {
  338. const char *pos = in;
  339. size_t ret;
  340. for (; pos[0] || pos[1]; pos += 2)
  341. ;
  342. ret = pos - (char *)in;
  343. ret >>= 1;
  344. return ret;
  345. }
  346. size_t __efi_runtime u16_strnlen(const u16 *in, size_t count)
  347. {
  348. size_t i;
  349. for (i = 0; count-- && in[i]; i++);
  350. return i;
  351. }
  352. size_t u16_strsize(const void *in)
  353. {
  354. return (u16_strlen(in) + 1) * sizeof(u16);
  355. }
  356. u16 *u16_strcpy(u16 *dest, const u16 *src)
  357. {
  358. u16 *tmp = dest;
  359. for (;; dest++, src++) {
  360. *dest = *src;
  361. if (!*src)
  362. break;
  363. }
  364. return tmp;
  365. }
  366. u16 *u16_strdup(const void *src)
  367. {
  368. u16 *new;
  369. size_t len;
  370. if (!src)
  371. return NULL;
  372. len = (u16_strlen(src) + 1) * sizeof(u16);
  373. new = malloc(len);
  374. if (!new)
  375. return NULL;
  376. memcpy(new, src, len);
  377. return new;
  378. }
  379. /* Convert UTF-16 to UTF-8. */
  380. uint8_t *utf16_to_utf8(uint8_t *dest, const uint16_t *src, size_t size)
  381. {
  382. uint32_t code_high = 0;
  383. while (size--) {
  384. uint32_t code = *src++;
  385. if (code_high) {
  386. if (code >= 0xDC00 && code <= 0xDFFF) {
  387. /* Surrogate pair. */
  388. code = ((code_high - 0xD800) << 10) + (code - 0xDC00) + 0x10000;
  389. *dest++ = (code >> 18) | 0xF0;
  390. *dest++ = ((code >> 12) & 0x3F) | 0x80;
  391. *dest++ = ((code >> 6) & 0x3F) | 0x80;
  392. *dest++ = (code & 0x3F) | 0x80;
  393. } else {
  394. /* Error... */
  395. *dest++ = '?';
  396. /* *src may be valid. Don't eat it. */
  397. src--;
  398. }
  399. code_high = 0;
  400. } else {
  401. if (code <= 0x007F) {
  402. *dest++ = code;
  403. } else if (code <= 0x07FF) {
  404. *dest++ = (code >> 6) | 0xC0;
  405. *dest++ = (code & 0x3F) | 0x80;
  406. } else if (code >= 0xD800 && code <= 0xDBFF) {
  407. code_high = code;
  408. continue;
  409. } else if (code >= 0xDC00 && code <= 0xDFFF) {
  410. /* Error... */
  411. *dest++ = '?';
  412. } else if (code < 0x10000) {
  413. *dest++ = (code >> 12) | 0xE0;
  414. *dest++ = ((code >> 6) & 0x3F) | 0x80;
  415. *dest++ = (code & 0x3F) | 0x80;
  416. } else {
  417. *dest++ = (code >> 18) | 0xF0;
  418. *dest++ = ((code >> 12) & 0x3F) | 0x80;
  419. *dest++ = ((code >> 6) & 0x3F) | 0x80;
  420. *dest++ = (code & 0x3F) | 0x80;
  421. }
  422. }
  423. }
  424. return dest;
  425. }
  426. int utf_to_cp(s32 *c, const u16 *codepage)
  427. {
  428. if (*c >= 0x80) {
  429. int j;
  430. /* Look up codepage translation */
  431. for (j = 0; j < 0x80; ++j) {
  432. if (*c == codepage[j]) {
  433. *c = j + 0x80;
  434. return 0;
  435. }
  436. }
  437. *c = '?';
  438. return -ENOENT;
  439. }
  440. return 0;
  441. }
  442. int utf8_to_cp437_stream(u8 c, char *buffer)
  443. {
  444. char *end;
  445. const char *pos;
  446. s32 s;
  447. int ret;
  448. for (;;) {
  449. pos = buffer;
  450. end = buffer + strlen(buffer);
  451. *end++ = c;
  452. *end = 0;
  453. s = utf8_get(&pos);
  454. if (s > 0) {
  455. *buffer = 0;
  456. ret = utf_to_cp(&s, codepage_437);
  457. return s;
  458. }
  459. if (pos == end)
  460. return 0;
  461. *buffer = 0;
  462. }
  463. }
  464. int utf8_to_utf32_stream(u8 c, char *buffer)
  465. {
  466. char *end;
  467. const char *pos;
  468. s32 s;
  469. for (;;) {
  470. pos = buffer;
  471. end = buffer + strlen(buffer);
  472. *end++ = c;
  473. *end = 0;
  474. s = utf8_get(&pos);
  475. if (s > 0) {
  476. *buffer = 0;
  477. return s;
  478. }
  479. if (pos == end)
  480. return 0;
  481. *buffer = 0;
  482. }
  483. }