cygwin.c: Change variable names

This makes the names consistent in the two parallel functions, in
preparation for folding the two into one.

This maps win_path => converted_path
          wbuf     => wsrc
          wpath    => wconverted

1 files changed, 53 insertions, 53 deletions

diff --git a/cygwin/cygwin.c b/cygwin/cygwin.c
index cc681e0c18..299bdcd2e4 100644
--- a/cygwin/cygwin.c
+++ b/cygwin/cygwin.c
@@ -160,17 +160,17 @@ leave:
 
 #if (CYGWIN_VERSION_API_MINOR >= 181)
 char*
-wide_to_utf8(const wchar_t *wbuf)
+wide_to_utf8(const wchar_t *wsrc)
 {
     dTHX;
-    const Size_t wlen = (wcslen(wbuf) + 1) * sizeof(wchar_t);
+    const Size_t wlen = (wcslen(wsrc) + 1) * sizeof(wchar_t);
 
     /* Max expansion factor is 3/2 */
     Size_t blen = wlen * 3 / 2;
 
     char *buf = (char *) safemalloc(blen);
 
-    utf16_to_utf8((U8 *) wbuf, buf, wlen, &blen);
+    utf16_to_utf8((U8 *) wsrc, buf, wlen, &blen);
 
     return buf;
 }
@@ -179,7 +179,7 @@ wchar_t*
 utf8_to_wide(const char *buf)
 {
     dTHX;
-    wchar_t *wbuf;
+    wchar_t *wsrc;
     mbstate_t mbs;
     char *oldlocale;
     int wlen = sizeof(wchar_t)*strlen(buf);
@@ -189,15 +189,15 @@ utf8_to_wide(const char *buf)
     oldlocale = setlocale(LC_CTYPE, NULL);
 
     setlocale(LC_CTYPE, "utf-8");
-    wbuf = (wchar_t *) safemalloc(wlen);
-    wlen = mbsrtowcs(wbuf, (const char**)&buf, wlen, &mbs);
+    wsrc = (wchar_t *) safemalloc(wlen);
+    wlen = mbsrtowcs(wsrc, (const char**)&buf, wlen, &mbs);
 
     if (oldlocale) setlocale(LC_CTYPE, oldlocale);
     else setlocale(LC_CTYPE, "C");
 
     SETLOCALE_UNLOCK;
 
-    return wbuf;
+    return wsrc;
 }
 #endif /* cygwin 1.7 */
 
@@ -270,7 +270,7 @@ XS(XS_Cygwin_win_to_posix_path)
     STRLEN len;
     int err = 0;
     char *src_path;
-    char *posix_path;
+    char *converted_path;
     int isutf8 = 0;
 
     if (items < 1 || items > 2)
