src/share/win_utf8_io/win_utf8_io.c

   1
   2 #if HAVE_CONFIG_H
   3 #  include <config.h>
   4 #endif
   5
   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
  15 #include "share/compat.h"
  16 #include "share/win_utf8_io.h"
  17 #include "share/compat.h"
  18
  19 static UINT win_utf8_io_codepage = CP_ACP;
  20
  21 /* convert WCHAR stored Unicode string to UTF-8. Caller is responsible for freeing memory */
  22 static
  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 */
  40 static
  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) {
  49                 if (MultiByteToWideChar(win_utf8_io_codepage, 0, str, len, widestr, len) == 0) {
  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
  87         FreeLibrary(handle);
  88
  89         if (ret == 0) {
  90                 win_utf8_io_codepage = CP_UTF8;
  91                 *argc = wargc;
  92                 *argv = utf8argv;
  93         } else {
  94                 free(utf8argv);
  95         }
  96
  97         return ret;
  98 }
  99
 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 */
 110 int win_get_console_width(void)
 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
 119 /* print functions */
 120
 121 int print_console(FILE *stream, const wchar_t *text, uint32_t len)
 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
 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                 }
 158                 ret = print_console(stdout, wout, wcslen(wout));
 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                 }
 184                 ret = print_console(stream, wout, wcslen(wout));
 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                 }
 206                 ret = print_console(stream, wout, wcslen(wout));
 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
 235 int _stat64_utf8(const char *path, struct __stat64 *buffer)
 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 }