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