@@ -291,8 +291,8 @@ XS(XS_Cygwin_win_to_posix_path)
     if (isutf8) {
         int what = absolute_flag ? CCP_WIN_W_TO_POSIX : CCP_WIN_W_TO_POSIX | CCP_RELATIVE;
         STRLEN wlen = sizeof(wchar_t)*(len + PATH_LEN_GUESS);
-        wchar_t *wpath = (wchar_t *) safemalloc(sizeof(wchar_t)*len);
-        wchar_t *wbuf = (wchar_t *) safemalloc(wlen);
+        wchar_t *wconverted = (wchar_t *) safemalloc(sizeof(wchar_t)*len);
+        wchar_t *wsrc = (wchar_t *) safemalloc(wlen);
         if (!IN_BYTES) {
             mbstate_t mbs;
             char *oldlocale;
@@ -301,55 +301,55 @@ XS(XS_Cygwin_win_to_posix_path)
 
             oldlocale = setlocale(LC_CTYPE, NULL);
             setlocale(LC_CTYPE, "utf-8");
-            wlen = mbsrtowcs(wpath, (const char**)&src_path, wlen, &mbs);
+            wlen = mbsrtowcs(wconverted, (const char**)&src_path, wlen, &mbs);
             if (wlen > 0)
-                err = cygwin_conv_path(what, wpath, wbuf, wlen);
+                err = cygwin_conv_path(what, wconverted, wsrc, wlen);
             if (oldlocale) setlocale(LC_CTYPE, oldlocale);
             else setlocale(LC_CTYPE, "C");
 
             SETLOCALE_UNLOCK;
         } else { /* use bytes; assume already UTF-16 encoded bytestream */
-            err = cygwin_conv_path(what, src_path, wbuf, wlen);
+            err = cygwin_conv_path(what, src_path, wsrc, wlen);
         }
         if (err == ENOSPC) { /* our space assumption was wrong, not enough space */
-            int newlen = cygwin_conv_path(what, wpath, wbuf, 0);
-            wbuf = (wchar_t *) realloc(&wbuf, newlen);
-            err = cygwin_conv_path(what, wpath, wbuf, newlen);
+            int newlen = cygwin_conv_path(what, wconverted, wsrc, 0);
+            wsrc = (wchar_t *) realloc(&wsrc, newlen);
+            err = cygwin_conv_path(what, wconverted, wsrc, newlen);
             wlen = newlen;
         }
 
-        posix_path = wide_to_utf8(wpath);
+        converted_path = wide_to_utf8(wconverted);
 
-        safefree(wpath);
-        safefree(wbuf);
+        safefree(wconverted);
+        safefree(wsrc);
     } else {
         int what = absolute_flag ? CCP_WIN_A_TO_POSIX : CCP_WIN_A_TO_POSIX | CCP_RELATIVE;
-        posix_path = (char *) safemalloc (len + PATH_LEN_GUESS);
-        err = cygwin_conv_path(what, src_path, posix_path, len + PATH_LEN_GUESS);
+        converted_path = (char *) safemalloc (len + PATH_LEN_GUESS);
+        err = cygwin_conv_path(what, src_path, converted_path, len + PATH_LEN_GUESS);
         if (err == ENOSPC) { /* our space assumption was wrong, not enough space */
-            int newlen = cygwin_conv_path(what, src_path, posix_path, 0);
-            posix_path = (char *) realloc(&posix_path, newlen);
-            err = cygwin_conv_path(what, src_path, posix_path, newlen);
+            int newlen = cygwin_conv_path(what, src_path, converted_path, 0);
+            converted_path = (char *) realloc(&converted_path, newlen);
+            err = cygwin_conv_path(what, src_path, converted_path, newlen);
         }
     }
 #else
-    posix_path = (char *) safemalloc (len + PATH_LEN_GUESS);
+    converted_path = (char *) safemalloc (len + PATH_LEN_GUESS);
     if (absolute_flag)
-        err = cygwin_conv_to_full_posix_path(src_path, posix_path);
+        err = cygwin_conv_to_full_posix_path(src_path, converted_path);
     else
-        err = cygwin_conv_to_posix_path(src_path, posix_path);
+        err = cygwin_conv_to_posix_path(src_path, converted_path);
 #endif
     if (!err) {
         EXTEND(SP, 1);
-        ST(0) = sv_2mortal(newSVpv(posix_path, 0));
+        ST(0) = sv_2mortal(newSVpv(converted_path, 0));
         if (isutf8) { /* src was utf-8, so result should also */
             /* TODO: convert ANSI (local windows encoding) to utf-8 on cygwin-1.5 */
             SvUTF8_on(ST(0));
         }
-        safefree(posix_path);
+        safefree(converted_path);
         XSRETURN(1);
     } else {
-        safefree(posix_path);
+        safefree(converted_path);
         XSRETURN_UNDEF;
     }
 }
@@ -360,7 +360,7 @@ XS(XS_Cygwin_posix_to_win_path)
     int absolute_flag = 0;
     STRLEN len;
     int err = 0;
-    char *src_path, *win_path;
+    char *src_path, *converted_path;
     int isutf8 = 0;
 
     if (items < 1 || items > 2)
