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