home *** CD-ROM | disk | FTP | other *** search
/ vim.ftp.fu-berlin.de / 2015-02-03.vim.ftp.fu-berlin.de.tar / vim.ftp.fu-berlin.de / patches / 6.1.229 < prev    next >
Encoding:
Internet Message Format  |  2002-10-14  |  8.0 KB
  1. To: vim-dev@vim.org
  2. Subject: Patch 6.1.229
  3. Fcc: outbox
  4. From: Bram Moolenaar <Bram@moolenaar.net>
  5. Mime-Version: 1.0
  6. Content-Type: text/plain; charset=ISO-8859-1
  7. Content-Transfer-Encoding: 8bit
  8. ------------
  9.  
  10. Patch 6.1.229
  11. Problem:    Win32: Conversion to/from often used codepages requires the iconv
  12.         library, which is not always available.
  13. Solution:   Use standard MS-Windows functions for the conversion when
  14.         possible. (mostly by Glenn Maynard)
  15.         Also fixes missing declaration for patch 6.1.220.
  16. Files:        src/fileio.c
  17.  
  18.  
  19. *** ../vim61.228/src/fileio.c    Sun Oct 13 20:08:14 2002
  20. --- src/fileio.c    Tue Oct 15 20:35:02 2002
  21. ***************
  22. *** 78,83 ****
  23. --- 78,88 ----
  24.   # define FIO_UCS2    0x04    /* convert UCS-2 */
  25.   # define FIO_UCS4    0x08    /* convert UCS-4 */
  26.   # define FIO_UTF16    0x10    /* convert UTF-16 */
  27. + # ifdef WIN3264
  28. + #  define FIO_CODEPAGE    0x20    /* convert MS-Windows codepage */
  29. + #  define FIO_PUT_CP(x) (((x) & 0xffff) << 16)    /* put codepage in top word */
  30. + #  define FIO_GET_CP(x)    (((x)>>16) & 0xffff)    /* get codepage from top word */
  31. + # endif
  32.   # define FIO_ENDIAN_L    0x80    /* little endian */
  33.   # define FIO_ENCRYPTED    0x1000    /* encrypt written bytes */
  34.   # define FIO_NOCONVERT    0x2000    /* skip encoding conversion */
  35. ***************
  36. *** 125,131 ****
  37. --- 130,140 ----
  38.   static int get_fio_flags __ARGS((char_u *ptr));
  39.   static char_u *check_for_bom __ARGS((char_u *p, long size, int *lenp, int flags));
  40.   static int make_bom __ARGS((char_u *buf, char_u *name));
  41. + # ifdef WIN3264
  42. + static int get_win_fio_flags __ARGS((char_u *ptr));
  43. + # endif
  44.   #endif
  45. + static int move_lines __ARGS((buf_T *frombuf, buf_T *tobuf));
  46.   
  47.   static linenr_T    write_no_eol_lnum = 0;    /* non-zero lnum when last line of
  48.                          next binary write should not have
  49. ***************
  50. *** 851,856 ****
  51. --- 861,874 ----
  52.       else if (enc_utf8 || STRCMP(p_enc, "latin1") == 0)
  53.           fio_flags = get_fio_flags(fenc);
  54.   
  55. + # ifdef WIN3264
  56. +     /*
  57. +      * Conversion from an MS-Windows codepage to UTF-8 is handled here.
  58. +      */
  59. +     if (fio_flags == 0 && enc_utf8)
  60. +         fio_flags = get_win_fio_flags(fenc);
  61. + # endif
  62. + 
  63.   # ifdef USE_ICONV
  64.       /*
  65.        * Try using iconv() if we can't convert internally.
  66. ***************
  67. *** 1007,1012 ****
  68. --- 1025,1034 ----
  69.               size = (size * 2 / 3) & ~3;
  70.           else if (fio_flags == FIO_UCSBOM)
  71.               size = size / ICONV_MULT;    /* worst case */
  72. + # ifdef WIN3264
  73. +         else if (fio_flags & FIO_CODEPAGE)
  74. +             size = size / ICONV_MULT;    /* also worst case */
  75. + # endif
  76.   #endif
  77.   
  78.   #ifdef FEAT_MBYTE
  79. ***************
  80. *** 1213,1218 ****
  81. --- 1235,1301 ----
  82.           }
  83.   # endif
  84.   
  85. + # ifdef WIN3264
  86. +         if (fio_flags & FIO_CODEPAGE)
  87. +         {
  88. +         /*
  89. +          * Conversion from an MS-Windows codepage to UTF-8, using
  90. +          * standard MS-Windows functions.
  91. +          */
  92. +         char_u    *ucsp;
  93. +         size_t    from_size;
  94. +         int    needed;
  95. +         char_u    *p;
  96. +         int    u8c;
  97. + 
  98. +         /*
  99. +          * We can't tell if the last byte of an MBCS string is valid
  100. +          * and MultiByteToWideChar() returns zero if it isn't.
  101. +          * Try the whole string, and if that fails, bump the last byte
  102. +          * into conv_rest and try again.
  103. +          */
  104. +         from_size = size;
  105. +         needed = MultiByteToWideChar(FIO_GET_CP(fio_flags),
  106. +                    MB_ERR_INVALID_CHARS, (LPCSTR)ptr, from_size,
  107. +                                      NULL, 0);
  108. +         if (needed == 0)
  109. +         {
  110. +             conv_rest[0] = ptr[from_size - 1];
  111. +             conv_restlen = 1;
  112. +             --from_size;
  113. +             needed = MultiByteToWideChar(FIO_GET_CP(fio_flags),
  114. +                    MB_ERR_INVALID_CHARS, (LPCSTR)ptr, from_size,
  115. +                                      NULL, 0);
  116. +         }
  117. + 
  118. +         /* If there really is a conversion error, try using another
  119. +          * conversion. */
  120. +         if (needed == 0)
  121. +             goto rewind_retry;
  122. + 
  123. +         /* Put the result of conversion to UCS-2 at the end of the
  124. +          * buffer, then convert from UCS-2 to UTF-8 into the start of
  125. +          * the buffer.  If there is not enough space just fail, there
  126. +          * is probably something wrong. */
  127. +         ucsp = ptr + real_size - (needed * sizeof(WCHAR));
  128. +         if (ucsp < ptr + size)
  129. +             goto rewind_retry;
  130. +         needed = MultiByteToWideChar(FIO_GET_CP(fio_flags),
  131. +                         MB_ERR_INVALID_CHARS, (LPCSTR)ptr,
  132. +                          from_size, (LPWSTR)ucsp, needed);
  133. + 
  134. +         /* Now go from UCS-2 to UTF-8. */
  135. +         p = ptr;
  136. +         for (; needed > 0; --needed)
  137. +         {
  138. +             u8c = *ucsp++;
  139. +             u8c += (*ucsp++ << 8);
  140. +             p += utf_char2bytes(u8c, p);
  141. +         }
  142. +         size = p - ptr;
  143. +         }
  144. +         else
  145. + # endif
  146.           if (fio_flags != 0)
  147.           {
  148.           int    u8c;
  149. ***************
  150. *** 3146,3151 ****
  151. --- 3229,3248 ----
  152.       }
  153.       }
  154.   
  155. + # ifdef WIN3264
  156. +     if (converted && wb_flags == 0 && get_win_fio_flags(fenc))
  157. +     {
  158. +     wb_flags = get_win_fio_flags(fenc);
  159. + 
  160. +     /* Convert UTF-8 -> UCS-2 and UCS-2 -> DBCS.  Worst-case * 4: */
  161. +     write_info.bw_conv_buflen = bufsize * 4;
  162. +     write_info.bw_conv_buf
  163. +                 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
  164. +     if (write_info.bw_conv_buf == NULL)
  165. +         end = 0;
  166. +     }
  167. + # endif
  168. + 
  169.   # if defined(FEAT_EVAL) || defined(USE_ICONV)
  170.       if (converted && wb_flags == 0)
  171.       {
  172. ***************
  173. *** 4126,4131 ****
  174. --- 4223,4291 ----
  175.           }
  176.       }
  177.   
  178. + # ifdef WIN3264
  179. +     else if (flags & FIO_CODEPAGE)
  180. +     {
  181. +         /*
  182. +          * Convert UTF-8 to UCS-2 and then to MS-Windows codepage.
  183. +          */
  184. +         char_u    *from;
  185. +         size_t    fromlen;
  186. +         char_u    *to;
  187. +         int        u8c;
  188. +         BOOL    bad = FALSE;
  189. + 
  190. +         if (ip->bw_restlen > 0)
  191. +         {
  192. +         /* Need to concatenate the remainder of the previous call and
  193. +          * the bytes of the current call.  Use the end of the
  194. +          * conversion buffer for this. */
  195. +         fromlen = len + ip->bw_restlen;
  196. +         from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
  197. +         mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen);
  198. +         mch_memmove(from + ip->bw_restlen, buf, (size_t)len);
  199. +         }
  200. +         else
  201. +         {
  202. +         from = buf;
  203. +         fromlen = len;
  204. +         }
  205. + 
  206. +         /* Convert from UTF-8 to UCS-2, to the start of the buffer.
  207. +          * The buffer has been allocated to be big enough. */
  208. +         to = ip->bw_conv_buf;
  209. +         while (fromlen > 0)
  210. +         {
  211. +         n = utf_ptr2len_check_len(from, fromlen);
  212. +         if (n > (int)fromlen)
  213. +             break;
  214. +         u8c = utf_ptr2char(from);
  215. +         *to++ = (u8c & 0xff);
  216. +         *to++ = (u8c >> 8);
  217. +         fromlen -= n;
  218. +         from += n;
  219. +         }
  220. + 
  221. +         /* copy remainder to ip->bw_rest[] to be used for the next call. */
  222. +         mch_memmove(ip->bw_rest, from, fromlen);
  223. +         ip->bw_restlen = fromlen;
  224. + 
  225. +         /* Convert from UCS-2 to the codepage, using the remainder of the
  226. +          * conversion buffer.  If the conversion uses the default
  227. +          * character "0", the data doesn't fit in this encoding, so fail. */
  228. +         fromlen = to - ip->bw_conv_buf;
  229. +         len = WideCharToMultiByte(FIO_GET_CP(flags), 0,
  230. +             (LPCWSTR)ip->bw_conv_buf, (int)fromlen / sizeof(WCHAR),
  231. +             (LPSTR)to, ip->bw_conv_buflen - fromlen, 0, &bad);
  232. +         if (bad)
  233. +         {
  234. +         ip->bw_conv_error = TRUE;
  235. +         return FAIL;
  236. +         }
  237. +         buf = to;
  238. +     }
  239. + # endif
  240. + 
  241.   # ifdef USE_ICONV
  242.       if (ip->bw_iconv_fd != (iconv_t)-1)
  243.       {
  244. ***************
  245. *** 4364,4369 ****
  246. --- 4524,4544 ----
  247.       /* must be ENC_DBCS, requires iconv() */
  248.       return 0;
  249.   }
  250. + 
  251. + #ifdef WIN3264
  252. + /*
  253. +  * Check "ptr" for a MS-Windows codepage name and return the FIO_ flags needed
  254. +  * for the conversion MS-Windows can do for us.
  255. +  */
  256. +     static int
  257. + get_win_fio_flags(ptr)
  258. +     char_u    *ptr;
  259. + {
  260. +     if (ptr[0] == 'c' && ptr[1] == 'p' && isdigit(ptr[2]))
  261. +     return FIO_PUT_CP(atoi(ptr + 2)) | FIO_CODEPAGE;
  262. +     return 0;
  263. + }
  264. + #endif
  265.   
  266.   /*
  267.    * Check for a Unicode BOM (Byte Order Mark) at the start of p[size].
  268. *** ../vim61.228/src/version.c    Tue Oct 15 21:05:16 2002
  269. --- src/version.c    Tue Oct 15 21:09:55 2002
  270. ***************
  271. *** 608,609 ****
  272. --- 608,611 ----
  273.   {   /* Add new patch number below this line */
  274. + /**/
  275. +     229,
  276.   /**/
  277.  
  278. -- 
  279. hundred-and-one symptoms of being an internet addict:
  280. 235. You start naming your kids Pascal, COBOL, Algol and Fortran.
  281.  
  282.  ///  Bram Moolenaar -- Bram@moolenaar.net -- http://www.moolenaar.net  \\\
  283. ///          Creator of Vim - Vi IMproved -- http://www.vim.org          \\\
  284. \\\           Project leader for A-A-P -- http://www.a-a-p.org           ///
  285.  \\\ Lord Of The Rings helps Uganda - http://iccf-holland.org/lotr.html ///
  286.