@@ -380,8 +380,8 @@ XS(XS_Cygwin_posix_to_win_path)
     if (isutf8) {
         int what = absolute_flag ? CCP_POSIX_TO_WIN_W : CCP_POSIX_TO_WIN_W | CCP_RELATIVE;
         int wlen = sizeof(wchar_t)*(len + PATH_LEN_GUESS);
-        wchar_t *wpath = (wchar_t *) safemalloc(sizeof(wchar_t)*len);
-        wchar_t *wbuf = (wchar_t *) safemalloc(wlen);
+        wchar_t *wconverted = (wchar_t *) safemalloc(sizeof(wchar_t)*len);
+        wchar_t *wsrc = (wchar_t *) safemalloc(wlen);
 
         if (!IN_BYTES) {
             mbstate_t mbs;
@@ -392,57 +392,57 @@ XS(XS_Cygwin_posix_to_win_path)
             oldlocale = setlocale(LC_CTYPE, NULL);
             setlocale(LC_CTYPE, "utf-8");
 
-            wlen = mbsrtowcs(wpath, (const char**)&src_path, wlen, &mbs);
+            wlen = mbsrtowcs(wconverted, (const char**)&src_path, wlen, &mbs);
             if (wlen > 0)
-                err = cygwin_conv_path(what, wpath, wbuf, wlen);
+                err = cygwin_conv_path(what, wconverted, wsrc, wlen);
 
             if (oldlocale) setlocale(LC_CTYPE, oldlocale);
             else setlocale(LC_CTYPE, "C");
 
             SETLOCALE_UNLOCK;
         } else { /* use bytes; assume already UTF-16 encoded bytestream */
-            err = cygwin_conv_path(what, src_path, wbuf, wlen);
+            err = cygwin_conv_path(what, src_path, wsrc, wlen);
         }
         if (err == ENOSPC) { /* our space assumption was wrong, not enough space */
-            int newlen = cygwin_conv_path(what, wpath, wbuf, 0);
-            wbuf = (wchar_t *) realloc(&wbuf, newlen);
-            err = cygwin_conv_path(what, wpath, wbuf, newlen);
+            int newlen = cygwin_conv_path(what, wconverted, wsrc, 0);
+            wsrc = (wchar_t *) realloc(&wsrc, newlen);
+            err = cygwin_conv_path(what, wconverted, wsrc, newlen);
             wlen = newlen;
         }
 
-        win_path = wide_to_utf8(wpath);
+        converted_path = wide_to_utf8(wconverted);
 
-        safefree(wpath);
-        safefree(wbuf);
+        safefree(wconverted);
+        safefree(wsrc);
     } else {
         int what = absolute_flag ? CCP_POSIX_TO_WIN_A : CCP_POSIX_TO_WIN_A | CCP_RELATIVE;
-        win_path = (char *) safemalloc(len + PATH_LEN_GUESS);
-        err = cygwin_conv_path(what, src_path, win_path, len + PATH_LEN_GUESS);
+        converted_path = (char *) safemalloc(len + PATH_LEN_GUESS);
+        err = cygwin_conv_path(what, src_path, converted_path, len + PATH_LEN_GUESS);
         if (err == ENOSPC) { /* our space assumption was wrong, not enough space */
-            int newlen = cygwin_conv_path(what, src_path, win_path, 0);
-            win_path = (char *) realloc(&win_path, newlen);
-            err = cygwin_conv_path(what, src_path, win_path, newlen);
+            int newlen = cygwin_conv_path(what, src_path, converted_path, 0);
+            converted_path = (char *) realloc(&converted_path, newlen);
+            err = cygwin_conv_path(what, src_path, converted_path, newlen);
         }
     }
 #else
     if (isutf8)
         Perl_warn(aTHX_ "can't convert utf8 path");
-    win_path = (char *) safemalloc(len + PATH_LEN_GUESS);
+    converted_path = (char *) safemalloc(len + PATH_LEN_GUESS);
     if (absolute_flag)
-        err = cygwin_conv_to_full_win32_path(src_path, win_path);
+        err = cygwin_conv_to_full_win32_path(src_path, converted_path);
     else
-        err = cygwin_conv_to_win32_path(src_path, win_path);
+        err = cygwin_conv_to_win32_path(src_path, converted_path);
 #endif
     if (!err) {
         EXTEND(SP, 1);
-        ST(0) = sv_2mortal(newSVpv(win_path, 0));
+        ST(0) = sv_2mortal(newSVpv(converted_path, 0));
         if (isutf8) {
             SvUTF8_on(ST(0));
         }
-        safefree(win_path);
+        safefree(converted_path);
         XSRETURN(1);
     } else {
-        safefree(win_path);
+        safefree(converted_path);
         XSRETURN_UNDEF;
     }
 }