vim72-20100325-kaoriya-w64j.zip
[MacVim/KaoriYa.git] / src / os_mac_conv.c
blob7930189988a2cdee07a82431743f74a6337cde5e
1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9 /*
10 * os_mac_conv.c: Code specifically for Mac string conversions.
12 * This code has been put in a separate file to avoid the conflicts that are
13 * caused by including both the X11 and Carbon header files.
16 #define NO_X11_INCLUDES
17 #include "vim.h"
19 #if defined(MACOS_CONVERT) || defined(PROTO)
20 # ifdef PROTO
21 /* A few dummy types to be able to generate function prototypes. */
22 typedef int UniChar;
23 typedef int *TECObjectRef;
24 typedef int CFStringRef;
25 # endif
27 static char_u *mac_utf16_to_utf8 __ARGS((UniChar *from, size_t fromLen, size_t *actualLen));
28 static UniChar *mac_utf8_to_utf16 __ARGS((char_u *from, size_t fromLen, size_t *actualLen));
30 /* Converter for composing decomposed HFS+ file paths */
31 static TECObjectRef gPathConverter;
32 /* Converter used by mac_utf16_to_utf8 */
33 static TECObjectRef gUTF16ToUTF8Converter;
36 * A Mac version of string_convert_ext() for special cases.
38 char_u *
39 mac_string_convert(ptr, len, lenp, fail_on_error, from_enc, to_enc, unconvlenp)
40 char_u *ptr;
41 int len;
42 int *lenp;
43 int fail_on_error;
44 int from_enc;
45 int to_enc;
46 int *unconvlenp;
48 char_u *retval, *d;
49 CFStringRef cfstr;
50 int buflen, in, out, l, i;
51 CFStringEncoding from;
52 CFStringEncoding to;
54 switch (from_enc)
56 case 'l': from = kCFStringEncodingISOLatin1; break;
57 case 'm': from = kCFStringEncodingMacRoman; break;
58 case 'u': from = kCFStringEncodingUTF8; break;
59 default: return NULL;
61 switch (to_enc)
63 case 'l': to = kCFStringEncodingISOLatin1; break;
64 case 'm': to = kCFStringEncodingMacRoman; break;
65 case 'u': to = kCFStringEncodingUTF8; break;
66 default: return NULL;
69 if (unconvlenp != NULL)
70 *unconvlenp = 0;
71 cfstr = CFStringCreateWithBytes(NULL, ptr, len, from, 0);
73 if(cfstr == NULL)
74 fprintf(stderr, "Encoding failed\n");
75 /* When conversion failed, try excluding bytes from the end, helps when
76 * there is an incomplete byte sequence. Only do up to 6 bytes to avoid
77 * looping a long time when there really is something unconvertible. */
78 while (cfstr == NULL && unconvlenp != NULL && len > 1 && *unconvlenp < 6)
80 --len;
81 ++*unconvlenp;
82 cfstr = CFStringCreateWithBytes(NULL, ptr, len, from, 0);
84 if (cfstr == NULL)
85 return NULL;
87 if (to == kCFStringEncodingUTF8)
88 buflen = len * 6 + 1;
89 else
90 buflen = len + 1;
91 retval = alloc(buflen);
92 if (retval == NULL)
94 CFRelease(cfstr);
95 return NULL;
98 #if 0
99 CFRange convertRange = CFRangeMake(0, CFStringGetLength(cfstr));
100 /* Determine output buffer size */
101 CFStringGetBytes(cfstr, convertRange, to, NULL, FALSE, NULL, 0, (CFIndex *)&buflen);
102 retval = (buflen > 0) ? alloc(buflen) : NULL;
103 if (retval == NULL) {
104 CFRelease(cfstr);
105 return NULL;
108 if (lenp)
109 *lenp = buflen / sizeof(char_u);
111 if (!CFStringGetBytes(cfstr, convertRange, to, NULL, FALSE, retval, buflen, NULL))
112 #endif
113 if (!CFStringGetCString(cfstr, (char *)retval, buflen, to))
115 CFRelease(cfstr);
116 if (fail_on_error)
118 vim_free(retval);
119 return NULL;
122 fprintf(stderr, "Trying char-by-char conversion...\n");
123 /* conversion failed for the whole string, but maybe it will work
124 * for each character */
125 for (d = retval, in = 0, out = 0; in < len && out < buflen - 1;)
127 if (from == kCFStringEncodingUTF8)
128 l = utf_ptr2len(ptr + in);
129 else
130 l = 1;
131 cfstr = CFStringCreateWithBytes(NULL, ptr + in, l, from, 0);
132 if (cfstr == NULL)
134 *d++ = '?';
135 out++;
137 else
139 if (!CFStringGetCString(cfstr, (char *)d, buflen - out, to))
141 *d++ = '?';
142 out++;
144 else
146 i = STRLEN(d);
147 d += i;
148 out += i;
150 CFRelease(cfstr);
152 in += l;
154 *d = NUL;
155 if (lenp != NULL)
156 *lenp = out;
157 return retval;
159 CFRelease(cfstr);
160 if (lenp != NULL)
161 *lenp = STRLEN(retval);
163 return retval;
167 * Conversion from Apple MacRoman char encoding to UTF-8 or latin1, using
168 * standard Carbon framework.
169 * Input: "ptr[*sizep]".
170 * "real_size" is the size of the buffer that "ptr" points to.
171 * output is in-place, "sizep" is adjusted.
172 * Returns OK or FAIL.
175 macroman2enc(ptr, sizep, real_size)
176 char_u *ptr;
177 long *sizep;
178 long real_size;
180 CFStringRef cfstr;
181 CFRange r;
182 CFIndex len = *sizep;
184 /* MacRoman is an 8-bit encoding, no need to move bytes to
185 * conv_rest[]. */
186 cfstr = CFStringCreateWithBytes(NULL, ptr, len,
187 kCFStringEncodingMacRoman, 0);
189 * If there is a conversion error, try using another
190 * conversion.
192 if (cfstr == NULL)
193 return FAIL;
195 r.location = 0;
196 r.length = CFStringGetLength(cfstr);
197 if (r.length != CFStringGetBytes(cfstr, r,
198 (enc_utf8) ? kCFStringEncodingUTF8 : kCFStringEncodingISOLatin1,
199 0, /* no lossy conversion */
200 0, /* not external representation */
201 ptr + *sizep, real_size - *sizep, &len))
203 CFRelease(cfstr);
204 return FAIL;
206 CFRelease(cfstr);
207 mch_memmove(ptr, ptr + *sizep, len);
208 *sizep = len;
210 return OK;
214 * Conversion from UTF-8 or latin1 to MacRoman.
215 * Input: "from[fromlen]"
216 * Output: "to[maxtolen]" length in "*tolenp"
217 * Unconverted rest in rest[*restlenp].
218 * Returns OK or FAIL.
221 enc2macroman(from, fromlen, to, tolenp, maxtolen, rest, restlenp)
222 char_u *from;
223 size_t fromlen;
224 char_u *to;
225 int *tolenp;
226 int maxtolen;
227 char_u *rest;
228 int *restlenp;
230 CFStringRef cfstr;
231 CFRange r;
232 CFIndex l;
234 *restlenp = 0;
235 cfstr = CFStringCreateWithBytes(NULL, from, fromlen,
236 (enc_utf8) ? kCFStringEncodingUTF8 : kCFStringEncodingISOLatin1,
238 while (cfstr == NULL && *restlenp < 3 && fromlen > 1)
240 rest[*restlenp++] = from[--fromlen];
241 cfstr = CFStringCreateWithBytes(NULL, from, fromlen,
242 (enc_utf8) ? kCFStringEncodingUTF8 : kCFStringEncodingISOLatin1,
245 if (cfstr == NULL)
246 return FAIL;
248 r.location = 0;
249 r.length = CFStringGetLength(cfstr);
250 if (r.length != CFStringGetBytes(cfstr, r,
251 kCFStringEncodingMacRoman,
252 0, /* no lossy conversion */
253 0, /* not external representation (since vim
254 * handles this internally */
255 to, maxtolen, &l))
257 CFRelease(cfstr);
258 return FAIL;
260 CFRelease(cfstr);
261 *tolenp = l;
262 return OK;
266 * Initializes text converters
268 void
269 mac_conv_init()
271 TextEncoding utf8_encoding;
272 TextEncoding utf8_hfsplus_encoding;
273 TextEncoding utf8_canon_encoding;
274 TextEncoding utf16_encoding;
276 utf8_encoding = CreateTextEncoding(kTextEncodingUnicodeDefault,
277 kTextEncodingDefaultVariant, kUnicodeUTF8Format);
278 utf8_hfsplus_encoding = CreateTextEncoding(kTextEncodingUnicodeDefault,
279 kUnicodeHFSPlusCompVariant, kUnicodeUTF8Format);
280 utf8_canon_encoding = CreateTextEncoding(kTextEncodingUnicodeDefault,
281 kUnicodeCanonicalCompVariant, kUnicodeUTF8Format);
282 utf16_encoding = CreateTextEncoding(kTextEncodingUnicodeDefault,
283 kTextEncodingDefaultVariant, kUnicode16BitFormat);
285 if (TECCreateConverter(&gPathConverter, utf8_encoding,
286 utf8_hfsplus_encoding) != noErr)
287 gPathConverter = NULL;
289 if (TECCreateConverter(&gUTF16ToUTF8Converter, utf16_encoding,
290 utf8_canon_encoding) != noErr)
292 /* On pre-10.3, Unicode normalization is not available so
293 * fall back to non-normalizing converter */
294 if (TECCreateConverter(&gUTF16ToUTF8Converter, utf16_encoding,
295 utf8_encoding) != noErr)
296 gUTF16ToUTF8Converter = NULL;
301 * Destroys text converters
303 void
304 mac_conv_cleanup()
306 if (gUTF16ToUTF8Converter)
308 TECDisposeConverter(gUTF16ToUTF8Converter);
309 gUTF16ToUTF8Converter = NULL;
312 if (gPathConverter)
314 TECDisposeConverter(gPathConverter);
315 gPathConverter = NULL;
320 * Conversion from UTF-16 UniChars to 'encoding'
321 * The function signature uses the real type of UniChar (as typedef'ed in
322 * CFBase.h) to avoid clashes with X11 header files in the .pro file
324 char_u *
325 mac_utf16_to_enc(from, fromLen, actualLen)
326 unsigned short *from;
327 size_t fromLen;
328 size_t *actualLen;
330 /* Following code borrows somewhat from os_mswin.c */
331 vimconv_T conv;
332 size_t utf8_len;
333 char_u *utf8_str;
334 char_u *result = NULL;
336 /* Convert to utf-8 first, works better with iconv */
337 utf8_len = 0;
338 utf8_str = mac_utf16_to_utf8(from, fromLen, &utf8_len);
340 if (utf8_str)
342 /* We might be called before we have p_enc set up. */
343 conv.vc_type = CONV_NONE;
345 /* If encoding (p_enc) is any unicode, it is actually in utf-8 (vim
346 * internal unicode is always utf-8) so don't convert in such cases */
348 if ((enc_canon_props(p_enc) & ENC_UNICODE) == 0)
349 convert_setup(&conv, (char_u *)"utf-8",
350 p_enc? p_enc: (char_u *)"macroman");
351 if (conv.vc_type == CONV_NONE)
353 /* p_enc is utf-8, so we're done. */
354 result = utf8_str;
356 else
358 result = string_convert(&conv, utf8_str, (int *)&utf8_len);
359 vim_free(utf8_str);
362 convert_setup(&conv, NULL, NULL);
364 if (actualLen)
365 *actualLen = utf8_len;
367 else if (actualLen)
368 *actualLen = 0;
370 return result;
374 * Conversion from 'encoding' to UTF-16 UniChars
375 * The function return uses the real type of UniChar (as typedef'ed in
376 * CFBase.h) to avoid clashes with X11 header files in the .pro file
378 unsigned short *
379 mac_enc_to_utf16(from, fromLen, actualLen)
380 char_u *from;
381 size_t fromLen;
382 size_t *actualLen;
384 /* Following code borrows somewhat from os_mswin.c */
385 vimconv_T conv;
386 size_t utf8_len;
387 char_u *utf8_str;
388 UniChar *result = NULL;
389 Boolean should_free_utf8 = FALSE;
393 /* Use MacRoman by default, we might be called before we have p_enc
394 * set up. Convert to utf-8 first, works better with iconv(). Does
395 * nothing if 'encoding' is "utf-8". */
396 conv.vc_type = CONV_NONE;
397 if ((enc_canon_props(p_enc) & ENC_UNICODE) == 0 &&
398 convert_setup(&conv, p_enc ? p_enc : (char_u *)"macroman",
399 (char_u *)"utf-8") == FAIL)
400 break;
402 if (conv.vc_type != CONV_NONE)
404 utf8_len = fromLen;
405 utf8_str = string_convert(&conv, from, (int *)&utf8_len);
406 should_free_utf8 = TRUE;
408 else
410 utf8_str = from;
411 utf8_len = fromLen;
414 if (utf8_str == NULL)
415 break;
417 convert_setup(&conv, NULL, NULL);
419 result = mac_utf8_to_utf16(utf8_str, utf8_len, actualLen);
421 if (should_free_utf8)
422 vim_free(utf8_str);
423 return result;
425 while (0);
427 if (actualLen)
428 *actualLen = 0;
430 return result;
434 * Converts from UTF-16 UniChars to CFString
435 * The void * return type is actually a CFStringRef
437 void *
438 mac_enc_to_cfstring(from, fromLen)
439 char_u *from;
440 size_t fromLen;
442 UniChar *utf16_str;
443 size_t utf16_len;
444 CFStringRef result = NULL;
446 utf16_str = mac_enc_to_utf16(from, fromLen, &utf16_len);
447 if (utf16_str)
449 result = CFStringCreateWithCharacters(NULL, utf16_str, utf16_len/sizeof(UniChar));
450 vim_free(utf16_str);
453 return (void *)result;
457 * Converts a decomposed HFS+ UTF-8 path to precomposed UTF-8
459 char_u *
460 mac_precompose_path(decompPath, decompLen, precompLen)
461 char_u *decompPath;
462 size_t decompLen;
463 size_t *precompLen;
465 char_u *result = NULL;
466 size_t actualLen = 0;
468 if (gPathConverter)
470 result = alloc(decompLen);
471 if (result)
473 if (TECConvertText(gPathConverter, decompPath,
474 decompLen, &decompLen, result,
475 decompLen, &actualLen) != noErr)
477 vim_free(result);
478 result = NULL;
483 if (precompLen)
484 *precompLen = actualLen;
486 return result;
490 * Converts from UTF-16 UniChars to precomposed UTF-8
492 static char_u *
493 mac_utf16_to_utf8(from, fromLen, actualLen)
494 UniChar *from;
495 size_t fromLen;
496 size_t *actualLen;
498 ByteCount utf8_len;
499 ByteCount inputRead;
500 char_u *result;
502 if (gUTF16ToUTF8Converter)
504 result = alloc(fromLen * 6 + 1);
505 if (result && TECConvertText(gUTF16ToUTF8Converter, (ConstTextPtr)from,
506 fromLen, &inputRead, result,
507 (fromLen*6+1)*sizeof(char_u), &utf8_len) == noErr)
509 TECFlushText(gUTF16ToUTF8Converter, result, (fromLen*6+1)*sizeof(char_u), &inputRead);
510 utf8_len += inputRead;
512 else
514 vim_free(result);
515 result = NULL;
518 else
520 result = NULL;
523 if (actualLen)
524 *actualLen = result ? utf8_len : 0;
526 return result;
530 * Converts from UTF-8 to UTF-16 UniChars
532 static UniChar *
533 mac_utf8_to_utf16(from, fromLen, actualLen)
534 char_u *from;
535 size_t fromLen;
536 size_t *actualLen;
538 CFStringRef utf8_str;
539 CFRange convertRange;
540 UniChar *result = NULL;
542 utf8_str = CFStringCreateWithBytes(NULL, from, fromLen,
543 kCFStringEncodingUTF8, FALSE);
545 if (utf8_str == NULL) {
546 if (actualLen)
547 *actualLen = 0;
548 return NULL;
551 convertRange = CFRangeMake(0, CFStringGetLength(utf8_str));
552 result = (UniChar *)alloc(convertRange.length * sizeof(UniChar));
554 CFStringGetCharacters(utf8_str, convertRange, result);
556 CFRelease(utf8_str);
558 if (actualLen)
559 *actualLen = convertRange.length * sizeof(UniChar);
561 return result;
565 * Sets LANG environment variable in Vim from Mac locale
567 void
568 mac_lang_init() {
569 if (mch_getenv((char_u *)"LANG") == NULL)
571 char buf[20];
572 if (LocaleRefGetPartString(NULL,
573 kLocaleLanguageMask | kLocaleLanguageVariantMask |
574 kLocaleRegionMask | kLocaleRegionVariantMask,
575 sizeof buf, buf) == noErr && *buf)
577 vim_setenv((char_u *)"LANG", (char_u *)buf);
578 # ifdef HAVE_LOCALE_H
579 setlocale(LC_ALL, "");
580 # endif
584 #endif /* MACOS_CONVERT */