Rename all 'utf8_io' -> 'win_utf8_io'.
[flac.git] / src / share / win_utf8_io / win_utf8_io.c
1 #ifdef FLAC__STRINGS_IN_UTF8
2
3 #include <stdio.h>
4 #include <sys/stat.h>
5 #include <sys/utime.h>
6 #include <io.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <stdarg.h>
10 #include <windows.h> /* for WideCharToMultiByte and MultiByteToWideChar */
11
12 #include "share/win_utf8_io.h"
13
14 /* convert WCHAR stored Unicode string to UTF-8. Caller is responsible for freeing memory */
15 char *utf8_from_wchar(const wchar_t *wstr)
16 {
17         char *utf8str;
18         int len;
19
20         if (!wstr) return NULL;
21         if ((len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL)) == 0) return NULL;
22         if ((utf8str = (char *)malloc(++len)) == NULL) return NULL;
23         if (WideCharToMultiByte(CP_UTF8, 0, wstr, -1, utf8str, len, NULL, NULL) == 0) {
24                 free(utf8str);
25                 utf8str = NULL;
26         }
27
28         return utf8str;
29 }
30
31 /* convert UTF-8 back to WCHAR. Caller is responsible for freeing memory */
32 wchar_t *wchar_from_utf8(const char *str)
33 {
34         wchar_t *widestr;
35         int len;
36
37         if (!str) return NULL;
38         len=(int)strlen(str)+1;
39         if ((widestr = (wchar_t *)malloc(len*sizeof(wchar_t))) != NULL) {
40                 if (MultiByteToWideChar(CP_UTF8, 0, str, len, widestr, len) == 0) {
41                         if (MultiByteToWideChar(CP_ACP, 0, str, len, widestr, len) == 0) { /* try conversion from Ansi in case the initial UTF-8 conversion had failed */
42                                 free(widestr);
43                                 widestr = NULL;
44                         }
45                 }
46         }
47
48         return widestr;
49 }
50
51 /* retrieve WCHAR commandline, expand wildcards and convert everything to UTF-8 */
52 int get_utf8_argv(int *argc, char ***argv)
53 {
54         typedef int (__cdecl *__wgetmainargs_)(int*, wchar_t***, wchar_t***, int, int*);
55         __wgetmainargs_ __wgetmainargs;
56         HMODULE handle;
57         int wargc;
58         wchar_t **wargv;
59         wchar_t **wenv;
60         char **utf8argv;
61         int ret, i;
62
63         if ((handle = LoadLibrary("msvcrt.dll")) == NULL) return 1;
64         if ((__wgetmainargs = (__wgetmainargs_)GetProcAddress(handle, "__wgetmainargs")) == NULL) return 1;
65         i = 0;
66         if (__wgetmainargs(&wargc, &wargv, &wenv, 1, &i) != 0) return 1;
67         if ((utf8argv = (char **)malloc(wargc*sizeof(char*))) == NULL) return 1;
68         ret = 0;
69
70         for (i=0; i<wargc; i++) {
71                 if ((utf8argv[i] = utf8_from_wchar(wargv[i])) == NULL) {
72                         ret = 1;
73                         break;
74                 }
75                 if (ret != 0) break;
76         }
77
78         if (ret == 0) {
79                 *argc = wargc;
80                 *argv = utf8argv;
81         } else {
82                 free(utf8argv);
83         }
84
85         return ret;
86 }
87
88 /* print functions */
89
90 int printf_utf8(const char *format, ...)
91 {
92         char *utmp = NULL;
93         wchar_t *wout = NULL;
94         int ret = -1;
95
96         while (1) {
97                 va_list argptr;
98                 if (!(utmp = (char *)malloc(32768*sizeof(char)))) break;
99                 va_start(argptr, format);
100                 ret = vsprintf(utmp, format, argptr);
101                 va_end(argptr);
102                 if (ret < 0) break;
103                 if (!(wout = wchar_from_utf8(utmp))) {
104                         ret = -1;
105                         break;
106                 }
107                 ret = wprintf(L"%s", wout);
108                 break;
109         }
110         if (utmp) free(utmp);
111         if (wout) free(wout);
112
113         return ret;
114 }
115
116 int fprintf_utf8(FILE *stream, const char *format, ...)
117 {
118         char *utmp = NULL;
119         wchar_t *wout = NULL;
120         int ret = -1;
121
122         while (1) {
123                 va_list argptr;
124                 if (!(utmp = (char *)malloc(32768*sizeof(char)))) break;
125                 va_start(argptr, format);
126                 ret = vsprintf(utmp, format, argptr);
127                 va_end(argptr);
128                 if (ret < 0) break;
129                 if (!(wout = wchar_from_utf8(utmp))) {
130                         ret = -1;
131                         break;
132                 }
133                 ret = fwprintf(stream, L"%s", wout);
134                 break;
135         }
136         if (utmp) free(utmp);
137         if (wout) free(wout);
138
139         return ret;
140 }
141
142 int vfprintf_utf8(FILE *stream, const char *format, va_list argptr)
143 {
144         char *utmp = NULL;
145         wchar_t *wout = NULL;
146         int ret = -1;
147
148         while (1) {
149                 if (!(utmp = (char *)malloc(32768*sizeof(char)))) break;
150                 if ((ret = vsprintf(utmp, format, argptr)) < 0) break;
151                 if (!(wout = wchar_from_utf8(utmp))) {
152                         ret = -1;
153                         break;
154                 }
155                 ret = fwprintf(stream, L"%s", wout);
156                 break;
157         }
158         if (utmp) free(utmp);
159         if (wout) free(wout);
160
161         return ret;
162 }
163
164 /* file functions */
165
166 FILE *fopen_utf8(const char *filename, const char *mode)
167 {
168         wchar_t *wname = NULL;
169         wchar_t *wmode = NULL;
170         FILE *f = NULL;
171
172         while (1) {
173                 if (!(wname = wchar_from_utf8(filename))) break;
174                 if (!(wmode = wchar_from_utf8(mode))) break;
175                 f = _wfopen(wname, wmode);
176                 break;
177         }
178         if (wname) free(wname);
179         if (wmode) free(wmode);
180
181         return f;
182 }
183
184 int _stat64_utf8(const char *path, struct _stat64 *buffer)
185 {
186         wchar_t *wpath;
187         int ret;
188
189         if (!(wpath = wchar_from_utf8(path))) return -1;
190         ret = _wstat64(wpath, buffer);
191         free(wpath);
192
193         return ret;
194 }
195
196 int chmod_utf8(const char *filename, int pmode)
197 {
198         wchar_t *wname;
199         int ret;
200
201         if (!(wname = wchar_from_utf8(filename))) return -1;
202         ret = _wchmod(wname, pmode);
203         free(wname);
204
205         return ret;
206 }
207
208 int utime_utf8(const char *filename, struct utimbuf *times)
209 {
210         wchar_t *wname;
211         struct _utimbuf ut;
212         int ret;
213
214         if (!(wname = wchar_from_utf8(filename))) return -1;
215         ret = _wutime(wname, &ut);
216         free(wname);
217
218         if (ret != -1) {
219                 if (sizeof(*times) == sizeof(ut)) {
220                         memcpy(times, &ut, sizeof(ut));
221                 } else {
222                         times->actime = ut.actime;
223                         times->modtime = ut.modtime;
224                 }
225         }
226
227         return ret;
228 }
229
230 int unlink_utf8(const char *filename)
231 {
232         wchar_t *wname;
233         int ret;
234
235         if (!(wname = wchar_from_utf8(filename))) return -1;
236         ret = _wunlink(wname);
237         free(wname);
238
239         return ret;
240 }
241
242 int rename_utf8(const char *oldname, const char *newname)
243 {
244         wchar_t *wold = NULL;
245         wchar_t *wnew = NULL;
246         int ret = -1;
247
248         while (1) {
249                 if (!(wold = wchar_from_utf8(oldname))) break;
250                 if (!(wnew = wchar_from_utf8(newname))) break;
251                 ret = _wrename(wold, wnew);
252                 break;
253         }
254         if (wold) free(wold);
255         if (wnew) free(wnew);
256
257         return ret;
258 }
259
260 #endif