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 }