stdex
Additional custom or not Standard C++ covered algorithms
Loading...
Searching...
No Matches
sgml.hpp
1/*
2 SPDX-License-Identifier: MIT
3 Copyright © 2023 Amebis
4*/
5
6#pragma once
7
8#include "compat.hpp"
9#include "mapping.hpp"
10#include "sgml_unicode.hpp"
11#include "string.hpp"
12#include <string.h>
13#include <exception>
14#include <string>
15
16namespace stdex
17{
19 template <class T>
20 inline const wchar_t* sgml2uni(_In_reads_or_z_(count) const T* entity, _In_ size_t count)
21 {
22 _Assume_(entity && count);
23 _Assume_(count < 2 || entity[0] != '#'); // No numeric entities
24
25 for (size_t i = 0, j = _countof(sgml_unicode); i < j; ) {
26 size_t m = (i + j) / 2;
27 if (sgml_unicode[m].sgml[0] < entity[0])
28 i = m + 1;
29 else if (sgml_unicode[m].sgml[0] > entity[0])
30 j = m;
31 else {
32 auto r = strncmp<char, T>(sgml_unicode[m].sgml + 1, _countof(sgml_unicode[0].sgml) - 1, entity + 1, count - 1);
33 if (r < 0)
34 i = m + 1;
35 else if (r > 0)
36 j = m;
37 else {
38 for (; i < m && strncmp<char, T>(sgml_unicode[m - 1].sgml, _countof(sgml_unicode[0].sgml), entity, count) == 0; m--);
39 return sgml_unicode[m].unicode;
40 }
41 }
42 }
43 return nullptr;
44 }
45
46 template <class T>
47 inline const T* sgmlend(
48 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count)
49 {
50 _Assume_(str || !count);
51 for (size_t i = 0; i < count; i++) {
52 if (str[i] == ';')
53 return str + i;
54 if (!str[i] || str[i] == '&' || isspace(str[i]))
55 break;
56 }
57 return nullptr;
58 }
60
61 constexpr int sgml_full = 0x80000000;
62 constexpr int sgml_quot = 0x00000001;
63 constexpr int sgml_apos = 0x00000002;
64 constexpr int sgml_quot_apos = sgml_quot | sgml_apos;
65 constexpr int sgml_amp = 0x00000004;
66 constexpr int sgml_lt_gt = 0x00000008;
67 constexpr int sgml_bsol = 0x00000010;
68 constexpr int sgml_dollar = 0x00000020;
69 constexpr int sgml_percnt = 0x00000040;
70 constexpr int sgml_commat = 0x00000080;
71 constexpr int sgml_num = 0x00000100;
72 constexpr int sgml_lpar_rpar = 0x00000200;
73 constexpr int sgml_lcub_rcub = 0x00000400;
74 constexpr int sgml_lsqb_rsqb = 0x00000800;
75 constexpr int sgml_sgml = sgml_amp | sgml_lt_gt;
76 constexpr int sgml_ml_attrib = sgml_amp | sgml_quot_apos;
77 constexpr int sgml_c = sgml_amp | sgml_bsol | sgml_quot_apos;
78 // constexpr int sgml_ajt_lemma = sgml_amp | sgml_quot | sgml_dollar | sgml_percnt;
79 // constexpr int sgml_ajt_form = sgml_ajt_lemma;
80 // constexpr int sgml_kolos = sgml_amp | sgml_quot | sgml_dollar | sgml_percnt | sgml_lt_gt | sgml_bsol/* | sgml_commat | sgml_num*/ | sgml_lpar_rpar | sgml_lcub_rcub | sgml_lsqb_rsqb;
81
92 template <class T>
93 inline void sgml2wstrcat(
94 _Inout_ std::wstring& dst,
95 _In_reads_or_z_opt_(count_src) const T* src, _In_ size_t count_src,
96 _In_ int skip = 0,
97 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
98 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
99 {
100 _Assume_(src || !count_src);
101
102 const bool
103 skip_quot = (skip & sgml_quot) == 0,
104 skip_apos = (skip & sgml_apos) == 0,
105 skip_amp = (skip & sgml_amp) == 0,
106 skip_lt_gt = (skip & sgml_lt_gt) == 0,
107 skip_bsol = (skip & sgml_bsol) == 0,
108 skip_dollar = (skip & sgml_dollar) == 0,
109 skip_percnt = (skip & sgml_percnt) == 0,
110 skip_commat = (skip & sgml_commat) == 0,
111 skip_num = (skip & sgml_num) == 0,
112 skip_lpar_rpar = (skip & sgml_lpar_rpar) == 0,
113 skip_lcub_rcub = (skip & sgml_lcub_rcub) == 0,
114 skip_lsqb_rsqb = (skip & sgml_lsqb_rsqb) == 0;
115
116 count_src = strnlen(src, count_src);
117 dst.reserve(dst.size() + count_src);
118 for (size_t i = 0; i < count_src;) {
119 if (src[i] == '&') {
120 auto end = sgmlend(src + i + 1, count_src - i - 1);
121 if (end) {
122 const wchar_t* entity_w;
123 wchar_t chr[3];
124 size_t n = end - src - i - 1;
125 if (n >= 2 && src[i + 1] == '#') {
126 uint32_t unicode;
127 if (src[i + 2] == 'x' || src[i + 2] == 'X')
128 unicode = strtou32(src + i + 3, n - 2, nullptr, 16);
129 else
130 unicode = strtou32(src + i + 2, n - 1, nullptr, 10);
131#ifdef _WIN32
132 if (unicode < 0x10000) {
133 chr[0] = (wchar_t)unicode;
134 chr[1] = 0;
135 }
136 else {
137 ucs4_to_surrogate_pair(chr, unicode);
138 chr[2] = 0;
139 }
140#else
141 chr[0] = (wchar_t)unicode;
142 chr[1] = 0;
143#endif
144 entity_w = chr;
145 }
146 else
147 entity_w = sgml2uni(src + i + 1, n);
148
149 if (entity_w &&
150 (skip_quot || (entity_w[0] != L'"')) &&
151 (skip_apos || (entity_w[0] != L'\'')) &&
152 (skip_amp || (entity_w[0] != L'&')) &&
153 (skip_lt_gt || (entity_w[0] != L'<' && entity_w[0] != L'>')) &&
154 (skip_bsol || (entity_w[0] != L'\\')) &&
155 (skip_dollar || (entity_w[0] != L'$')) &&
156 (skip_percnt || (entity_w[0] != L'%')) &&
157 (skip_commat || (entity_w[0] != L'@')) &&
158 (skip_num || (entity_w[0] != L'#')) &&
159 (skip_lpar_rpar || (entity_w[0] != L'(' && entity_w[0] != L')')) &&
160 (skip_lcub_rcub || (entity_w[0] != L'{' && entity_w[0] != L'}')) &&
161 (skip_lsqb_rsqb || (entity_w[0] != L'[' && entity_w[0] != L']')))
162 {
163 if (map) map->push_back(mapping<size_t>(offset.from + i, offset.to + dst.size()));
164 dst.append(entity_w);
165 i = end - src + 1;
166 if (map) map->push_back(mapping<size_t>(offset.from + i, offset.to + dst.size()));
167 continue;
168 }
169 }
170 }
171 dst.append(1, src[i++]);
172 }
173 }
174
175 template <class T>
176 _Deprecated_("Use stdex::sgml2wstrcat")
177 inline void sgml2wstr(
178 _Inout_ std::wstring& dst,
179 _In_reads_or_z_opt_(count_src) const T* src, _In_ size_t count_src,
180 _In_ int skip = 0,
181 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
182 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
183 {
184 sgml2wstrcat(dst, src, count_src, skip, offset, map);
185 }
186
196 template <class T>
197 inline void sgml2wstrcat(
198 _Inout_ std::wstring& dst,
199 _In_ const std::basic_string<T>& src,
200 _In_ int skip = 0,
201 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
202 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
203 {
204 sgml2wstrcat(dst, src.data(), src.size(), skip, offset, map);
205 }
206
207 template <class T>
208 _Deprecated_("Use stdex::sgml2wstrcat")
209 inline void sgml2wstr(
210 _Inout_ std::wstring& dst,
211 _In_ const std::basic_string<T>& src,
212 _In_ int skip = 0,
213 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
214 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
215 {
216 sgml2wstrcat(dst, src, skip, offset, map);
217 }
218
232 template <class T>
233 inline size_t sgml2wstrcat(
234 _Inout_cap_(count_dst) wchar_t* dst, _In_ size_t count_dst,
235 _In_reads_or_z_opt_(count_src) const T* src, _In_ size_t count_src,
236 _In_ int skip = 0,
237 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
238 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
239 {
240 _Assume_(dst || !count_dst);
241 _Assume_(src || !count_src);
242
243 static const std::invalid_argument buffer_overrun("buffer overrun");
244 const bool
245 skip_quot = (skip & sgml_quot) == 0,
246 skip_apos = (skip & sgml_apos) == 0,
247 skip_amp = (skip & sgml_amp) == 0,
248 skip_lt_gt = (skip & sgml_lt_gt) == 0,
249 skip_bsol = (skip & sgml_bsol) == 0,
250 skip_dollar = (skip & sgml_dollar) == 0,
251 skip_percnt = (skip & sgml_percnt) == 0,
252 skip_commat = (skip & sgml_commat) == 0,
253 skip_num = (skip & sgml_num) == 0,
254 skip_lpar_rpar = (skip & sgml_lpar_rpar) == 0,
255 skip_lcub_rcub = (skip & sgml_lcub_rcub) == 0,
256 skip_lsqb_rsqb = (skip & sgml_lsqb_rsqb) == 0;
257
258 size_t j = wcsnlen(dst, count_dst);
259 count_src = strnlen(src, count_src);
260 for (size_t i = 0; i < count_src;) {
261 if (src[i] == '&') {
262 auto end = sgmlend(src + i + 1, count_src - i - 1);
263 if (end) {
264 const wchar_t* entity_w;
265 wchar_t chr[3];
266 size_t n = end - src - i - 1;
267 if (n >= 2 && src[i + 1] == '#') {
268 uint32_t unicode;
269 if (src[i + 2] == 'x' || src[i + 2] == 'X')
270 unicode = strtou32(src + i + 3, n - 2, nullptr, 16);
271 else
272 unicode = strtou32(src + i + 2, n - 1, nullptr, 10);
273#ifdef _WIN32
274 if (unicode < 0x10000) {
275 chr[0] = (wchar_t)unicode;
276 chr[1] = 0;
277 }
278 else {
279 ucs4_to_surrogate_pair(chr, unicode);
280 chr[2] = 0;
281 }
282#else
283 chr[0] = (wchar_t)unicode;
284 chr[1] = 0;
285#endif
286 entity_w = chr;
287 }
288 else
289 entity_w = sgml2uni(src + i + 1, n);
290
291 if (entity_w &&
292 (skip_quot || (entity_w[0] != L'"')) &&
293 (skip_apos || (entity_w[0] != L'\'')) &&
294 (skip_amp || (entity_w[0] != L'&')) &&
295 (skip_lt_gt || (entity_w[0] != L'<' && entity_w[0] != L'>')) &&
296 (skip_bsol || (entity_w[0] != L'\\')) &&
297 (skip_dollar || (entity_w[0] != L'$')) &&
298 (skip_percnt || (entity_w[0] != L'%')) &&
299 (skip_commat || (entity_w[0] != L'@')) &&
300 (skip_num || (entity_w[0] != L'#')) &&
301 (skip_lpar_rpar || (entity_w[0] != L'(' && entity_w[0] != L')')) &&
302 (skip_lcub_rcub || (entity_w[0] != L'{' && entity_w[0] != L'}')) &&
303 (skip_lsqb_rsqb || (entity_w[0] != L'[' && entity_w[0] != L']')))
304 {
305 if (map) map->push_back(mapping<size_t>(offset.from + i, offset.to + j));
306 size_t m = wcslen(entity_w);
307 if (j + m >= count_dst)
308 throw buffer_overrun;
309 memcpy(dst + j, entity_w, m * sizeof(wchar_t)); j += m;
310 i = end - src + 1;
311 if (map) map->push_back(mapping<size_t>(offset.from + i, offset.to + j));
312 continue;
313 }
314 }
315 }
316 if (j + 1 >= count_dst)
317 throw buffer_overrun;
318 dst[j++] = src[i++];
319 }
320 if (j >= count_dst)
321 throw buffer_overrun;
322 dst[j] = 0;
323 return j;
324 }
325
326 template <class T>
327 _Deprecated_("Use stdex::sgml2wstrcat")
328 inline size_t sgml2wstr(
329 _Inout_cap_(count_dst) wchar_t* dst, _In_ size_t count_dst,
330 _In_reads_or_z_opt_(count_src) const T* src, _In_ size_t count_src,
331 _In_ int skip = 0,
332 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
333 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
334 {
335 return sgml2wstrcat(dst, count_dst, src, count_src, skip, offset, map);
336 }
337
348 template <class T>
349 inline void sgml2wstrcpy(
350 _Inout_ std::wstring& dst,
351 _In_reads_or_z_opt_(count_src) const T* src, _In_ size_t count_src,
352 _In_ int skip = 0,
353 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
354 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
355 {
356 dst.clear();
357 if (map)
358 map->clear();
359 sgml2wstrcat(dst, src, count_src, skip, offset, map);
360 }
361
371 template<class _Elem, class _Traits, class _Ax>
372 inline void sgml2wstrcpy(
373 _Inout_ std::wstring& dst,
374 _In_ const std::basic_string<_Elem, _Traits, _Ax>& src,
375 _In_ int skip = 0,
376 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
377 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
378 {
379 sgml2wstrcpy(dst, src.data(), src.size(), skip, offset, map);
380 }
381
395 template <class T>
396 inline size_t sgml2wstrcpy(
397 _Inout_cap_(count_dst) wchar_t* dst, _In_ size_t count_dst,
398 _In_reads_or_z_opt_(count_src) const T* src, _In_ size_t count_src,
399 _In_ int skip = 0,
400 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
401 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
402 {
403 _Assume_(dst || !count_dst);
404 if (count_dst)
405 dst[0] = 0;
406 if (map)
407 map->clear();
408 return sgml2wstrcat(dst, count_dst, src, count_src, skip, offset, map);
409 }
410
422 template <class T>
423 inline std::wstring sgml2wstr(
424 _In_reads_or_z_opt_(count_src) const T* src, _In_ size_t count_src,
425 _In_ int skip = 0,
426 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
427 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
428 {
429 std::wstring dst;
430 sgml2wstrcat(dst, src, count_src, skip, offset, map);
431 return dst;
432 }
433
444 template <class T>
445 inline std::wstring sgml2wstr(
446 _In_ const std::basic_string<T>& src,
447 _In_ int skip = 0,
448 _In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
449 _Inout_opt_ mapping_vector<size_t>* map = nullptr)
450 {
451 return sgml2wstr(src.c_str(), src.size(), skip, offset, map);
452 }
453
455 inline const char* chr2sgml(_In_reads_or_z_(count) const wchar_t* entity, _In_ size_t count)
456 {
457 _Assume_(entity && count);
458
459 const wchar_t e2 = entity[0];
460 for (size_t i = 0, j = _countof(unicode_sgml); i < j; ) {
461 size_t m = (i + j) / 2;
462 wchar_t e1 = sgml_unicode[unicode_sgml[m]].unicode[0];
463 if (e1 < e2)
464 i = m + 1;
465 else if (e1 > e2)
466 j = m;
467 else {
468 auto r = strncmp(sgml_unicode[unicode_sgml[m]].unicode + 1, _countof(sgml_unicode[0].unicode) - 1, entity + 1, count - 1);
469 if (r < 0)
470 i = m + 1;
471 else if (r > 0)
472 j = m;
473 else {
474 for (; i < m && sgml_unicode[unicode_sgml[m - 1]].unicode[0] == e2 && strncmp(sgml_unicode[unicode_sgml[m - 1]].unicode + 1, _countof(sgml_unicode[0].unicode) - 1, entity + 1, count - 1) == 0; m--);
475 return sgml_unicode[unicode_sgml[m]].sgml;
476 }
477 }
478 }
479 return nullptr;
480 }
482
491 inline void wstr2sgmlcat(
492 _Inout_ std::string& dst,
493 _In_reads_or_z_opt_(count_src) const wchar_t* src, _In_ size_t count_src,
494 _In_ size_t what = 0)
495 {
496 _Assume_(src || !count_src);
497
498 const bool
499 do_ascii = (what & sgml_full) == 0,
500 do_quot = (what & sgml_quot) == 0,
501 do_apos = (what & sgml_apos) == 0,
502 do_lt_gt = (what & sgml_lt_gt) == 0,
503 do_bsol = (what & sgml_bsol) == 0,
504 do_dollar = (what & sgml_dollar) == 0,
505 do_percnt = (what & sgml_percnt) == 0,
506 do_commat = (what & sgml_commat) == 0,
507 do_num = (what & sgml_num) == 0,
508 do_lpar_rpar = (what & sgml_lpar_rpar) == 0,
509 do_lcub_rcub = (what & sgml_lcub_rcub) == 0,
510 do_lsqb_rsqb = (what & sgml_lsqb_rsqb) == 0;
511
512 count_src = wcsnlen(src, count_src);
513 dst.reserve(dst.size() + count_src);
514 for (size_t i = 0; i < count_src;) {
515 size_t n = glyphlen(src + i, count_src - i);
516 if (n == 1 &&
517 do_ascii && (unsigned int)src[i] < 128 &&
518 src[i] != L'&' &&
519 (do_quot || (src[i] != L'"')) &&
520 (do_apos || (src[i] != L'\'')) &&
521 (do_lt_gt || (src[i] != L'<' && src[i] != L'>')) &&
522 (do_bsol || (src[i] != L'\\')) &&
523 (do_dollar || (src[i] != L'$')) &&
524 (do_percnt || (src[i] != L'%')) &&
525 (do_commat || (src[i] != L'@')) &&
526 (do_num || (src[i] != L'#')) &&
527 (do_lpar_rpar || (src[i] != L'(' && src[i] != L')')) &&
528 (do_lcub_rcub || (src[i] != L'{' && src[i] != L'}')) &&
529 (do_lsqb_rsqb || (src[i] != L'[' && src[i] != L']')))
530 {
531 // 7-bit ASCII and no desire to encode it as an SGML entity.
532 dst.append(1, static_cast<char>(src[i++]));
533 }
534 else {
535 const char* entity = chr2sgml(src + i, n);
536 if (entity) {
537 dst.append(1, '&');
538 dst.append(entity);
539 dst.append(1, ';');
540 i += n;
541 }
542 else if (n == 1) {
543 // Trivial character (1 code unit, 1 glyph), no entity available.
544 if ((unsigned int)src[i] < 128)
545 dst.append(1, static_cast<char>(src[i++]));
546 else {
547 char tmp[3 + 8 + 1 + 1];
548 snprintf(tmp, _countof(tmp), "&#x%x;", src[i++]);
549 dst.append(tmp);
550 }
551 }
552 else {
553 // Non-trivial character. Decompose.
554 const size_t end = i + n;
555 while (i < end) {
556 if ((entity = chr2sgml(src + i, 1)) != nullptr) {
557 dst.append(1, '&');
558 dst.append(entity);
559 dst.append(1, ';');
560 i++;
561 }
562 else if ((unsigned int)src[i] < 128)
563 dst.append(1, static_cast<char>(src[i++]));
564 else {
565 uint32_t unicode;
566#ifdef _WIN32
567 if (i + 1 < end && is_surrogate_pair(src + i)) {
568 unicode = surrogate_pair_to_ucs4(src + i);
569 i += 2;
570 }
571 else
572#endif
573 {
574 unicode = src[i++];
575 }
576 char tmp[3 + 8 + 1 + 1];
577 snprintf(tmp, _countof(tmp), "&#x%x;", unicode);
578 dst.append(tmp);
579 }
580 }
581 }
582 }
583 }
584 }
585
586 _Deprecated_("Use stdex::wstr2sgmlcat")
587 inline void wstr2sgml(
588 _Inout_ std::string& dst,
589 _In_reads_or_z_opt_(count_src) const wchar_t* src, _In_ size_t count_src,
590 _In_ size_t what = 0)
591 {
592 wstr2sgmlcat(dst, src, count_src, what);
593 }
594
602 inline void wstr2sgmlcat(
603 _Inout_ std::string& dst,
604 _In_ const std::wstring& src,
605 _In_ size_t what = 0)
606 {
607 wstr2sgmlcat(dst, src.c_str(), src.size(), what);
608 }
609
610 _Deprecated_("Use stdex::wstr2sgmlcat")
611 inline void wstr2sgml(
612 _Inout_ std::string& dst,
613 _In_ const std::wstring& src,
614 _In_ size_t what = 0)
615 {
616 wstr2sgmlcat(dst, src, what);
617 }
618
630 inline size_t wstr2sgmlcat(
631 _Inout_cap_(count_dst) char* dst, _In_ size_t count_dst,
632 _In_reads_or_z_opt_(count_src) const wchar_t* src, _In_ size_t count_src,
633 _In_ size_t what = 0)
634 {
635 _Assume_(dst || !count_dst);
636 _Assume_(src || !count_src);
637
638 static const std::invalid_argument buffer_overrun("buffer overrun");
639 const bool
640 do_ascii = (what & sgml_full) == 0,
641 do_quot = (what & sgml_quot) == 0,
642 do_apos = (what & sgml_apos) == 0,
643 do_lt_gt = (what & sgml_lt_gt) == 0,
644 do_bsol = (what & sgml_bsol) == 0,
645 do_dollar = (what & sgml_dollar) == 0,
646 do_percnt = (what & sgml_percnt) == 0,
647 do_commat = (what & sgml_commat) == 0,
648 do_num = (what & sgml_num) == 0,
649 do_lpar_rpar = (what & sgml_lpar_rpar) == 0,
650 do_lcub_rcub = (what & sgml_lcub_rcub) == 0,
651 do_lsqb_rsqb = (what & sgml_lsqb_rsqb) == 0;
652
653 size_t j = strnlen(dst, count_dst);
654 count_src = wcsnlen(src, count_src);
655 for (size_t i = 0; i < count_src;) {
656 size_t n = glyphlen(src + i, count_src - i);
657 if (n == 1 &&
658 do_ascii && (unsigned int)src[i] < 128 &&
659 src[i] != L'&' &&
660 (do_quot || (src[i] != L'"')) &&
661 (do_apos || (src[i] != L'\'')) &&
662 (do_lt_gt || (src[i] != L'<' && src[i] != L'>')) &&
663 (do_bsol || (src[i] != L'\\')) &&
664 (do_dollar || (src[i] != L'$')) &&
665 (do_percnt || (src[i] != L'%')) &&
666 (do_commat || (src[i] != L'@')) &&
667 (do_num || (src[i] != L'#')) &&
668 (do_lpar_rpar || (src[i] != L'(' && src[i] != L')')) &&
669 (do_lcub_rcub || (src[i] != L'{' && src[i] != L'}')) &&
670 (do_lsqb_rsqb || (src[i] != L'[' && src[i] != L']')))
671 {
672 // 7-bit ASCII and no desire to encode it as an SGML entity.
673 if (j + 1 >= count_dst)
674 throw buffer_overrun;
675 dst[j++] = static_cast<char>(src[i++]);
676 }
677 else {
678 const char* entity = chr2sgml(src + i, n);
679 if (entity) {
680 size_t m = strlen(entity);
681 if (j + m + 2 >= count_dst)
682 throw buffer_overrun;
683 dst[j++] = '&';
684 memcpy(dst + j, entity, m * sizeof(char)); j += m;
685 dst[j++] = ';';
686 i += n;
687 }
688 else if (n == 1) {
689 // Trivial character (1 code unit, 1 glyph), no entity available.
690 if ((unsigned int)src[i] < 128) {
691 if (j + 1 >= count_dst)
692 throw buffer_overrun;
693 dst[j++] = static_cast<char>(src[i++]);
694 }
695 else {
696 char tmp[3 + 8 + 1 + 1];
697 int m = snprintf(tmp, _countof(tmp), "&#x%x;", src[i++]);
698 _Assume_(m >= 0);
699 if (static_cast<size_t>(m) >= count_dst)
700 throw buffer_overrun;
701 memcpy(dst + j, tmp, m * sizeof(char)); j += m;
702 }
703 }
704 else {
705 // Non-trivial character. Decompose.
706 const size_t end = i + n;
707 while (i < end) {
708 if ((entity = chr2sgml(src + i, 1)) != nullptr) {
709 size_t m = strlen(entity);
710 if (j + m + 2 >= count_dst)
711 throw buffer_overrun;
712 dst[j++] = '&';
713 memcpy(dst + j, entity, m * sizeof(char)); j += m;
714 dst[j++] = ';';
715 i++;
716 }
717 else if ((unsigned int)src[i] < 128) {
718 if (j + 1 >= count_dst)
719 throw buffer_overrun;
720 dst[j++] = static_cast<char>(src[i++]);
721 }
722 else {
723 uint32_t unicode;
724#ifdef _WIN32
725 if (i + 1 < end && is_surrogate_pair(src + i)) {
726 unicode = surrogate_pair_to_ucs4(src + i);
727 i += 2;
728 }
729 else
730#endif
731 {
732 unicode = src[i++];
733 }
734 char tmp[3 + 8 + 1 + 1];
735 int m = snprintf(tmp, _countof(tmp), "&#x%x;", unicode);
736 _Assume_(m >= 0);
737 if (static_cast<size_t>(m) >= count_dst)
738 throw buffer_overrun;
739 memcpy(dst + j, tmp, m * sizeof(char)); j += m;
740 }
741 }
742 }
743 }
744 }
745 if (j >= count_dst)
746 throw buffer_overrun;
747 dst[j] = 0;
748 return j;
749 }
750
751 _Deprecated_("Use stdex::wstr2sgmlcat")
752 inline size_t wstr2sgml(
753 _Inout_cap_(count_dst) char* dst, _In_ size_t count_dst,
754 _In_reads_or_z_opt_(count_src) const wchar_t* src, _In_ size_t count_src,
755 _In_ size_t what = 0)
756 {
757 return wstr2sgmlcat(dst, count_dst, src, count_src, what);
758 }
759
768 inline void wstr2sgmlcpy(
769 _Inout_ std::string& dst,
770 _In_reads_or_z_opt_(count_src) const wchar_t* src, _In_ size_t count_src,
771 _In_ size_t what = 0)
772 {
773 dst.clear();
774 wstr2sgmlcat(dst, src, count_src, what);
775 }
776
784 inline void wstr2sgmlcpy(
785 _Inout_ std::string& dst,
786 _In_ const std::wstring& src,
787 _In_ size_t what = 0)
788 {
789 wstr2sgmlcpy(dst, src.data(), src.size(), what);
790 }
791
803 inline size_t wstr2sgmlcpy(
804 _Inout_cap_(count_dst) char* dst, _In_ size_t count_dst,
805 _In_reads_or_z_opt_(count_src) const wchar_t* src, _In_ size_t count_src,
806 _In_ size_t what = 0)
807 {
808 _Assume_(dst || !count_dst);
809 if (count_dst)
810 dst[0] = 0;
811 return wstr2sgmlcat(dst, count_dst, src, count_src, what);
812 }
813
823 inline std::string wstr2sgml(
824 _In_reads_or_z_opt_(count_src) const wchar_t* src, _In_ size_t count_src,
825 _In_ size_t what = 0)
826 {
827 std::string dst;
828 wstr2sgmlcat(dst, src, count_src, what);
829 return dst;
830 }
831
840 inline std::string wstr2sgml(
841 _In_ const std::wstring& src,
842 _In_ size_t what = 0)
843 {
844 return wstr2sgml(src.c_str(), src.size(), what);
845 }
846}
Generated on Fri Nov 10 2023 07:42:56 for stdex by doxygen 1.9.8