Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 1 | |
Erik de Castro Lopo | 0b736a5 | 2013-04-21 17:19:37 +1000 | [diff] [blame] | 2 | #if HAVE_CONFIG_H |
| 3 | # include <config.h> |
| 4 | #endif |
| 5 | |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 6 | #include <stdio.h> |
| 7 | #include <sys/stat.h> |
| 8 | #include <sys/utime.h> |
| 9 | #include <io.h> |
| 10 | #include <stdlib.h> |
| 11 | #include <string.h> |
| 12 | #include <stdarg.h> |
| 13 | #include <windows.h> /* for WideCharToMultiByte and MultiByteToWideChar */ |
| 14 | |
Erik de Castro Lopo | 0b736a5 | 2013-04-21 17:19:37 +1000 | [diff] [blame] | 15 | #include "share/compat.h" |
Erik de Castro Lopo | 608e246 | 2013-03-22 18:18:14 +1100 | [diff] [blame] | 16 | #include "share/win_utf8_io.h" |
Erik de Castro Lopo | 0b736a5 | 2013-04-21 17:19:37 +1000 | [diff] [blame] | 17 | #include "share/compat.h" |
Erik de Castro Lopo | 608e246 | 2013-03-22 18:18:14 +1100 | [diff] [blame] | 18 | |
Erik de Castro Lopo | 6a9a18f | 2013-04-07 13:11:19 +1000 | [diff] [blame] | 19 | static UINT win_utf8_io_codepage = CP_ACP; |
| 20 | |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 21 | /* convert WCHAR stored Unicode string to UTF-8. Caller is responsible for freeing memory */ |
Erik de Castro Lopo | 2199d08 | 2013-04-01 19:57:13 +1100 | [diff] [blame] | 22 | static |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 23 | char *utf8_from_wchar(const wchar_t *wstr) |
| 24 | { |
| 25 | char *utf8str; |
| 26 | int len; |
| 27 | |
| 28 | if (!wstr) return NULL; |
| 29 | if ((len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL)) == 0) return NULL; |
| 30 | if ((utf8str = (char *)malloc(++len)) == NULL) return NULL; |
| 31 | if (WideCharToMultiByte(CP_UTF8, 0, wstr, -1, utf8str, len, NULL, NULL) == 0) { |
| 32 | free(utf8str); |
| 33 | utf8str = NULL; |
| 34 | } |
| 35 | |
| 36 | return utf8str; |
| 37 | } |
| 38 | |
| 39 | /* convert UTF-8 back to WCHAR. Caller is responsible for freeing memory */ |
Erik de Castro Lopo | 2199d08 | 2013-04-01 19:57:13 +1100 | [diff] [blame] | 40 | static |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 41 | wchar_t *wchar_from_utf8(const char *str) |
| 42 | { |
| 43 | wchar_t *widestr; |
| 44 | int len; |
| 45 | |
| 46 | if (!str) return NULL; |
| 47 | len=(int)strlen(str)+1; |
| 48 | if ((widestr = (wchar_t *)malloc(len*sizeof(wchar_t))) != NULL) { |
Erik de Castro Lopo | 6a9a18f | 2013-04-07 13:11:19 +1000 | [diff] [blame] | 49 | if (MultiByteToWideChar(win_utf8_io_codepage, 0, str, len, widestr, len) == 0) { |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 50 | if (MultiByteToWideChar(CP_ACP, 0, str, len, widestr, len) == 0) { /* try conversion from Ansi in case the initial UTF-8 conversion had failed */ |
| 51 | free(widestr); |
| 52 | widestr = NULL; |
| 53 | } |
| 54 | } |
| 55 | } |
| 56 | |
| 57 | return widestr; |
| 58 | } |
| 59 | |
| 60 | /* retrieve WCHAR commandline, expand wildcards and convert everything to UTF-8 */ |
| 61 | int get_utf8_argv(int *argc, char ***argv) |
| 62 | { |
| 63 | typedef int (__cdecl *__wgetmainargs_)(int*, wchar_t***, wchar_t***, int, int*); |
| 64 | __wgetmainargs_ __wgetmainargs; |
| 65 | HMODULE handle; |
| 66 | int wargc; |
| 67 | wchar_t **wargv; |
| 68 | wchar_t **wenv; |
| 69 | char **utf8argv; |
| 70 | int ret, i; |
| 71 | |
| 72 | if ((handle = LoadLibrary("msvcrt.dll")) == NULL) return 1; |
| 73 | if ((__wgetmainargs = (__wgetmainargs_)GetProcAddress(handle, "__wgetmainargs")) == NULL) return 1; |
| 74 | i = 0; |
| 75 | if (__wgetmainargs(&wargc, &wargv, &wenv, 1, &i) != 0) return 1; |
| 76 | if ((utf8argv = (char **)malloc(wargc*sizeof(char*))) == NULL) return 1; |
| 77 | ret = 0; |
| 78 | |
| 79 | for (i=0; i<wargc; i++) { |
| 80 | if ((utf8argv[i] = utf8_from_wchar(wargv[i])) == NULL) { |
| 81 | ret = 1; |
| 82 | break; |
| 83 | } |
| 84 | if (ret != 0) break; |
| 85 | } |
| 86 | |
Erik de Castro Lopo | 6a9a18f | 2013-04-07 13:11:19 +1000 | [diff] [blame] | 87 | FreeLibrary(handle); |
| 88 | |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 89 | if (ret == 0) { |
Erik de Castro Lopo | 6a9a18f | 2013-04-07 13:11:19 +1000 | [diff] [blame] | 90 | win_utf8_io_codepage = CP_UTF8; |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 91 | *argc = wargc; |
| 92 | *argv = utf8argv; |
| 93 | } else { |
| 94 | free(utf8argv); |
| 95 | } |
| 96 | |
| 97 | return ret; |
| 98 | } |
| 99 | |
Erik de Castro Lopo | d0c219f | 2013-04-21 16:16:44 +1000 | [diff] [blame] | 100 | /* return number of characters in the UTF-8 string */ |
| 101 | size_t strlen_utf8(const char *str) |
| 102 | { |
| 103 | size_t len; |
| 104 | if ((len = MultiByteToWideChar(win_utf8_io_codepage, 0, str, -1, NULL, 0)) == 0) |
| 105 | len = strlen(str); |
| 106 | return len; |
| 107 | } |
| 108 | |
| 109 | /* get the console width in characters */ |
Erik de Castro Lopo | 0b736a5 | 2013-04-21 17:19:37 +1000 | [diff] [blame] | 110 | int win_get_console_width(void) |
Erik de Castro Lopo | d0c219f | 2013-04-21 16:16:44 +1000 | [diff] [blame] | 111 | { |
| 112 | int width = 80; |
| 113 | CONSOLE_SCREEN_BUFFER_INFO csbi; |
| 114 | HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); |
| 115 | if (GetConsoleScreenBufferInfo(hOut, &csbi) != 0) width = csbi.dwSize.X; |
| 116 | return width; |
| 117 | } |
| 118 | |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 119 | /* print functions */ |
| 120 | |
Erik de Castro Lopo | 0b736a5 | 2013-04-21 17:19:37 +1000 | [diff] [blame] | 121 | int print_console(FILE *stream, const wchar_t *text, uint32_t len) |
Erik de Castro Lopo | d0c219f | 2013-04-21 16:16:44 +1000 | [diff] [blame] | 122 | { |
| 123 | static HANDLE hOut; |
| 124 | static HANDLE hErr; |
| 125 | DWORD out; |
| 126 | hOut = GetStdHandle(STD_OUTPUT_HANDLE); |
| 127 | hErr = GetStdHandle(STD_ERROR_HANDLE); |
| 128 | if (stream == stdout && hOut != INVALID_HANDLE_VALUE && GetFileType(hOut) == FILE_TYPE_CHAR) { |
| 129 | if (WriteConsoleW(hOut, text, len, &out, NULL) == 0) return -1; |
| 130 | return out; |
| 131 | } else if (stream == stderr && hErr != INVALID_HANDLE_VALUE && GetFileType(hErr) == FILE_TYPE_CHAR) { |
| 132 | if (WriteConsoleW(hErr, text, len, &out, NULL) == 0) return -1; |
| 133 | return out; |
| 134 | } else { |
| 135 | int ret = fwprintf(stream, L"%s", text); |
| 136 | if (ret < 0) return ret; |
| 137 | return len; |
| 138 | } |
| 139 | } |
| 140 | |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 141 | int printf_utf8(const char *format, ...) |
| 142 | { |
| 143 | char *utmp = NULL; |
| 144 | wchar_t *wout = NULL; |
| 145 | int ret = -1; |
| 146 | |
| 147 | while (1) { |
| 148 | va_list argptr; |
| 149 | if (!(utmp = (char *)malloc(32768*sizeof(char)))) break; |
| 150 | va_start(argptr, format); |
| 151 | ret = vsprintf(utmp, format, argptr); |
| 152 | va_end(argptr); |
| 153 | if (ret < 0) break; |
| 154 | if (!(wout = wchar_from_utf8(utmp))) { |
| 155 | ret = -1; |
| 156 | break; |
| 157 | } |
Erik de Castro Lopo | d0c219f | 2013-04-21 16:16:44 +1000 | [diff] [blame] | 158 | ret = print_console(stdout, wout, wcslen(wout)); |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 159 | break; |
| 160 | } |
| 161 | if (utmp) free(utmp); |
| 162 | if (wout) free(wout); |
| 163 | |
| 164 | return ret; |
| 165 | } |
| 166 | |
| 167 | int fprintf_utf8(FILE *stream, const char *format, ...) |
| 168 | { |
| 169 | char *utmp = NULL; |
| 170 | wchar_t *wout = NULL; |
| 171 | int ret = -1; |
| 172 | |
| 173 | while (1) { |
| 174 | va_list argptr; |
| 175 | if (!(utmp = (char *)malloc(32768*sizeof(char)))) break; |
| 176 | va_start(argptr, format); |
| 177 | ret = vsprintf(utmp, format, argptr); |
| 178 | va_end(argptr); |
| 179 | if (ret < 0) break; |
| 180 | if (!(wout = wchar_from_utf8(utmp))) { |
| 181 | ret = -1; |
| 182 | break; |
| 183 | } |
Erik de Castro Lopo | d0c219f | 2013-04-21 16:16:44 +1000 | [diff] [blame] | 184 | ret = print_console(stream, wout, wcslen(wout)); |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 185 | break; |
| 186 | } |
| 187 | if (utmp) free(utmp); |
| 188 | if (wout) free(wout); |
| 189 | |
| 190 | return ret; |
| 191 | } |
| 192 | |
| 193 | int vfprintf_utf8(FILE *stream, const char *format, va_list argptr) |
| 194 | { |
| 195 | char *utmp = NULL; |
| 196 | wchar_t *wout = NULL; |
| 197 | int ret = -1; |
| 198 | |
| 199 | while (1) { |
| 200 | if (!(utmp = (char *)malloc(32768*sizeof(char)))) break; |
| 201 | if ((ret = vsprintf(utmp, format, argptr)) < 0) break; |
| 202 | if (!(wout = wchar_from_utf8(utmp))) { |
| 203 | ret = -1; |
| 204 | break; |
| 205 | } |
Erik de Castro Lopo | d0c219f | 2013-04-21 16:16:44 +1000 | [diff] [blame] | 206 | ret = print_console(stream, wout, wcslen(wout)); |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 207 | break; |
| 208 | } |
| 209 | if (utmp) free(utmp); |
| 210 | if (wout) free(wout); |
| 211 | |
| 212 | return ret; |
| 213 | } |
| 214 | |
| 215 | /* file functions */ |
| 216 | |
| 217 | FILE *fopen_utf8(const char *filename, const char *mode) |
| 218 | { |
| 219 | wchar_t *wname = NULL; |
| 220 | wchar_t *wmode = NULL; |
| 221 | FILE *f = NULL; |
| 222 | |
| 223 | while (1) { |
| 224 | if (!(wname = wchar_from_utf8(filename))) break; |
| 225 | if (!(wmode = wchar_from_utf8(mode))) break; |
| 226 | f = _wfopen(wname, wmode); |
| 227 | break; |
| 228 | } |
| 229 | if (wname) free(wname); |
| 230 | if (wmode) free(wmode); |
| 231 | |
| 232 | return f; |
| 233 | } |
| 234 | |
Erik de Castro Lopo | f44c353 | 2013-04-02 06:27:07 +1100 | [diff] [blame] | 235 | int _stat64_utf8(const char *path, struct __stat64 *buffer) |
Erik de Castro Lopo | 5705b4d | 2013-03-21 19:18:49 +1100 | [diff] [blame] | 236 | { |
| 237 | wchar_t *wpath; |
| 238 | int ret; |
| 239 | |
| 240 | if (!(wpath = wchar_from_utf8(path))) return -1; |
| 241 | ret = _wstat64(wpath, buffer); |
| 242 | free(wpath); |
| 243 | |
| 244 | return ret; |
| 245 | } |
| 246 | |
| 247 | int chmod_utf8(const char *filename, int pmode) |
| 248 | { |
| 249 | wchar_t *wname; |
| 250 | int ret; |
| 251 | |
| 252 | if (!(wname = wchar_from_utf8(filename))) return -1; |
| 253 | ret = _wchmod(wname, pmode); |
| 254 | free(wname); |
| 255 | |
| 256 | return ret; |
| 257 | } |
| 258 | |
| 259 | int utime_utf8(const char *filename, struct utimbuf *times) |
| 260 | { |
| 261 | wchar_t *wname; |
| 262 | struct _utimbuf ut; |
| 263 | int ret; |
| 264 | |
| 265 | if (!(wname = wchar_from_utf8(filename))) return -1; |
| 266 | ret = _wutime(wname, &ut); |
| 267 | free(wname); |
| 268 | |
| 269 | if (ret != -1) { |
| 270 | if (sizeof(*times) == sizeof(ut)) { |
| 271 | memcpy(times, &ut, sizeof(ut)); |
| 272 | } else { |
| 273 | times->actime = ut.actime; |
| 274 | times->modtime = ut.modtime; |
| 275 | } |
| 276 | } |
| 277 | |
| 278 | return ret; |
| 279 | } |
| 280 | |
| 281 | int unlink_utf8(const char *filename) |
| 282 | { |
| 283 | wchar_t *wname; |
| 284 | int ret; |
| 285 | |
| 286 | if (!(wname = wchar_from_utf8(filename))) return -1; |
| 287 | ret = _wunlink(wname); |
| 288 | free(wname); |
| 289 | |
| 290 | return ret; |
| 291 | } |
| 292 | |
| 293 | int rename_utf8(const char *oldname, const char *newname) |
| 294 | { |
| 295 | wchar_t *wold = NULL; |
| 296 | wchar_t *wnew = NULL; |
| 297 | int ret = -1; |
| 298 | |
| 299 | while (1) { |
| 300 | if (!(wold = wchar_from_utf8(oldname))) break; |
| 301 | if (!(wnew = wchar_from_utf8(newname))) break; |
| 302 | ret = _wrename(wold, wnew); |
| 303 | break; |
| 304 | } |
| 305 | if (wold) free(wold); |
| 306 | if (wnew) free(wnew); |
| 307 | |
| 308 | return ret; |
| 309 | } |
Erik de Castro Lopo | 52fab8b | 2013-04-21 17:53:02 +1000 | [diff] [blame^] | 310 | |
| 311 | HANDLE WINAPI CreateFile_utf8(const char *lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) |
| 312 | { |
| 313 | wchar_t *wname; |
| 314 | HANDLE handle = INVALID_HANDLE_VALUE; |
| 315 | |
| 316 | if ((wname = wchar_from_utf8(lpFileName)) != NULL) { |
| 317 | handle = CreateFileW(wname, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile); |
| 318 | free(wname); |
| 319 | } |
| 320 | |
| 321 | return handle; |
| 322 | } |