blob: 0b9f4b8d7730c11e8f6399db44139f30d563ae79 [file] [log] [blame]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001/* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
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#include "vim.h"
11
12#ifdef FEAT_LINEBREAK
13static int win_chartabsize __ARGS((win_T *wp, char_u *p, colnr_T col));
14#endif
15
16#ifdef FEAT_MBYTE
Bram Moolenaard7b734a2010-08-12 20:17:02 +020017# if defined(HAVE_WCHAR_H)
18# include <wchar.h> /* for towupper() and towlower() */
19# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +000020static int win_nolbr_chartabsize __ARGS((win_T *wp, char_u *s, colnr_T col, int *headp));
21#endif
22
Bram Moolenaar0ab2a882009-05-13 10:51:08 +000023static unsigned nr2hex __ARGS((unsigned c));
Bram Moolenaar071d4272004-06-13 20:20:40 +000024
25static int chartab_initialized = FALSE;
26
27/* b_chartab[] is an array of 32 bytes, each bit representing one of the
28 * characters 0-255. */
29#define SET_CHARTAB(buf, c) (buf)->b_chartab[(unsigned)(c) >> 3] |= (1 << ((c) & 0x7))
30#define RESET_CHARTAB(buf, c) (buf)->b_chartab[(unsigned)(c) >> 3] &= ~(1 << ((c) & 0x7))
31#define GET_CHARTAB(buf, c) ((buf)->b_chartab[(unsigned)(c) >> 3] & (1 << ((c) & 0x7)))
32
33/*
34 * Fill chartab[]. Also fills curbuf->b_chartab[] with flags for keyword
35 * characters for current buffer.
36 *
37 * Depends on the option settings 'iskeyword', 'isident', 'isfname',
38 * 'isprint' and 'encoding'.
39 *
40 * The index in chartab[] depends on 'encoding':
41 * - For non-multi-byte index with the byte (same as the character).
42 * - For DBCS index with the first byte.
43 * - For UTF-8 index with the character (when first byte is up to 0x80 it is
44 * the same as the character, if the first byte is 0x80 and above it depends
45 * on further bytes).
46 *
47 * The contents of chartab[]:
48 * - The lower two bits, masked by CT_CELL_MASK, give the number of display
49 * cells the character occupies (1 or 2). Not valid for UTF-8 above 0x80.
50 * - CT_PRINT_CHAR bit is set when the character is printable (no need to
51 * translate the character before displaying it). Note that only DBCS
52 * characters can have 2 display cells and still be printable.
53 * - CT_FNAME_CHAR bit is set when the character can be in a file name.
54 * - CT_ID_CHAR bit is set when the character can be in an identifier.
55 *
56 * Return FAIL if 'iskeyword', 'isident', 'isfname' or 'isprint' option has an
57 * error, OK otherwise.
58 */
59 int
60init_chartab()
61{
62 return buf_init_chartab(curbuf, TRUE);
63}
64
65 int
66buf_init_chartab(buf, global)
67 buf_T *buf;
68 int global; /* FALSE: only set buf->b_chartab[] */
69{
70 int c;
71 int c2;
72 char_u *p;
73 int i;
74 int tilde;
75 int do_isalpha;
76
77 if (global)
78 {
79 /*
80 * Set the default size for printable characters:
81 * From <Space> to '~' is 1 (printable), others are 2 (not printable).
82 * This also inits all 'isident' and 'isfname' flags to FALSE.
83 *
84 * EBCDIC: all chars below ' ' are not printable, all others are
85 * printable.
86 */
87 c = 0;
88 while (c < ' ')
89 chartab[c++] = (dy_flags & DY_UHEX) ? 4 : 2;
90#ifdef EBCDIC
91 while (c < 255)
92#else
93 while (c <= '~')
94#endif
95 chartab[c++] = 1 + CT_PRINT_CHAR;
96#ifdef FEAT_FKMAP
97 if (p_altkeymap)
98 {
99 while (c < YE)
100 chartab[c++] = 1 + CT_PRINT_CHAR;
101 }
102#endif
103 while (c < 256)
104 {
105#ifdef FEAT_MBYTE
106 /* UTF-8: bytes 0xa0 - 0xff are printable (latin1) */
107 if (enc_utf8 && c >= 0xa0)
108 chartab[c++] = CT_PRINT_CHAR + 1;
109 /* euc-jp characters starting with 0x8e are single width */
110 else if (enc_dbcs == DBCS_JPNU && c == 0x8e)
111 chartab[c++] = CT_PRINT_CHAR + 1;
112 /* other double-byte chars can be printable AND double-width */
113 else if (enc_dbcs != 0 && MB_BYTE2LEN(c) == 2)
114 chartab[c++] = CT_PRINT_CHAR + 2;
115 else
116#endif
117 /* the rest is unprintable by default */
118 chartab[c++] = (dy_flags & DY_UHEX) ? 4 : 2;
119 }
120
121#ifdef FEAT_MBYTE
122 /* Assume that every multi-byte char is a filename character. */
123 for (c = 1; c < 256; ++c)
124 if ((enc_dbcs != 0 && MB_BYTE2LEN(c) > 1)
125 || (enc_dbcs == DBCS_JPNU && c == 0x8e)
126 || (enc_utf8 && c >= 0xa0))
127 chartab[c] |= CT_FNAME_CHAR;
128#endif
129 }
130
131 /*
132 * Init word char flags all to FALSE
133 */
134 vim_memset(buf->b_chartab, 0, (size_t)32);
135#ifdef FEAT_MBYTE
Bram Moolenaar6bb68362005-03-22 23:03:44 +0000136 if (enc_dbcs != 0)
137 for (c = 0; c < 256; ++c)
138 {
139 /* double-byte characters are probably word characters */
140 if (MB_BYTE2LEN(c) == 2)
141 SET_CHARTAB(buf, c);
142 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000143#endif
144
145#ifdef FEAT_LISP
146 /*
147 * In lisp mode the '-' character is included in keywords.
148 */
149 if (buf->b_p_lisp)
150 SET_CHARTAB(buf, '-');
151#endif
152
153 /* Walk through the 'isident', 'iskeyword', 'isfname' and 'isprint'
154 * options Each option is a list of characters, character numbers or
155 * ranges, separated by commas, e.g.: "200-210,x,#-178,-"
156 */
157 for (i = global ? 0 : 3; i <= 3; ++i)
158 {
159 if (i == 0)
160 p = p_isi; /* first round: 'isident' */
161 else if (i == 1)
162 p = p_isp; /* second round: 'isprint' */
163 else if (i == 2)
164 p = p_isf; /* third round: 'isfname' */
165 else /* i == 3 */
166 p = buf->b_p_isk; /* fourth round: 'iskeyword' */
167
168 while (*p)
169 {
170 tilde = FALSE;
171 do_isalpha = FALSE;
172 if (*p == '^' && p[1] != NUL)
173 {
174 tilde = TRUE;
175 ++p;
176 }
177 if (VIM_ISDIGIT(*p))
178 c = getdigits(&p);
179 else
Bram Moolenaar183bb3e2009-09-11 12:02:34 +0000180#ifdef FEAT_MBYTE
181 if (has_mbyte)
182 c = mb_ptr2char_adv(&p);
183 else
184#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000185 c = *p++;
186 c2 = -1;
187 if (*p == '-' && p[1] != NUL)
188 {
189 ++p;
190 if (VIM_ISDIGIT(*p))
191 c2 = getdigits(&p);
192 else
Bram Moolenaar2ac5e602009-11-03 15:04:20 +0000193#ifdef FEAT_MBYTE
194 if (has_mbyte)
195 c2 = mb_ptr2char_adv(&p);
196 else
197#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000198 c2 = *p++;
199 }
Bram Moolenaar2ac5e602009-11-03 15:04:20 +0000200 if (c <= 0 || c >= 256 || (c2 < c && c2 != -1) || c2 >= 256
Bram Moolenaar071d4272004-06-13 20:20:40 +0000201 || !(*p == NUL || *p == ','))
202 return FAIL;
203
204 if (c2 == -1) /* not a range */
205 {
206 /*
207 * A single '@' (not "@-@"):
208 * Decide on letters being ID/printable/keyword chars with
209 * standard function isalpha(). This takes care of locale for
210 * single-byte characters).
211 */
212 if (c == '@')
213 {
214 do_isalpha = TRUE;
215 c = 1;
216 c2 = 255;
217 }
218 else
219 c2 = c;
220 }
221 while (c <= c2)
222 {
Bram Moolenaardeefb632007-08-15 18:41:34 +0000223 /* Use the MB_ functions here, because isalpha() doesn't
224 * work properly when 'encoding' is "latin1" and the locale is
225 * "C". */
226 if (!do_isalpha || MB_ISLOWER(c) || MB_ISUPPER(c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000227#ifdef FEAT_FKMAP
228 || (p_altkeymap && (F_isalpha(c) || F_isdigit(c)))
229#endif
230 )
231 {
232 if (i == 0) /* (re)set ID flag */
233 {
234 if (tilde)
235 chartab[c] &= ~CT_ID_CHAR;
236 else
237 chartab[c] |= CT_ID_CHAR;
238 }
239 else if (i == 1) /* (re)set printable */
240 {
241 if ((c < ' '
242#ifndef EBCDIC
243 || c > '~'
244#endif
245#ifdef FEAT_FKMAP
246 || (p_altkeymap
247 && (F_isalpha(c) || F_isdigit(c)))
248#endif
249 )
250#ifdef FEAT_MBYTE
251 /* For double-byte we keep the cell width, so
252 * that we can detect it from the first byte. */
253 && !(enc_dbcs && MB_BYTE2LEN(c) == 2)
254#endif
255 )
256 {
257 if (tilde)
258 {
259 chartab[c] = (chartab[c] & ~CT_CELL_MASK)
260 + ((dy_flags & DY_UHEX) ? 4 : 2);
261 chartab[c] &= ~CT_PRINT_CHAR;
262 }
263 else
264 {
265 chartab[c] = (chartab[c] & ~CT_CELL_MASK) + 1;
266 chartab[c] |= CT_PRINT_CHAR;
267 }
268 }
269 }
270 else if (i == 2) /* (re)set fname flag */
271 {
272 if (tilde)
273 chartab[c] &= ~CT_FNAME_CHAR;
274 else
275 chartab[c] |= CT_FNAME_CHAR;
276 }
277 else /* i == 3 */ /* (re)set keyword flag */
278 {
279 if (tilde)
280 RESET_CHARTAB(buf, c);
281 else
282 SET_CHARTAB(buf, c);
283 }
284 }
285 ++c;
286 }
Bram Moolenaar309379f2013-02-06 16:26:26 +0100287
288 c = *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000289 p = skip_to_option_part(p);
Bram Moolenaar309379f2013-02-06 16:26:26 +0100290 if (c == ',' && *p == NUL)
291 /* Trailing comma is not allowed. */
292 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000293 }
294 }
295 chartab_initialized = TRUE;
296 return OK;
297}
298
299/*
300 * Translate any special characters in buf[bufsize] in-place.
301 * The result is a string with only printable characters, but if there is not
302 * enough room, not all characters will be translated.
303 */
304 void
305trans_characters(buf, bufsize)
306 char_u *buf;
307 int bufsize;
308{
309 int len; /* length of string needing translation */
310 int room; /* room in buffer after string */
311 char_u *trs; /* translated character */
312 int trs_len; /* length of trs[] */
313
314 len = (int)STRLEN(buf);
315 room = bufsize - len;
316 while (*buf != 0)
317 {
318# ifdef FEAT_MBYTE
319 /* Assume a multi-byte character doesn't need translation. */
Bram Moolenaar0fa313a2005-08-10 21:07:57 +0000320 if (has_mbyte && (trs_len = (*mb_ptr2len)(buf)) > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000321 len -= trs_len;
322 else
323# endif
324 {
325 trs = transchar_byte(*buf);
326 trs_len = (int)STRLEN(trs);
327 if (trs_len > 1)
328 {
329 room -= trs_len - 1;
330 if (room <= 0)
331 return;
332 mch_memmove(buf + trs_len, buf + 1, (size_t)len);
333 }
334 mch_memmove(buf, trs, (size_t)trs_len);
335 --len;
336 }
337 buf += trs_len;
338 }
339}
340
Bram Moolenaar7cc36e92007-03-27 10:42:05 +0000341#if defined(FEAT_EVAL) || defined(FEAT_TITLE) || defined(FEAT_INS_EXPAND) \
342 || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000343/*
344 * Translate a string into allocated memory, replacing special chars with
345 * printable chars. Returns NULL when out of memory.
346 */
347 char_u *
348transstr(s)
349 char_u *s;
350{
351 char_u *res;
352 char_u *p;
353#ifdef FEAT_MBYTE
354 int l, len, c;
355 char_u hexbuf[11];
356#endif
357
358#ifdef FEAT_MBYTE
359 if (has_mbyte)
360 {
361 /* Compute the length of the result, taking account of unprintable
362 * multi-byte characters. */
363 len = 0;
364 p = s;
365 while (*p != NUL)
366 {
Bram Moolenaar0fa313a2005-08-10 21:07:57 +0000367 if ((l = (*mb_ptr2len)(p)) > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000368 {
369 c = (*mb_ptr2char)(p);
370 p += l;
371 if (vim_isprintc(c))
372 len += l;
373 else
374 {
375 transchar_hex(hexbuf, c);
Bram Moolenaara93fa7e2006-04-17 22:14:47 +0000376 len += (int)STRLEN(hexbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000377 }
378 }
379 else
380 {
381 l = byte2cells(*p++);
382 if (l > 0)
383 len += l;
384 else
385 len += 4; /* illegal byte sequence */
386 }
387 }
388 res = alloc((unsigned)(len + 1));
389 }
390 else
391#endif
392 res = alloc((unsigned)(vim_strsize(s) + 1));
393 if (res != NULL)
394 {
395 *res = NUL;
396 p = s;
397 while (*p != NUL)
398 {
399#ifdef FEAT_MBYTE
Bram Moolenaar0fa313a2005-08-10 21:07:57 +0000400 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000401 {
402 c = (*mb_ptr2char)(p);
403 if (vim_isprintc(c))
404 STRNCAT(res, p, l); /* append printable multi-byte char */
405 else
406 transchar_hex(res + STRLEN(res), c);
407 p += l;
408 }
409 else
410#endif
411 STRCAT(res, transchar_byte(*p++));
412 }
413 }
414 return res;
415}
416#endif
417
418#if defined(FEAT_SYN_HL) || defined(FEAT_INS_EXPAND) || defined(PROTO)
419/*
Bram Moolenaar217ad922005-03-20 22:37:15 +0000420 * Convert the string "str[orglen]" to do ignore-case comparing. Uses the
421 * current locale.
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000422 * When "buf" is NULL returns an allocated string (NULL for out-of-memory).
423 * Otherwise puts the result in "buf[buflen]".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000424 */
425 char_u *
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000426str_foldcase(str, orglen, buf, buflen)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000427 char_u *str;
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000428 int orglen;
429 char_u *buf;
430 int buflen;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000431{
432 garray_T ga;
433 int i;
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000434 int len = orglen;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000435
436#define GA_CHAR(i) ((char_u *)ga.ga_data)[i]
437#define GA_PTR(i) ((char_u *)ga.ga_data + i)
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000438#define STR_CHAR(i) (buf == NULL ? GA_CHAR(i) : buf[i])
439#define STR_PTR(i) (buf == NULL ? GA_PTR(i) : buf + i)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000440
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000441 /* Copy "str" into "buf" or allocated memory, unmodified. */
442 if (buf == NULL)
443 {
444 ga_init2(&ga, 1, 10);
445 if (ga_grow(&ga, len + 1) == FAIL)
446 return NULL;
447 mch_memmove(ga.ga_data, str, (size_t)len);
448 ga.ga_len = len;
449 }
450 else
451 {
452 if (len >= buflen) /* Ugly! */
453 len = buflen - 1;
454 mch_memmove(buf, str, (size_t)len);
455 }
456 if (buf == NULL)
457 GA_CHAR(len) = NUL;
458 else
459 buf[len] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000460
461 /* Make each character lower case. */
462 i = 0;
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000463 while (STR_CHAR(i) != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000464 {
465#ifdef FEAT_MBYTE
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000466 if (enc_utf8 || (has_mbyte && MB_BYTE2LEN(STR_CHAR(i)) > 1))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000467 {
468 if (enc_utf8)
469 {
Bram Moolenaarb9839212008-06-28 11:03:50 +0000470 int c = utf_ptr2char(STR_PTR(i));
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100471 int olen = utf_ptr2len(STR_PTR(i));
Bram Moolenaarb9839212008-06-28 11:03:50 +0000472 int lc = utf_tolower(c);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000473
Bram Moolenaarb9839212008-06-28 11:03:50 +0000474 /* Only replace the character when it is not an invalid
475 * sequence (ASCII character or more than one byte) and
476 * utf_tolower() doesn't return the original character. */
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100477 if ((c < 0x80 || olen > 1) && c != lc)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000478 {
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100479 int nlen = utf_char2len(lc);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000480
481 /* If the byte length changes need to shift the following
482 * characters forward or backward. */
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100483 if (olen != nlen)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000484 {
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100485 if (nlen > olen)
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000486 {
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100487 if (buf == NULL
488 ? ga_grow(&ga, nlen - olen + 1) == FAIL
489 : len + nlen - olen >= buflen)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000490 {
491 /* out of memory, keep old char */
492 lc = c;
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100493 nlen = olen;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000494 }
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000495 }
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100496 if (olen != nlen)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000497 {
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000498 if (buf == NULL)
499 {
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100500 STRMOVE(GA_PTR(i) + nlen, GA_PTR(i) + olen);
501 ga.ga_len += nlen - olen;
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000502 }
503 else
504 {
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100505 STRMOVE(buf + i + nlen, buf + i + olen);
506 len += nlen - olen;
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000507 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000508 }
509 }
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000510 (void)utf_char2bytes(lc, STR_PTR(i));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000511 }
512 }
513 /* skip to next multi-byte char */
Bram Moolenaar0fa313a2005-08-10 21:07:57 +0000514 i += (*mb_ptr2len)(STR_PTR(i));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000515 }
516 else
517#endif
518 {
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000519 if (buf == NULL)
520 GA_CHAR(i) = TOLOWER_LOC(GA_CHAR(i));
521 else
522 buf[i] = TOLOWER_LOC(buf[i]);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000523 ++i;
524 }
525 }
526
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000527 if (buf == NULL)
528 return (char_u *)ga.ga_data;
529 return buf;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000530}
531#endif
532
533/*
534 * Catch 22: chartab[] can't be initialized before the options are
535 * initialized, and initializing options may cause transchar() to be called!
536 * When chartab_initialized == FALSE don't use chartab[].
537 * Does NOT work for multi-byte characters, c must be <= 255.
538 * Also doesn't work for the first byte of a multi-byte, "c" must be a
539 * character!
540 */
541static char_u transchar_buf[7];
542
543 char_u *
544transchar(c)
545 int c;
546{
547 int i;
548
549 i = 0;
550 if (IS_SPECIAL(c)) /* special key code, display as ~@ char */
551 {
552 transchar_buf[0] = '~';
553 transchar_buf[1] = '@';
554 i = 2;
555 c = K_SECOND(c);
556 }
557
558 if ((!chartab_initialized && (
559#ifdef EBCDIC
560 (c >= 64 && c < 255)
561#else
562 (c >= ' ' && c <= '~')
563#endif
564#ifdef FEAT_FKMAP
565 || F_ischar(c)
566#endif
567 )) || (c < 256 && vim_isprintc_strict(c)))
568 {
569 /* printable character */
570 transchar_buf[i] = c;
571 transchar_buf[i + 1] = NUL;
572 }
573 else
574 transchar_nonprint(transchar_buf + i, c);
575 return transchar_buf;
576}
577
578#if defined(FEAT_MBYTE) || defined(PROTO)
579/*
580 * Like transchar(), but called with a byte instead of a character. Checks
581 * for an illegal UTF-8 byte.
582 */
583 char_u *
584transchar_byte(c)
585 int c;
586{
587 if (enc_utf8 && c >= 0x80)
588 {
589 transchar_nonprint(transchar_buf, c);
590 return transchar_buf;
591 }
592 return transchar(c);
593}
594#endif
595
596/*
597 * Convert non-printable character to two or more printable characters in
598 * "buf[]". "buf" needs to be able to hold five bytes.
599 * Does NOT work for multi-byte characters, c must be <= 255.
600 */
601 void
602transchar_nonprint(buf, c)
603 char_u *buf;
604 int c;
605{
606 if (c == NL)
607 c = NUL; /* we use newline in place of a NUL */
608 else if (c == CAR && get_fileformat(curbuf) == EOL_MAC)
609 c = NL; /* we use CR in place of NL in this case */
610
611 if (dy_flags & DY_UHEX) /* 'display' has "uhex" */
612 transchar_hex(buf, c);
613
614#ifdef EBCDIC
615 /* For EBCDIC only the characters 0-63 and 255 are not printable */
616 else if (CtrlChar(c) != 0 || c == DEL)
617#else
618 else if (c <= 0x7f) /* 0x00 - 0x1f and 0x7f */
619#endif
620 {
621 buf[0] = '^';
622#ifdef EBCDIC
623 if (c == DEL)
624 buf[1] = '?'; /* DEL displayed as ^? */
625 else
626 buf[1] = CtrlChar(c);
627#else
628 buf[1] = c ^ 0x40; /* DEL displayed as ^? */
629#endif
630
631 buf[2] = NUL;
632 }
633#ifdef FEAT_MBYTE
634 else if (enc_utf8 && c >= 0x80)
635 {
636 transchar_hex(buf, c);
637 }
638#endif
639#ifndef EBCDIC
640 else if (c >= ' ' + 0x80 && c <= '~' + 0x80) /* 0xa0 - 0xfe */
641 {
642 buf[0] = '|';
643 buf[1] = c - 0x80;
644 buf[2] = NUL;
645 }
646#else
647 else if (c < 64)
648 {
649 buf[0] = '~';
650 buf[1] = MetaChar(c);
651 buf[2] = NUL;
652 }
653#endif
654 else /* 0x80 - 0x9f and 0xff */
655 {
656 /*
657 * TODO: EBCDIC I don't know what to do with this chars, so I display
658 * them as '~?' for now
659 */
660 buf[0] = '~';
661#ifdef EBCDIC
662 buf[1] = '?'; /* 0xff displayed as ~? */
663#else
664 buf[1] = (c - 0x80) ^ 0x40; /* 0xff displayed as ~? */
665#endif
666 buf[2] = NUL;
667 }
668}
669
670 void
671transchar_hex(buf, c)
672 char_u *buf;
673 int c;
674{
675 int i = 0;
676
677 buf[0] = '<';
678#ifdef FEAT_MBYTE
679 if (c > 255)
680 {
681 buf[++i] = nr2hex((unsigned)c >> 12);
682 buf[++i] = nr2hex((unsigned)c >> 8);
683 }
684#endif
685 buf[++i] = nr2hex((unsigned)c >> 4);
Bram Moolenaar0ab2a882009-05-13 10:51:08 +0000686 buf[++i] = nr2hex((unsigned)c);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000687 buf[++i] = '>';
688 buf[++i] = NUL;
689}
690
691/*
692 * Convert the lower 4 bits of byte "c" to its hex character.
693 * Lower case letters are used to avoid the confusion of <F1> being 0xf1 or
694 * function key 1.
695 */
Bram Moolenaar0ab2a882009-05-13 10:51:08 +0000696 static unsigned
Bram Moolenaar071d4272004-06-13 20:20:40 +0000697nr2hex(c)
Bram Moolenaar0ab2a882009-05-13 10:51:08 +0000698 unsigned c;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000699{
700 if ((c & 0xf) <= 9)
701 return (c & 0xf) + '0';
702 return (c & 0xf) - 10 + 'a';
703}
704
705/*
706 * Return number of display cells occupied by byte "b".
707 * Caller must make sure 0 <= b <= 255.
708 * For multi-byte mode "b" must be the first byte of a character.
709 * A TAB is counted as two cells: "^I".
710 * For UTF-8 mode this will return 0 for bytes >= 0x80, because the number of
711 * cells depends on further bytes.
712 */
713 int
714byte2cells(b)
715 int b;
716{
717#ifdef FEAT_MBYTE
718 if (enc_utf8 && b >= 0x80)
719 return 0;
720#endif
721 return (chartab[b] & CT_CELL_MASK);
722}
723
724/*
725 * Return number of display cells occupied by character "c".
726 * "c" can be a special key (negative number) in which case 3 or 4 is returned.
727 * A TAB is counted as two cells: "^I" or four: "<09>".
728 */
729 int
730char2cells(c)
731 int c;
732{
733 if (IS_SPECIAL(c))
734 return char2cells(K_SECOND(c)) + 2;
735#ifdef FEAT_MBYTE
736 if (c >= 0x80)
737 {
738 /* UTF-8: above 0x80 need to check the value */
739 if (enc_utf8)
740 return utf_char2cells(c);
741 /* DBCS: double-byte means double-width, except for euc-jp with first
742 * byte 0x8e */
743 if (enc_dbcs != 0 && c >= 0x100)
744 {
745 if (enc_dbcs == DBCS_JPNU && ((unsigned)c >> 8) == 0x8e)
746 return 1;
747 return 2;
748 }
749 }
750#endif
751 return (chartab[c & 0xff] & CT_CELL_MASK);
752}
753
754/*
755 * Return number of display cells occupied by character at "*p".
756 * A TAB is counted as two cells: "^I" or four: "<09>".
757 */
758 int
759ptr2cells(p)
760 char_u *p;
761{
762#ifdef FEAT_MBYTE
763 /* For UTF-8 we need to look at more bytes if the first byte is >= 0x80. */
764 if (enc_utf8 && *p >= 0x80)
765 return utf_ptr2cells(p);
766 /* For DBCS we can tell the cell count from the first byte. */
767#endif
768 return (chartab[*p] & CT_CELL_MASK);
769}
770
771/*
Bram Moolenaar06af6022012-01-26 13:40:08 +0100772 * Return the number of character cells string "s" will take on the screen,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000773 * counting TABs as two characters: "^I".
774 */
775 int
776vim_strsize(s)
777 char_u *s;
778{
779 return vim_strnsize(s, (int)MAXCOL);
780}
781
782/*
Bram Moolenaar06af6022012-01-26 13:40:08 +0100783 * Return the number of character cells string "s[len]" will take on the
784 * screen, counting TABs as two characters: "^I".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000785 */
786 int
787vim_strnsize(s, len)
788 char_u *s;
789 int len;
790{
791 int size = 0;
792
793 while (*s != NUL && --len >= 0)
794 {
795#ifdef FEAT_MBYTE
796 if (has_mbyte)
797 {
Bram Moolenaar0fa313a2005-08-10 21:07:57 +0000798 int l = (*mb_ptr2len)(s);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000799
800 size += ptr2cells(s);
801 s += l;
802 len -= l - 1;
803 }
804 else
805#endif
806 size += byte2cells(*s++);
807 }
808 return size;
809}
810
811/*
812 * Return the number of characters 'c' will take on the screen, taking
813 * into account the size of a tab.
814 * Use a define to make it fast, this is used very often!!!
815 * Also see getvcol() below.
816 */
817
818#define RET_WIN_BUF_CHARTABSIZE(wp, buf, p, col) \
819 if (*(p) == TAB && (!(wp)->w_p_list || lcs_tab1)) \
820 { \
821 int ts; \
822 ts = (buf)->b_p_ts; \
823 return (int)(ts - (col % ts)); \
824 } \
825 else \
826 return ptr2cells(p);
827
828#if defined(FEAT_VREPLACE) || defined(FEAT_EX_EXTRA) || defined(FEAT_GUI) \
829 || defined(FEAT_VIRTUALEDIT) || defined(PROTO)
830 int
831chartabsize(p, col)
832 char_u *p;
833 colnr_T col;
834{
835 RET_WIN_BUF_CHARTABSIZE(curwin, curbuf, p, col)
836}
837#endif
838
839#ifdef FEAT_LINEBREAK
840 static int
841win_chartabsize(wp, p, col)
842 win_T *wp;
843 char_u *p;
844 colnr_T col;
845{
846 RET_WIN_BUF_CHARTABSIZE(wp, wp->w_buffer, p, col)
847}
848#endif
849
850/*
Bram Moolenaardc536092010-07-18 15:45:49 +0200851 * Return the number of characters the string 's' will take on the screen,
852 * taking into account the size of a tab.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000853 */
854 int
855linetabsize(s)
856 char_u *s;
857{
Bram Moolenaardc536092010-07-18 15:45:49 +0200858 return linetabsize_col(0, s);
859}
860
861/*
862 * Like linetabsize(), but starting at column "startcol".
863 */
864 int
865linetabsize_col(startcol, s)
866 int startcol;
867 char_u *s;
868{
869 colnr_T col = startcol;
Bram Moolenaar597a4222014-06-25 14:39:50 +0200870 char_u *line = s; /* pointer to start of line, for breakindent */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000871
872 while (*s != NUL)
Bram Moolenaar597a4222014-06-25 14:39:50 +0200873 col += lbr_chartabsize_adv(line, &s, col);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000874 return (int)col;
875}
876
877/*
878 * Like linetabsize(), but for a given window instead of the current one.
879 */
880 int
Bram Moolenaar597a4222014-06-25 14:39:50 +0200881win_linetabsize(wp, line, len)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000882 win_T *wp;
Bram Moolenaar597a4222014-06-25 14:39:50 +0200883 char_u *line;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000884 colnr_T len;
885{
886 colnr_T col = 0;
887 char_u *s;
888
Bram Moolenaar597a4222014-06-25 14:39:50 +0200889 for (s = line; *s != NUL && (len == MAXCOL || s < line + len);
890 mb_ptr_adv(s))
891 col += win_lbr_chartabsize(wp, line, s, col, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000892 return (int)col;
893}
894
895/*
Bram Moolenaar81695252004-12-29 20:58:21 +0000896 * Return TRUE if 'c' is a normal identifier character:
897 * Letters and characters from the 'isident' option.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000898 */
899 int
900vim_isIDc(c)
901 int c;
902{
903 return (c > 0 && c < 0x100 && (chartab[c] & CT_ID_CHAR));
904}
905
906/*
907 * return TRUE if 'c' is a keyword character: Letters and characters from
908 * 'iskeyword' option for current buffer.
909 * For multi-byte characters mb_get_class() is used (builtin rules).
910 */
911 int
912vim_iswordc(c)
913 int c;
914{
Bram Moolenaar9d182dd2013-01-23 15:53:15 +0100915 return vim_iswordc_buf(c, curbuf);
916}
917
918 int
919vim_iswordc_buf(c, buf)
920 int c;
921 buf_T *buf;
922{
Bram Moolenaar071d4272004-06-13 20:20:40 +0000923#ifdef FEAT_MBYTE
924 if (c >= 0x100)
925 {
926 if (enc_dbcs != 0)
Bram Moolenaar0ab2a882009-05-13 10:51:08 +0000927 return dbcs_class((unsigned)c >> 8, (unsigned)(c & 0xff)) >= 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000928 if (enc_utf8)
929 return utf_class(c) >= 2;
930 }
931#endif
Bram Moolenaar9d182dd2013-01-23 15:53:15 +0100932 return (c > 0 && c < 0x100 && GET_CHARTAB(buf, c) != 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000933}
934
935/*
936 * Just like vim_iswordc() but uses a pointer to the (multi-byte) character.
937 */
938 int
939vim_iswordp(p)
940 char_u *p;
941{
942#ifdef FEAT_MBYTE
943 if (has_mbyte && MB_BYTE2LEN(*p) > 1)
944 return mb_get_class(p) >= 2;
945#endif
946 return GET_CHARTAB(curbuf, *p) != 0;
947}
948
Bram Moolenaar071d4272004-06-13 20:20:40 +0000949 int
Bram Moolenaar9d182dd2013-01-23 15:53:15 +0100950vim_iswordp_buf(p, buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000951 char_u *p;
952 buf_T *buf;
953{
Bram Moolenaara50e5862013-01-30 17:30:17 +0100954#ifdef FEAT_MBYTE
Bram Moolenaar071d4272004-06-13 20:20:40 +0000955 if (has_mbyte && MB_BYTE2LEN(*p) > 1)
956 return mb_get_class(p) >= 2;
Bram Moolenaara50e5862013-01-30 17:30:17 +0100957#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000958 return (GET_CHARTAB(buf, *p) != 0);
959}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000960
961/*
962 * return TRUE if 'c' is a valid file-name character
963 * Assume characters above 0x100 are valid (multi-byte).
964 */
965 int
966vim_isfilec(c)
967 int c;
968{
969 return (c >= 0x100 || (c > 0 && (chartab[c] & CT_FNAME_CHAR)));
970}
971
972/*
Bram Moolenaardd87969c2007-08-21 13:07:12 +0000973 * return TRUE if 'c' is a valid file-name character or a wildcard character
974 * Assume characters above 0x100 are valid (multi-byte).
975 * Explicitly interpret ']' as a wildcard character as mch_has_wildcard("]")
976 * returns false.
977 */
978 int
979vim_isfilec_or_wc(c)
980 int c;
981{
982 char_u buf[2];
983
984 buf[0] = (char_u)c;
985 buf[1] = NUL;
986 return vim_isfilec(c) || c == ']' || mch_has_wildcard(buf);
987}
988
989/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000990 * return TRUE if 'c' is a printable character
991 * Assume characters above 0x100 are printable (multi-byte), except for
992 * Unicode.
993 */
994 int
995vim_isprintc(c)
996 int c;
997{
998#ifdef FEAT_MBYTE
999 if (enc_utf8 && c >= 0x100)
1000 return utf_printable(c);
1001#endif
1002 return (c >= 0x100 || (c > 0 && (chartab[c] & CT_PRINT_CHAR)));
1003}
1004
1005/*
1006 * Strict version of vim_isprintc(c), don't return TRUE if "c" is the head
1007 * byte of a double-byte character.
1008 */
1009 int
1010vim_isprintc_strict(c)
1011 int c;
1012{
1013#ifdef FEAT_MBYTE
1014 if (enc_dbcs != 0 && c < 0x100 && MB_BYTE2LEN(c) > 1)
1015 return FALSE;
1016 if (enc_utf8 && c >= 0x100)
1017 return utf_printable(c);
1018#endif
1019 return (c >= 0x100 || (c > 0 && (chartab[c] & CT_PRINT_CHAR)));
1020}
1021
1022/*
1023 * like chartabsize(), but also check for line breaks on the screen
1024 */
1025 int
Bram Moolenaar597a4222014-06-25 14:39:50 +02001026lbr_chartabsize(line, s, col)
1027 char_u *line; /* start of the line */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001028 unsigned char *s;
1029 colnr_T col;
1030{
1031#ifdef FEAT_LINEBREAK
Bram Moolenaar597a4222014-06-25 14:39:50 +02001032 if (!curwin->w_p_lbr && *p_sbr == NUL && !curwin->w_p_bri)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001033 {
1034#endif
1035#ifdef FEAT_MBYTE
1036 if (curwin->w_p_wrap)
1037 return win_nolbr_chartabsize(curwin, s, col, NULL);
1038#endif
1039 RET_WIN_BUF_CHARTABSIZE(curwin, curbuf, s, col)
1040#ifdef FEAT_LINEBREAK
1041 }
Bram Moolenaar597a4222014-06-25 14:39:50 +02001042 return win_lbr_chartabsize(curwin, line == NULL ? s : line, s, col, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001043#endif
1044}
1045
1046/*
1047 * Call lbr_chartabsize() and advance the pointer.
1048 */
1049 int
Bram Moolenaar597a4222014-06-25 14:39:50 +02001050lbr_chartabsize_adv(line, s, col)
1051 char_u *line; /* start of the line */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001052 char_u **s;
1053 colnr_T col;
1054{
1055 int retval;
1056
Bram Moolenaar597a4222014-06-25 14:39:50 +02001057 retval = lbr_chartabsize(line, *s, col);
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001058 mb_ptr_adv(*s);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001059 return retval;
1060}
1061
1062/*
1063 * This function is used very often, keep it fast!!!!
1064 *
1065 * If "headp" not NULL, set *headp to the size of what we for 'showbreak'
1066 * string at start of line. Warning: *headp is only set if it's a non-zero
1067 * value, init to 0 before calling.
1068 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001069 int
Bram Moolenaar597a4222014-06-25 14:39:50 +02001070win_lbr_chartabsize(wp, line, s, col, headp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001071 win_T *wp;
Bram Moolenaar597a4222014-06-25 14:39:50 +02001072 char_u *line; /* start of the line */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001073 char_u *s;
1074 colnr_T col;
Bram Moolenaar0c094b92009-05-14 20:20:33 +00001075 int *headp UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001076{
1077#ifdef FEAT_LINEBREAK
1078 int c;
1079 int size;
1080 colnr_T col2;
Bram Moolenaaree739b42014-07-02 19:37:42 +02001081 colnr_T col_adj = 0; /* col + screen size of tab */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001082 colnr_T colmax;
1083 int added;
1084# ifdef FEAT_MBYTE
1085 int mb_added = 0;
1086# else
1087# define mb_added 0
1088# endif
1089 int numberextra;
1090 char_u *ps;
1091 int tab_corr = (*s == TAB);
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001092 int n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001093
1094 /*
Bram Moolenaar597a4222014-06-25 14:39:50 +02001095 * No 'linebreak', 'showbreak' and 'breakindent': return quickly.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001096 */
Bram Moolenaar597a4222014-06-25 14:39:50 +02001097 if (!wp->w_p_lbr && !wp->w_p_bri && *p_sbr == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001098#endif
1099 {
1100#ifdef FEAT_MBYTE
1101 if (wp->w_p_wrap)
1102 return win_nolbr_chartabsize(wp, s, col, headp);
1103#endif
1104 RET_WIN_BUF_CHARTABSIZE(wp, wp->w_buffer, s, col)
1105 }
1106
1107#ifdef FEAT_LINEBREAK
1108 /*
1109 * First get normal size, without 'linebreak'
1110 */
1111 size = win_chartabsize(wp, s, col);
1112 c = *s;
Bram Moolenaaree739b42014-07-02 19:37:42 +02001113 if (tab_corr)
1114 col_adj = size - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001115
1116 /*
1117 * If 'linebreak' set check at a blank before a non-blank if the line
1118 * needs a break here
1119 */
1120 if (wp->w_p_lbr
1121 && vim_isbreak(c)
1122 && !vim_isbreak(s[1])
1123 && !wp->w_p_list
1124 && wp->w_p_wrap
1125# ifdef FEAT_VERTSPLIT
1126 && wp->w_width != 0
1127# endif
1128 )
1129 {
1130 /*
1131 * Count all characters from first non-blank after a blank up to next
1132 * non-blank after a blank.
1133 */
1134 numberextra = win_col_off(wp);
1135 col2 = col;
Bram Moolenaaree739b42014-07-02 19:37:42 +02001136 colmax = (colnr_T)(W_WIDTH(wp) - numberextra - col_adj);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001137 if (col >= colmax)
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001138 {
Bram Moolenaaree739b42014-07-02 19:37:42 +02001139 colmax += col_adj;
1140 n = colmax + win_col_off2(wp);
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001141 if (n > 0)
Bram Moolenaaree739b42014-07-02 19:37:42 +02001142 colmax += (((col - colmax) / n) + 1) * n - col_adj;
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001143 }
1144
Bram Moolenaar071d4272004-06-13 20:20:40 +00001145 for (;;)
1146 {
1147 ps = s;
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001148 mb_ptr_adv(s);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001149 c = *s;
1150 if (!(c != NUL
1151 && (vim_isbreak(c)
1152 || (!vim_isbreak(c)
1153 && (col2 == col || !vim_isbreak(*ps))))))
1154 break;
1155
1156 col2 += win_chartabsize(wp, s, col2);
1157 if (col2 >= colmax) /* doesn't fit */
1158 {
Bram Moolenaaree739b42014-07-02 19:37:42 +02001159 size = colmax - col + col_adj;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001160 tab_corr = FALSE;
1161 break;
1162 }
1163 }
1164 }
1165# ifdef FEAT_MBYTE
1166 else if (has_mbyte && size == 2 && MB_BYTE2LEN(*s) > 1
1167 && wp->w_p_wrap && in_win_border(wp, col))
1168 {
1169 ++size; /* Count the ">" in the last column. */
1170 mb_added = 1;
1171 }
1172# endif
1173
1174 /*
Bram Moolenaar597a4222014-06-25 14:39:50 +02001175 * May have to add something for 'breakindent' and/or 'showbreak'
1176 * string at start of line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001177 * Set *headp to the size of what we add.
1178 */
1179 added = 0;
Bram Moolenaar597a4222014-06-25 14:39:50 +02001180 if ((*p_sbr != NUL || wp->w_p_bri) && wp->w_p_wrap && col != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001181 {
1182 numberextra = win_col_off(wp);
1183 col += numberextra + mb_added;
1184 if (col >= (colnr_T)W_WIDTH(wp))
1185 {
1186 col -= W_WIDTH(wp);
1187 numberextra = W_WIDTH(wp) - (numberextra - win_col_off2(wp));
1188 if (numberextra > 0)
1189 col = col % numberextra;
1190 }
1191 if (col == 0 || col + size > (colnr_T)W_WIDTH(wp))
1192 {
Bram Moolenaar597a4222014-06-25 14:39:50 +02001193 added = 0;
1194 if (*p_sbr != NUL)
1195 added += vim_strsize(p_sbr);
1196 if (wp->w_p_bri)
1197 added += get_breakindent_win(wp, line);
1198
Bram Moolenaar071d4272004-06-13 20:20:40 +00001199 if (tab_corr)
1200 size += (added / wp->w_buffer->b_p_ts) * wp->w_buffer->b_p_ts;
1201 else
1202 size += added;
1203 if (col != 0)
1204 added = 0;
1205 }
1206 }
1207 if (headp != NULL)
1208 *headp = added + mb_added;
1209 return size;
1210#endif
1211}
1212
1213#if defined(FEAT_MBYTE) || defined(PROTO)
1214/*
1215 * Like win_lbr_chartabsize(), except that we know 'linebreak' is off and
1216 * 'wrap' is on. This means we need to check for a double-byte character that
1217 * doesn't fit at the end of the screen line.
1218 */
1219 static int
1220win_nolbr_chartabsize(wp, s, col, headp)
1221 win_T *wp;
1222 char_u *s;
1223 colnr_T col;
1224 int *headp;
1225{
1226 int n;
1227
1228 if (*s == TAB && (!wp->w_p_list || lcs_tab1))
1229 {
1230 n = wp->w_buffer->b_p_ts;
1231 return (int)(n - (col % n));
1232 }
1233 n = ptr2cells(s);
1234 /* Add one cell for a double-width character in the last column of the
1235 * window, displayed with a ">". */
1236 if (n == 2 && MB_BYTE2LEN(*s) > 1 && in_win_border(wp, col))
1237 {
1238 if (headp != NULL)
1239 *headp = 1;
1240 return 3;
1241 }
1242 return n;
1243}
1244
1245/*
1246 * Return TRUE if virtual column "vcol" is in the rightmost column of window
1247 * "wp".
1248 */
1249 int
1250in_win_border(wp, vcol)
1251 win_T *wp;
1252 colnr_T vcol;
1253{
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001254 int width1; /* width of first line (after line number) */
1255 int width2; /* width of further lines */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001256
1257#ifdef FEAT_VERTSPLIT
1258 if (wp->w_width == 0) /* there is no border */
1259 return FALSE;
1260#endif
1261 width1 = W_WIDTH(wp) - win_col_off(wp);
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001262 if ((int)vcol < width1 - 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001263 return FALSE;
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001264 if ((int)vcol == width1 - 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001265 return TRUE;
1266 width2 = width1 + win_col_off2(wp);
Bram Moolenaar8701cd62009-10-07 14:20:30 +00001267 if (width2 <= 0)
1268 return FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001269 return ((vcol - width1) % width2 == width2 - 1);
1270}
1271#endif /* FEAT_MBYTE */
1272
1273/*
1274 * Get virtual column number of pos.
1275 * start: on the first position of this character (TAB, ctrl)
1276 * cursor: where the cursor is on this character (first char, except for TAB)
1277 * end: on the last position of this character (TAB, ctrl)
1278 *
1279 * This is used very often, keep it fast!
1280 */
1281 void
1282getvcol(wp, pos, start, cursor, end)
1283 win_T *wp;
1284 pos_T *pos;
1285 colnr_T *start;
1286 colnr_T *cursor;
1287 colnr_T *end;
1288{
1289 colnr_T vcol;
1290 char_u *ptr; /* points to current char */
1291 char_u *posptr; /* points to char at pos->col */
Bram Moolenaar597a4222014-06-25 14:39:50 +02001292 char_u *line; /* start of the line */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001293 int incr;
1294 int head;
1295 int ts = wp->w_buffer->b_p_ts;
1296 int c;
1297
1298 vcol = 0;
Bram Moolenaar597a4222014-06-25 14:39:50 +02001299 line = ptr = ml_get_buf(wp->w_buffer, pos->lnum, FALSE);
Bram Moolenaar37d619f2010-03-10 14:46:26 +01001300 if (pos->col == MAXCOL)
1301 posptr = NULL; /* continue until the NUL */
1302 else
1303 posptr = ptr + pos->col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001304
1305 /*
1306 * This function is used very often, do some speed optimizations.
Bram Moolenaar597a4222014-06-25 14:39:50 +02001307 * When 'list', 'linebreak', 'showbreak' and 'breakindent' are not set
1308 * use a simple loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001309 * Also use this when 'list' is set but tabs take their normal size.
1310 */
1311 if ((!wp->w_p_list || lcs_tab1 != NUL)
1312#ifdef FEAT_LINEBREAK
Bram Moolenaar597a4222014-06-25 14:39:50 +02001313 && !wp->w_p_lbr && *p_sbr == NUL && !wp->w_p_bri
Bram Moolenaar071d4272004-06-13 20:20:40 +00001314#endif
1315 )
1316 {
1317#ifndef FEAT_MBYTE
1318 head = 0;
1319#endif
1320 for (;;)
1321 {
1322#ifdef FEAT_MBYTE
1323 head = 0;
1324#endif
1325 c = *ptr;
1326 /* make sure we don't go past the end of the line */
1327 if (c == NUL)
1328 {
1329 incr = 1; /* NUL at end of line only takes one column */
1330 break;
1331 }
1332 /* A tab gets expanded, depending on the current column */
1333 if (c == TAB)
1334 incr = ts - (vcol % ts);
1335 else
1336 {
1337#ifdef FEAT_MBYTE
1338 if (has_mbyte)
1339 {
1340 /* For utf-8, if the byte is >= 0x80, need to look at
1341 * further bytes to find the cell width. */
1342 if (enc_utf8 && c >= 0x80)
1343 incr = utf_ptr2cells(ptr);
1344 else
1345 incr = CHARSIZE(c);
1346
1347 /* If a double-cell char doesn't fit at the end of a line
1348 * it wraps to the next line, it's like this char is three
1349 * cells wide. */
Bram Moolenaar9c33a7c2008-02-20 13:59:32 +00001350 if (incr == 2 && wp->w_p_wrap && MB_BYTE2LEN(*ptr) > 1
1351 && in_win_border(wp, vcol))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001352 {
1353 ++incr;
1354 head = 1;
1355 }
1356 }
1357 else
1358#endif
1359 incr = CHARSIZE(c);
1360 }
1361
Bram Moolenaar37d619f2010-03-10 14:46:26 +01001362 if (posptr != NULL && ptr >= posptr) /* character at pos->col */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001363 break;
1364
1365 vcol += incr;
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001366 mb_ptr_adv(ptr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001367 }
1368 }
1369 else
1370 {
1371 for (;;)
1372 {
1373 /* A tab gets expanded, depending on the current column */
1374 head = 0;
Bram Moolenaar597a4222014-06-25 14:39:50 +02001375 incr = win_lbr_chartabsize(wp, line, ptr, vcol, &head);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001376 /* make sure we don't go past the end of the line */
1377 if (*ptr == NUL)
1378 {
1379 incr = 1; /* NUL at end of line only takes one column */
1380 break;
1381 }
1382
Bram Moolenaar37d619f2010-03-10 14:46:26 +01001383 if (posptr != NULL && ptr >= posptr) /* character at pos->col */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001384 break;
1385
1386 vcol += incr;
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001387 mb_ptr_adv(ptr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001388 }
1389 }
1390 if (start != NULL)
1391 *start = vcol + head;
1392 if (end != NULL)
1393 *end = vcol + incr - 1;
1394 if (cursor != NULL)
1395 {
1396 if (*ptr == TAB
1397 && (State & NORMAL)
1398 && !wp->w_p_list
1399 && !virtual_active()
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +01001400 && !(VIsual_active && (*p_sel == 'e' || ltoreq(*pos, VIsual)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001401 )
1402 *cursor = vcol + incr - 1; /* cursor at end */
1403 else
1404 *cursor = vcol + head; /* cursor at start */
1405 }
1406}
1407
1408/*
1409 * Get virtual cursor column in the current window, pretending 'list' is off.
1410 */
1411 colnr_T
1412getvcol_nolist(posp)
1413 pos_T *posp;
1414{
1415 int list_save = curwin->w_p_list;
1416 colnr_T vcol;
1417
1418 curwin->w_p_list = FALSE;
1419 getvcol(curwin, posp, NULL, &vcol, NULL);
1420 curwin->w_p_list = list_save;
1421 return vcol;
1422}
1423
1424#if defined(FEAT_VIRTUALEDIT) || defined(PROTO)
1425/*
1426 * Get virtual column in virtual mode.
1427 */
1428 void
1429getvvcol(wp, pos, start, cursor, end)
1430 win_T *wp;
1431 pos_T *pos;
1432 colnr_T *start;
1433 colnr_T *cursor;
1434 colnr_T *end;
1435{
1436 colnr_T col;
1437 colnr_T coladd;
1438 colnr_T endadd;
1439# ifdef FEAT_MBYTE
1440 char_u *ptr;
1441# endif
1442
1443 if (virtual_active())
1444 {
1445 /* For virtual mode, only want one value */
1446 getvcol(wp, pos, &col, NULL, NULL);
1447
1448 coladd = pos->coladd;
1449 endadd = 0;
1450# ifdef FEAT_MBYTE
1451 /* Cannot put the cursor on part of a wide character. */
1452 ptr = ml_get_buf(wp->w_buffer, pos->lnum, FALSE);
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001453 if (pos->col < (colnr_T)STRLEN(ptr))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001454 {
1455 int c = (*mb_ptr2char)(ptr + pos->col);
1456
1457 if (c != TAB && vim_isprintc(c))
1458 {
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001459 endadd = (colnr_T)(char2cells(c) - 1);
Bram Moolenaara5792f52005-11-23 21:25:05 +00001460 if (coladd > endadd) /* past end of line */
1461 endadd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001462 else
1463 coladd = 0;
1464 }
1465 }
1466# endif
1467 col += coladd;
1468 if (start != NULL)
1469 *start = col;
1470 if (cursor != NULL)
1471 *cursor = col;
1472 if (end != NULL)
1473 *end = col + endadd;
1474 }
1475 else
1476 getvcol(wp, pos, start, cursor, end);
1477}
1478#endif
1479
Bram Moolenaar071d4272004-06-13 20:20:40 +00001480/*
1481 * Get the leftmost and rightmost virtual column of pos1 and pos2.
1482 * Used for Visual block mode.
1483 */
1484 void
1485getvcols(wp, pos1, pos2, left, right)
1486 win_T *wp;
1487 pos_T *pos1, *pos2;
1488 colnr_T *left, *right;
1489{
1490 colnr_T from1, from2, to1, to2;
1491
1492 if (ltp(pos1, pos2))
1493 {
1494 getvvcol(wp, pos1, &from1, NULL, &to1);
1495 getvvcol(wp, pos2, &from2, NULL, &to2);
1496 }
1497 else
1498 {
1499 getvvcol(wp, pos2, &from1, NULL, &to1);
1500 getvvcol(wp, pos1, &from2, NULL, &to2);
1501 }
1502 if (from2 < from1)
1503 *left = from2;
1504 else
1505 *left = from1;
1506 if (to2 > to1)
1507 {
1508 if (*p_sel == 'e' && from2 - 1 >= to1)
1509 *right = from2 - 1;
1510 else
1511 *right = to2;
1512 }
1513 else
1514 *right = to1;
1515}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001516
1517/*
1518 * skipwhite: skip over ' ' and '\t'.
1519 */
1520 char_u *
Bram Moolenaar1387a602008-07-24 19:31:11 +00001521skipwhite(q)
1522 char_u *q;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001523{
Bram Moolenaar1387a602008-07-24 19:31:11 +00001524 char_u *p = q;
1525
Bram Moolenaar071d4272004-06-13 20:20:40 +00001526 while (vim_iswhite(*p)) /* skip to next non-white */
1527 ++p;
1528 return p;
1529}
1530
1531/*
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001532 * skip over digits
Bram Moolenaar071d4272004-06-13 20:20:40 +00001533 */
1534 char_u *
Bram Moolenaar1387a602008-07-24 19:31:11 +00001535skipdigits(q)
1536 char_u *q;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001537{
Bram Moolenaar1387a602008-07-24 19:31:11 +00001538 char_u *p = q;
1539
Bram Moolenaar071d4272004-06-13 20:20:40 +00001540 while (VIM_ISDIGIT(*p)) /* skip to next non-digit */
1541 ++p;
1542 return p;
1543}
1544
Bram Moolenaarc4956c82006-03-12 21:58:43 +00001545#if defined(FEAT_SYN_HL) || defined(FEAT_SPELL) || defined(PROTO)
Bram Moolenaar75c50c42005-06-04 22:06:24 +00001546/*
1547 * skip over digits and hex characters
1548 */
1549 char_u *
Bram Moolenaar1387a602008-07-24 19:31:11 +00001550skiphex(q)
1551 char_u *q;
Bram Moolenaar75c50c42005-06-04 22:06:24 +00001552{
Bram Moolenaar1387a602008-07-24 19:31:11 +00001553 char_u *p = q;
1554
Bram Moolenaar75c50c42005-06-04 22:06:24 +00001555 while (vim_isxdigit(*p)) /* skip to next non-digit */
1556 ++p;
1557 return p;
1558}
1559#endif
1560
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001561#if defined(FEAT_EX_EXTRA) || defined(PROTO)
1562/*
1563 * skip to digit (or NUL after the string)
1564 */
1565 char_u *
Bram Moolenaar1387a602008-07-24 19:31:11 +00001566skiptodigit(q)
1567 char_u *q;
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001568{
Bram Moolenaar1387a602008-07-24 19:31:11 +00001569 char_u *p = q;
1570
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001571 while (*p != NUL && !VIM_ISDIGIT(*p)) /* skip to next digit */
1572 ++p;
1573 return p;
1574}
1575
1576/*
1577 * skip to hex character (or NUL after the string)
1578 */
1579 char_u *
Bram Moolenaar1387a602008-07-24 19:31:11 +00001580skiptohex(q)
1581 char_u *q;
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001582{
Bram Moolenaar1387a602008-07-24 19:31:11 +00001583 char_u *p = q;
1584
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001585 while (*p != NUL && !vim_isxdigit(*p)) /* skip to next digit */
1586 ++p;
1587 return p;
1588}
1589#endif
1590
Bram Moolenaar071d4272004-06-13 20:20:40 +00001591/*
1592 * Variant of isdigit() that can handle characters > 0x100.
1593 * We don't use isdigit() here, because on some systems it also considers
1594 * superscript 1 to be a digit.
1595 * Use the VIM_ISDIGIT() macro for simple arguments.
1596 */
1597 int
1598vim_isdigit(c)
1599 int c;
1600{
1601 return (c >= '0' && c <= '9');
1602}
1603
1604/*
1605 * Variant of isxdigit() that can handle characters > 0x100.
1606 * We don't use isxdigit() here, because on some systems it also considers
1607 * superscript 1 to be a digit.
1608 */
1609 int
1610vim_isxdigit(c)
1611 int c;
1612{
1613 return (c >= '0' && c <= '9')
1614 || (c >= 'a' && c <= 'f')
1615 || (c >= 'A' && c <= 'F');
1616}
1617
Bram Moolenaar78622822005-08-23 21:00:13 +00001618#if defined(FEAT_MBYTE) || defined(PROTO)
1619/*
1620 * Vim's own character class functions. These exist because many library
1621 * islower()/toupper() etc. do not work properly: they crash when used with
1622 * invalid values or can't handle latin1 when the locale is C.
1623 * Speed is most important here.
1624 */
1625#define LATIN1LOWER 'l'
1626#define LATIN1UPPER 'U'
1627
Bram Moolenaar6e7c7f32005-08-24 22:16:11 +00001628static char_u latin1flags[257] = " UUUUUUUUUUUUUUUUUUUUUUUUUU llllllllllllllllllllllllll UUUUUUUUUUUUUUUUUUUUUUU UUUUUUUllllllllllllllllllllllll llllllll";
Bram Moolenaar936347b2012-05-25 11:56:22 +02001629static char_u latin1upper[257] = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xf7\xd8\xd9\xda\xdb\xdc\xdd\xde\xff";
1630static char_u latin1lower[257] = " !\"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xd7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff";
Bram Moolenaar78622822005-08-23 21:00:13 +00001631
1632 int
1633vim_islower(c)
1634 int c;
1635{
1636 if (c <= '@')
1637 return FALSE;
1638 if (c >= 0x80)
1639 {
1640 if (enc_utf8)
1641 return utf_islower(c);
1642 if (c >= 0x100)
1643 {
1644#ifdef HAVE_ISWLOWER
1645 if (has_mbyte)
1646 return iswlower(c);
1647#endif
1648 /* islower() can't handle these chars and may crash */
1649 return FALSE;
1650 }
1651 if (enc_latin1like)
1652 return (latin1flags[c] & LATIN1LOWER) == LATIN1LOWER;
1653 }
1654 return islower(c);
1655}
1656
1657 int
1658vim_isupper(c)
1659 int c;
1660{
1661 if (c <= '@')
1662 return FALSE;
1663 if (c >= 0x80)
1664 {
1665 if (enc_utf8)
1666 return utf_isupper(c);
1667 if (c >= 0x100)
1668 {
1669#ifdef HAVE_ISWUPPER
1670 if (has_mbyte)
1671 return iswupper(c);
1672#endif
1673 /* islower() can't handle these chars and may crash */
1674 return FALSE;
1675 }
1676 if (enc_latin1like)
1677 return (latin1flags[c] & LATIN1UPPER) == LATIN1UPPER;
1678 }
1679 return isupper(c);
1680}
1681
1682 int
1683vim_toupper(c)
1684 int c;
1685{
1686 if (c <= '@')
1687 return c;
1688 if (c >= 0x80)
1689 {
1690 if (enc_utf8)
1691 return utf_toupper(c);
1692 if (c >= 0x100)
1693 {
1694#ifdef HAVE_TOWUPPER
1695 if (has_mbyte)
1696 return towupper(c);
1697#endif
1698 /* toupper() can't handle these chars and may crash */
1699 return c;
1700 }
1701 if (enc_latin1like)
1702 return latin1upper[c];
1703 }
1704 return TOUPPER_LOC(c);
1705}
1706
1707 int
1708vim_tolower(c)
1709 int c;
1710{
1711 if (c <= '@')
1712 return c;
1713 if (c >= 0x80)
1714 {
1715 if (enc_utf8)
1716 return utf_tolower(c);
1717 if (c >= 0x100)
1718 {
1719#ifdef HAVE_TOWLOWER
1720 if (has_mbyte)
1721 return towlower(c);
1722#endif
1723 /* tolower() can't handle these chars and may crash */
1724 return c;
1725 }
1726 if (enc_latin1like)
1727 return latin1lower[c];
1728 }
1729 return TOLOWER_LOC(c);
1730}
1731#endif
1732
Bram Moolenaar071d4272004-06-13 20:20:40 +00001733/*
1734 * skiptowhite: skip over text until ' ' or '\t' or NUL.
1735 */
1736 char_u *
1737skiptowhite(p)
1738 char_u *p;
1739{
1740 while (*p != ' ' && *p != '\t' && *p != NUL)
1741 ++p;
1742 return p;
1743}
1744
1745#if defined(FEAT_LISTCMDS) || defined(FEAT_SIGNS) || defined(FEAT_SNIFF) \
1746 || defined(PROTO)
1747/*
1748 * skiptowhite_esc: Like skiptowhite(), but also skip escaped chars
1749 */
1750 char_u *
1751skiptowhite_esc(p)
1752 char_u *p;
1753{
1754 while (*p != ' ' && *p != '\t' && *p != NUL)
1755 {
1756 if ((*p == '\\' || *p == Ctrl_V) && *(p + 1) != NUL)
1757 ++p;
1758 ++p;
1759 }
1760 return p;
1761}
1762#endif
1763
1764/*
1765 * Getdigits: Get a number from a string and skip over it.
1766 * Note: the argument is a pointer to a char_u pointer!
1767 */
1768 long
1769getdigits(pp)
1770 char_u **pp;
1771{
1772 char_u *p;
1773 long retval;
1774
1775 p = *pp;
1776 retval = atol((char *)p);
1777 if (*p == '-') /* skip negative sign */
1778 ++p;
1779 p = skipdigits(p); /* skip to next non-digit */
1780 *pp = p;
1781 return retval;
1782}
1783
1784/*
1785 * Return TRUE if "lbuf" is empty or only contains blanks.
1786 */
1787 int
1788vim_isblankline(lbuf)
1789 char_u *lbuf;
1790{
1791 char_u *p;
1792
1793 p = skipwhite(lbuf);
1794 return (*p == NUL || *p == '\r' || *p == '\n');
1795}
1796
1797/*
1798 * Convert a string into a long and/or unsigned long, taking care of
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +00001799 * hexadecimal and octal numbers. Accepts a '-' sign.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001800 * If "hexp" is not NULL, returns a flag to indicate the type of the number:
1801 * 0 decimal
1802 * '0' octal
1803 * 'X' hex
1804 * 'x' hex
1805 * If "len" is not NULL, the length of the number in characters is returned.
1806 * If "nptr" is not NULL, the signed result is returned in it.
1807 * If "unptr" is not NULL, the unsigned result is returned in it.
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001808 * If "dooct" is non-zero recognize octal numbers, when > 1 always assume
1809 * octal number.
Bram Moolenaar97b2ad32006-03-18 21:40:56 +00001810 * If "dohex" is non-zero recognize hex numbers, when > 1 always assume
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001811 * hex number.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001812 */
1813 void
1814vim_str2nr(start, hexp, len, dooct, dohex, nptr, unptr)
1815 char_u *start;
1816 int *hexp; /* return: type of number 0 = decimal, 'x'
1817 or 'X' is hex, '0' = octal */
1818 int *len; /* return: detected length of number */
1819 int dooct; /* recognize octal number */
1820 int dohex; /* recognize hex number */
1821 long *nptr; /* return: signed result */
1822 unsigned long *unptr; /* return: unsigned result */
1823{
1824 char_u *ptr = start;
1825 int hex = 0; /* default is decimal */
1826 int negative = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001827 unsigned long un = 0;
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001828 int n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001829
1830 if (ptr[0] == '-')
1831 {
1832 negative = TRUE;
1833 ++ptr;
1834 }
1835
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001836 /* Recognize hex and octal. */
1837 if (ptr[0] == '0' && ptr[1] != '8' && ptr[1] != '9')
Bram Moolenaar071d4272004-06-13 20:20:40 +00001838 {
1839 hex = ptr[1];
1840 if (dohex && (hex == 'X' || hex == 'x') && vim_isxdigit(ptr[2]))
1841 ptr += 2; /* hexadecimal */
1842 else
1843 {
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001844 hex = 0; /* default is decimal */
1845 if (dooct)
1846 {
1847 /* Don't interpret "0", "08" or "0129" as octal. */
1848 for (n = 1; VIM_ISDIGIT(ptr[n]); ++n)
1849 {
1850 if (ptr[n] > '7')
1851 {
1852 hex = 0; /* can't be octal */
1853 break;
1854 }
Bram Moolenaar06af6022012-01-26 13:40:08 +01001855 if (ptr[n] >= '0')
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001856 hex = '0'; /* assume octal */
1857 }
1858 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001859 }
1860 }
1861
1862 /*
1863 * Do the string-to-numeric conversion "manually" to avoid sscanf quirks.
1864 */
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001865 if (hex == '0' || dooct > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001866 {
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001867 /* octal */
1868 while ('0' <= *ptr && *ptr <= '7')
Bram Moolenaar071d4272004-06-13 20:20:40 +00001869 {
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001870 un = 8 * un + (unsigned long)(*ptr - '0');
1871 ++ptr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001872 }
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001873 }
1874 else if (hex != 0 || dohex > 1)
1875 {
1876 /* hex */
1877 while (vim_isxdigit(*ptr))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001878 {
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001879 un = 16 * un + (unsigned long)hex2nr(*ptr);
1880 ++ptr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001881 }
1882 }
1883 else
1884 {
1885 /* decimal */
1886 while (VIM_ISDIGIT(*ptr))
1887 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001888 un = 10 * un + (unsigned long)(*ptr - '0');
1889 ++ptr;
1890 }
1891 }
1892
Bram Moolenaar071d4272004-06-13 20:20:40 +00001893 if (hexp != NULL)
1894 *hexp = hex;
1895 if (len != NULL)
1896 *len = (int)(ptr - start);
1897 if (nptr != NULL)
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +00001898 {
1899 if (negative) /* account for leading '-' for decimal numbers */
1900 *nptr = -(long)un;
1901 else
1902 *nptr = (long)un;
1903 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001904 if (unptr != NULL)
1905 *unptr = un;
1906}
1907
1908/*
1909 * Return the value of a single hex character.
1910 * Only valid when the argument is '0' - '9', 'A' - 'F' or 'a' - 'f'.
1911 */
1912 int
1913hex2nr(c)
1914 int c;
1915{
1916 if (c >= 'a' && c <= 'f')
1917 return c - 'a' + 10;
1918 if (c >= 'A' && c <= 'F')
1919 return c - 'A' + 10;
1920 return c - '0';
1921}
1922
1923#if defined(FEAT_TERMRESPONSE) \
1924 || (defined(FEAT_GUI_GTK) && defined(FEAT_WINDOWS)) || defined(PROTO)
1925/*
1926 * Convert two hex characters to a byte.
1927 * Return -1 if one of the characters is not hex.
1928 */
1929 int
1930hexhex2nr(p)
1931 char_u *p;
1932{
1933 if (!vim_isxdigit(p[0]) || !vim_isxdigit(p[1]))
1934 return -1;
1935 return (hex2nr(p[0]) << 4) + hex2nr(p[1]);
1936}
1937#endif
1938
1939/*
1940 * Return TRUE if "str" starts with a backslash that should be removed.
1941 * For MS-DOS, WIN32 and OS/2 this is only done when the character after the
1942 * backslash is not a normal file name character.
1943 * '$' is a valid file name character, we don't remove the backslash before
1944 * it. This means it is not possible to use an environment variable after a
1945 * backslash. "C:\$VIM\doc" is taken literally, only "$VIM\doc" works.
1946 * Although "\ name" is valid, the backslash in "Program\ files" must be
1947 * removed. Assume a file name doesn't start with a space.
1948 * For multi-byte names, never remove a backslash before a non-ascii
1949 * character, assume that all multi-byte characters are valid file name
1950 * characters.
1951 */
1952 int
1953rem_backslash(str)
1954 char_u *str;
1955{
1956#ifdef BACKSLASH_IN_FILENAME
1957 return (str[0] == '\\'
1958# ifdef FEAT_MBYTE
1959 && str[1] < 0x80
1960# endif
1961 && (str[1] == ' '
1962 || (str[1] != NUL
1963 && str[1] != '*'
1964 && str[1] != '?'
1965 && !vim_isfilec(str[1]))));
1966#else
1967 return (str[0] == '\\' && str[1] != NUL);
1968#endif
1969}
1970
1971/*
1972 * Halve the number of backslashes in a file name argument.
1973 * For MS-DOS we only do this if the character after the backslash
1974 * is not a normal file character.
1975 */
1976 void
1977backslash_halve(p)
1978 char_u *p;
1979{
1980 for ( ; *p; ++p)
1981 if (rem_backslash(p))
Bram Moolenaar446cb832008-06-24 21:56:24 +00001982 STRMOVE(p, p + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001983}
1984
1985/*
1986 * backslash_halve() plus save the result in allocated memory.
1987 */
1988 char_u *
1989backslash_halve_save(p)
1990 char_u *p;
1991{
1992 char_u *res;
1993
1994 res = vim_strsave(p);
1995 if (res == NULL)
1996 return p;
1997 backslash_halve(res);
1998 return res;
1999}
2000
2001#if (defined(EBCDIC) && defined(FEAT_POSTSCRIPT)) || defined(PROTO)
2002/*
2003 * Table for EBCDIC to ASCII conversion unashamedly taken from xxd.c!
2004 * The first 64 entries have been added to map control characters defined in
2005 * ascii.h
2006 */
2007static char_u ebcdic2ascii_tab[256] =
2008{
2009 0000, 0001, 0002, 0003, 0004, 0011, 0006, 0177,
2010 0010, 0011, 0012, 0013, 0014, 0015, 0016, 0017,
2011 0020, 0021, 0022, 0023, 0024, 0012, 0010, 0027,
2012 0030, 0031, 0032, 0033, 0033, 0035, 0036, 0037,
2013 0040, 0041, 0042, 0043, 0044, 0045, 0046, 0047,
2014 0050, 0051, 0052, 0053, 0054, 0055, 0056, 0057,
2015 0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
2016 0070, 0071, 0072, 0073, 0074, 0075, 0076, 0077,
2017 0040, 0240, 0241, 0242, 0243, 0244, 0245, 0246,
2018 0247, 0250, 0325, 0056, 0074, 0050, 0053, 0174,
2019 0046, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
2020 0260, 0261, 0041, 0044, 0052, 0051, 0073, 0176,
2021 0055, 0057, 0262, 0263, 0264, 0265, 0266, 0267,
2022 0270, 0271, 0313, 0054, 0045, 0137, 0076, 0077,
2023 0272, 0273, 0274, 0275, 0276, 0277, 0300, 0301,
2024 0302, 0140, 0072, 0043, 0100, 0047, 0075, 0042,
2025 0303, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
2026 0150, 0151, 0304, 0305, 0306, 0307, 0310, 0311,
2027 0312, 0152, 0153, 0154, 0155, 0156, 0157, 0160,
2028 0161, 0162, 0136, 0314, 0315, 0316, 0317, 0320,
2029 0321, 0345, 0163, 0164, 0165, 0166, 0167, 0170,
2030 0171, 0172, 0322, 0323, 0324, 0133, 0326, 0327,
2031 0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
2032 0340, 0341, 0342, 0343, 0344, 0135, 0346, 0347,
2033 0173, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
2034 0110, 0111, 0350, 0351, 0352, 0353, 0354, 0355,
2035 0175, 0112, 0113, 0114, 0115, 0116, 0117, 0120,
2036 0121, 0122, 0356, 0357, 0360, 0361, 0362, 0363,
2037 0134, 0237, 0123, 0124, 0125, 0126, 0127, 0130,
2038 0131, 0132, 0364, 0365, 0366, 0367, 0370, 0371,
2039 0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
2040 0070, 0071, 0372, 0373, 0374, 0375, 0376, 0377
2041};
2042
2043/*
2044 * Convert a buffer worth of characters from EBCDIC to ASCII. Only useful if
2045 * wanting 7-bit ASCII characters out the other end.
2046 */
2047 void
2048ebcdic2ascii(buffer, len)
2049 char_u *buffer;
2050 int len;
2051{
2052 int i;
2053
2054 for (i = 0; i < len; i++)
2055 buffer[i] = ebcdic2ascii_tab[buffer[i]];
2056}
2057#endif