Implement setting of Windows-specific XML information
[wimlib] / include / wimlib / encoding.h
1 #ifndef _WIMLIB_ENCODING_H
2 #define _WIMLIB_ENCODING_H
3
4 #include <string.h>
5
6 #include "wimlib/error.h"
7 #include "wimlib/util.h"
8 #include "wimlib/types.h"
9
10 extern void
11 iconv_global_init(void);
12
13 extern void
14 iconv_global_cleanup(void);
15
16 extern u16 upcase[65536];
17
18 extern void
19 init_upcase(void);
20
21 extern bool wimlib_mbs_is_utf8;
22
23 #define DECLARE_CHAR_CONVERSION_FUNCTIONS(varname1, varname2,           \
24                                           chartype1, chartype2)         \
25                                                                         \
26 extern int                                                              \
27 varname1##_to_##varname2(const chartype1 *in, size_t in_nbytes,         \
28                          chartype2 **out_ret,                           \
29                          size_t *out_nbytes_ret);                       \
30                                                                         \
31 extern int                                                              \
32 varname1##_to_##varname2##_nbytes(const chartype1 *in, size_t in_nbytes,\
33                                   size_t *out_nbytes_ret);              \
34                                                                         \
35 extern int                                                              \
36 varname1##_to_##varname2##_buf(const chartype1 *in, size_t in_nbytes,   \
37                                chartype2 *out);
38
39 extern utf16lechar *
40 utf16le_dupz(const void *ustr, size_t usize);
41
42 extern utf16lechar *
43 utf16le_dup(const utf16lechar *ustr);
44
45 extern size_t
46 utf16le_len_bytes(const utf16lechar *s);
47
48 extern size_t
49 utf16le_len_chars(const utf16lechar *s);
50
51 #if !TCHAR_IS_UTF16LE
52 DECLARE_CHAR_CONVERSION_FUNCTIONS(utf16le, tstr, utf16lechar, tchar);
53 DECLARE_CHAR_CONVERSION_FUNCTIONS(tstr, utf16le, tchar, utf16lechar);
54 #else
55
56 static inline int
57 tstr_to_utf16le(const tchar *tstr, size_t tsize,
58                 utf16lechar **ustr_ret, size_t *usize_ret)
59 {
60         utf16lechar *ustr = utf16le_dupz(tstr, tsize);
61         if (!ustr)
62                 return WIMLIB_ERR_NOMEM;
63         *ustr_ret = ustr;
64         *usize_ret = tsize;
65         return 0;
66 }
67
68 #define utf16le_to_tstr tstr_to_utf16le
69
70 #endif
71
72 DECLARE_CHAR_CONVERSION_FUNCTIONS(utf8, tstr, char, tchar);
73 DECLARE_CHAR_CONVERSION_FUNCTIONS(tstr, utf8, tchar, char);
74
75 extern int
76 utf8_to_tstr_simple(const char *utf8str, tchar **out);
77
78 extern int
79 tstr_to_utf8_simple(const tchar *tstr, char **out);
80
81 extern int
82 cmp_utf16le_strings(const utf16lechar *s1, size_t n1,
83                     const utf16lechar *s2, size_t n2,
84                     bool ignore_case);
85
86 extern int
87 cmp_utf16le_strings_z(const utf16lechar *s1, const utf16lechar *s2,
88                       bool ignore_case);
89
90 /* Convert a string in the platform-dependent encoding to UTF-16LE, but if both
91  * encodings are UTF-16LE, simply re-use the string.  Release with
92  * tstr_put_utf16le() when done.  */
93 static inline int
94 tstr_get_utf16le_and_len(const tchar *tstr,
95                          const utf16lechar **ustr_ret, size_t *usize_ret)
96 {
97         size_t tsize = tstrlen(tstr) * sizeof(tchar);
98 #if TCHAR_IS_UTF16LE
99         /* No conversion or copy needed  */
100         *ustr_ret = tstr;
101         *usize_ret = tsize;
102         return 0;
103 #else
104         return tstr_to_utf16le(tstr, tsize, (utf16lechar **)ustr_ret, usize_ret);
105 #endif
106 }
107
108 /* Convert a string in the platform-dependent encoding to UTF-16LE, but if both
109  * encodings are UTF-16LE, simply re-use the string.  Release with
110  * tstr_put_utf16le() when done.  */
111 static inline int
112 tstr_get_utf16le(const tchar *tstr, const utf16lechar **ustr_ret)
113 {
114 #if TCHAR_IS_UTF16LE
115         /* No conversion or copy needed  */
116         *ustr_ret = tstr;
117         return 0;
118 #else
119         size_t tsize = tstrlen(tstr) * sizeof(tchar);
120         size_t dummy;
121         return tstr_to_utf16le(tstr, tsize, (utf16lechar **)ustr_ret, &dummy);
122 #endif
123 }
124
125 /* Release a string acquired with tstr_get_utf16le() or
126  * tstr_get_utf16le_and_len().  */
127 static inline void
128 tstr_put_utf16le(const utf16lechar *ustr)
129 {
130 #if !TCHAR_IS_UTF16LE
131         FREE((void *)ustr);
132 #endif
133 }
134
135 /* Convert a UTF16-LE string to the platform-dependent encoding, but if both
136  * encodings are UTF-16LE, simply re-use the string.  Release with
137  * utf16le_put_tstr() when done.  */
138 static inline int
139 utf16le_get_tstr(const utf16lechar *ustr, size_t usize,
140                  const tchar **tstr_ret, size_t *tsize_ret)
141 {
142 #if TCHAR_IS_UTF16LE
143         /* No conversion or copy needed  */
144         *tstr_ret = ustr;
145         *tsize_ret = usize;
146         return 0;
147 #else
148         return utf16le_to_tstr(ustr, usize, (tchar **)tstr_ret, tsize_ret);
149 #endif
150 }
151
152 /* Release a string acquired with utf16le_get_tstr().  */
153 static inline void
154 utf16le_put_tstr(const tchar *tstr)
155 {
156 #if !TCHAR_IS_UTF16LE
157         FREE((void *)tstr);
158 #endif
159 }
160
161 #endif /* _WIMLIB_ENCODING_H */