Problem: Some macros are in lower case.
Solution: Make a few more macros upper case. Avoid lower case macros use an
argument twice.
char_u *s;
for (s = line; *s != NUL && (len == MAXCOL || s < line + len);
- mb_ptr_adv(s))
+ MB_PTR_ADV(s))
col += win_lbr_chartabsize(wp, line, s, col, NULL);
return (int)col;
}
int retval;
retval = lbr_chartabsize(line, *s, col);
- mb_ptr_adv(*s);
+ MB_PTR_ADV(*s);
return retval;
}
* needs a break here
*/
if (wp->w_p_lbr
- && vim_isbreak(c)
- && !vim_isbreak(s[1])
+ && VIM_ISBREAK(c)
+ && !VIM_ISBREAK(s[1])
&& wp->w_p_wrap
# ifdef FEAT_WINDOWS
&& wp->w_width != 0
for (;;)
{
ps = s;
- mb_ptr_adv(s);
+ MB_PTR_ADV(s);
c = *s;
if (!(c != NUL
- && (vim_isbreak(c)
- || (!vim_isbreak(c)
- && (col2 == col || !vim_isbreak(*ps))))))
+ && (VIM_ISBREAK(c)
+ || (!VIM_ISBREAK(c)
+ && (col2 == col || !VIM_ISBREAK(*ps))))))
break;
col2 += win_chartabsize(wp, s, col2);
break;
vcol += incr;
- mb_ptr_adv(ptr);
+ MB_PTR_ADV(ptr);
}
}
else
break;
vcol += incr;
- mb_ptr_adv(ptr);
+ MB_PTR_ADV(ptr);
}
}
if (start != NULL)
if (str != NULL)
{
- for (p = str; *p != NUL; mb_ptr_adv(p))
+ for (p = str; *p != NUL; MB_PTR_ADV(p))
ins_compl_addleader(PTR2CHAR(p));
vim_free(str);
}
if (*str != NUL && stop_arrow() != FAIL)
{
/* Insert the new value of v:char literally. */
- for (p = str; *p != NUL; mb_ptr_adv(p))
+ for (p = str; *p != NUL; MB_PTR_ADV(p))
{
c = PTR2CHAR(p);
if (c == CAR || c == K_KENTER || c == NL)
actual_len = 0;
while (*p != NUL)
{
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
++actual_len;
}
}
actual_compl_length = 0;
while (*p != NUL)
{
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
++actual_compl_length;
}
}
#ifdef FEAT_MBYTE
if (has_mbyte)
{
- mb_ptr_adv(p);
- mb_ptr_adv(s);
+ MB_PTR_ADV(p);
+ MB_PTR_ADV(s);
}
else
#endif
line = ml_get_curline();
p = line + curwin->w_cursor.col;
- mb_ptr_back(line, p);
+ MB_PTR_BACK(line, p);
/* Stop completion when the whole word was deleted. For Omni completion
* allow the word to be deleted, we won't match everything.
if (len > 0)
len -= (*mb_head_off)(p, p + len);
#endif
- for (p += len; *p != NUL; mb_ptr_adv(p))
+ for (p += len; *p != NUL; MB_PTR_ADV(p))
AppendCharToRedobuff(K_BS);
}
else
{
char_u *p = line + startcol;
- mb_ptr_back(line, p);
+ MB_PTR_BACK(line, p);
while (p > line && vim_isfilec(PTR2CHAR(p)))
- mb_ptr_back(line, p);
+ MB_PTR_BACK(line, p);
if (p == line && vim_isfilec(PTR2CHAR(p)))
startcol = 0;
else
for (p = arg + STRLEN(arg); p >= arg; )
{
xp->xp_pattern = p;
- mb_ptr_back(arg, p);
+ MB_PTR_BACK(arg, p);
if (vim_iswhite(*p))
break;
}
/*
* Find the end of the string, skipping backslashed characters.
*/
- for (p = *arg + 1; *p != NUL && *p != '"'; mb_ptr_adv(p))
+ for (p = *arg + 1; *p != NUL && *p != '"'; MB_PTR_ADV(p))
{
if (*p == '\\' && p[1] != NUL)
{
/*
* Find the end of the string, skipping ''.
*/
- for (p = *arg + 1; *p != NUL; mb_ptr_adv(p))
+ for (p = *arg + 1; *p != NUL; MB_PTR_ADV(p))
{
if (*p == '\'')
{
if (str != NULL)
{
len += (unsigned)STRLEN(str);
- for (p = str; *p != NUL; mb_ptr_adv(p))
+ for (p = str; *p != NUL; MB_PTR_ADV(p))
if (*p == '\'')
++len;
}
|| *p == '{'
|| ((flags & FNE_INCL_BR) && (*p == '[' || *p == '.'))
|| mb_nest != 0
- || br_nest != 0); mb_ptr_adv(p))
+ || br_nest != 0); MB_PTR_ADV(p))
{
if (*p == '\'')
{
/* skip over 'string' to avoid counting [ and ] inside it. */
- for (p = p + 1; *p != NUL && *p != '\''; mb_ptr_adv(p))
+ for (p = p + 1; *p != NUL && *p != '\''; MB_PTR_ADV(p))
;
if (*p == NUL)
break;
else if (*p == '"')
{
/* skip over "str\"ing" to avoid counting [ and ] inside it. */
- for (p = p + 1; *p != NUL && *p != '"'; mb_ptr_adv(p))
+ for (p = p + 1; *p != NUL && *p != '"'; MB_PTR_ADV(p))
if (*p == '\\' && p[1] != NUL)
++p;
if (*p == NUL)
/* Count up the path separators from the RHS.. so we know which part
* of the path to return. */
sepcount = 0;
- for (p = *fnamep; p < *fnamep + *fnamelen; mb_ptr_adv(p))
+ for (p = *fnamep; p < *fnamep + *fnamelen; MB_PTR_ADV(p))
if (vim_ispathsep(*p))
++sepcount;
}
/* When "/." or "/.." is used: force expansion to get rid of it. */
- for (p = *fnamep; *p != NUL; mb_ptr_adv(p))
+ for (p = *fnamep; *p != NUL; MB_PTR_ADV(p))
{
if (vim_ispathsep(*p)
&& p[1] == '.'
*usedlen += 2;
s = get_past_head(*fnamep);
while (tail > s && after_pathsep(s, tail))
- mb_ptr_back(*fnamep, tail);
+ MB_PTR_BACK(*fnamep, tail);
*fnamelen = (int)(tail - *fnamep);
#ifdef VMS
if (*fnamelen > 0)
else
{
while (tail > s && !after_pathsep(s, tail))
- mb_ptr_back(*fnamep, tail);
+ MB_PTR_BACK(*fnamep, tail);
}
}
}
if (cmd[0] == '\\' && cmd[1] != 0) /* skip escaped characters */
++cmd;
- mb_ptr_adv(cmd);
+ MB_PTR_ADV(cmd);
}
if (!eap->skip)
{
/* directory is not yet in 'runtimepath', add it */
p4 = p3 = p2 = p1 = get_past_head(ffname);
- for (p = p1; *p; mb_ptr_adv(p))
+ for (p = p1; *p; MB_PTR_ADV(p))
if (vim_ispathsep_nocolon(*p))
{
p4 = p3; p3 = p2; p2 = p1; p1 = p;
return NULL; /* It's a comment */
}
}
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
}
{
if (*p == '\\' && *(p + 1) != NUL)
++p; /* skip over escaped character */
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
}
else
#endif
len = 1;
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
if (in_quote)
bow = p;
xp->xp_pattern = p;
p -= len;
}
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
/*
arg = p + 1;
else if (*p == '\\' && *(p + 1) != NUL)
++p; /* skip over escaped character */
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
xp->xp_pattern = arg;
}
p = eap->arg;
#endif
- for ( ; *p; mb_ptr_adv(p))
+ for ( ; *p; MB_PTR_ADV(p))
{
if (*p == Ctrl_V)
{
else
++p;
}
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
return p;
}
if (*flagp & SSOP_SLASH)
{
/* change all backslashes to forward slashes */
- for (p = sname; *p != NUL; mb_ptr_adv(p))
+ for (p = sname; *p != NUL; MB_PTR_ADV(p))
if (*p == '\\')
*p = '/';
}
t = p;
had_sep = FALSE;
}
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
return t;
}
if (e - 4 > s && STRNICMP(e - 4, ".vim", 4) == 0)
{
e -= 4;
- for (s = e; s > match; mb_ptr_back(match, s))
+ for (s = e; s > match; MB_PTR_BACK(match, s))
if (s < match || vim_ispathsep(*s))
break;
++s;
* Then truncate what is after the '/', '\' or ':' to 8 characters for
* MSDOS and 26 characters for AMIGA, a lot more for UNIX.
*/
- for (ptr = retval + fnamelen; ptr > retval; mb_ptr_back(retval, ptr))
+ for (ptr = retval + fnamelen; ptr > retval; MB_PTR_BACK(retval, ptr))
{
if (*ext == '.'
#ifdef USE_LONG_FNAME
}
else
{
- mb_ptr_adv(s);
+ MB_PTR_ADV(s);
}
}
}
--flp->lvl_next;
}
else
- mb_ptr_adv(s);
+ MB_PTR_ADV(s);
}
/* The level can't go negative, must be missing a start marker. */
for (;;)
{
w = chartabsize(p, col);
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
if (*p == NUL) /* don't count the last character */
break;
col += w;
else if (*p == DLG_HOTKEY_CHAR)
*p++ = '_';
else
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
array[count] = NULL; /* currently not relied upon, but doesn't hurt */
}
/*
* macros.h: macro definitions for often used code
+ *
+ * Macros should be ALL_CAPS. An exception is for where a function is
+ * replaced and an argument is not used more than once.
*/
/*
#endif
/*
- * vim_isbreak() is used very often if 'linebreak' is set, use a macro to make
- * it work fast.
+ * VIM_ISBREAK() is used very often if 'linebreak' is set, use a macro to make
+ * it work fast. Only works for single byte characters!
*/
-#define vim_isbreak(c) (breakat_flags[(char_u)(c)])
+#define VIM_ISBREAK(c) ((c) < 256 && breakat_flags[(char_u)(c)])
/*
* On VMS file names are different and require a translation.
# define mch_stat(n, p) vim_stat((n), (p))
# else
# ifdef STAT_IGNORES_SLASH
- /* On Solaris stat() accepts "file/" as if it was "file". Return -1 if
- * the name ends in "/" and it's not a directory. */
-# define mch_stat(n, p) (illegal_slash(n) ? -1 : stat((n), (p)))
+# define mch_stat(n, p) vim_stat((n), (p))
# else
# define mch_stat(n, p) stat((n), (p))
# endif
#endif
/*
- * mb_ptr_adv(): advance a pointer to the next character, taking care of
+ * MB_PTR_ADV(): advance a pointer to the next character, taking care of
* multi-byte characters if needed.
- * mb_ptr_back(): backup a pointer to the previous character, taking care of
+ * MB_PTR_BACK(): backup a pointer to the previous character, taking care of
* multi-byte characters if needed.
* MB_COPY_CHAR(f, t): copy one char from "f" to "t" and advance the pointers.
* PTR2CHAR(): get character from pointer.
*/
#ifdef FEAT_MBYTE
/* Get the length of the character p points to */
-# define MB_PTR2LEN(p) (has_mbyte ? (*mb_ptr2len)(p) : 1)
+# define MB_PTR2LEN(p) (has_mbyte ? (*mb_ptr2len)(p) : 1)
/* Advance multi-byte pointer, skip over composing chars. */
-# define mb_ptr_adv(p) p += has_mbyte ? (*mb_ptr2len)(p) : 1
+# define MB_PTR_ADV(p) p += has_mbyte ? (*mb_ptr2len)(p) : 1
/* Advance multi-byte pointer, do not skip over composing chars. */
-# define mb_cptr_adv(p) p += enc_utf8 ? utf_ptr2len(p) : has_mbyte ? (*mb_ptr2len)(p) : 1
+# define MB_CPTR_ADV(p) p += enc_utf8 ? utf_ptr2len(p) : has_mbyte ? (*mb_ptr2len)(p) : 1
/* Backup multi-byte pointer. Only use with "p" > "s" ! */
-# define mb_ptr_back(s, p) p -= has_mbyte ? ((*mb_head_off)(s, p - 1) + 1) : 1
+# define MB_PTR_BACK(s, p) p -= has_mbyte ? ((*mb_head_off)(s, p - 1) + 1) : 1
/* get length of multi-byte char, not including composing chars */
# define MB_CPTR2LEN(p) (enc_utf8 ? utf_ptr2len(p) : (*mb_ptr2len)(p))
#else
# define MB_PTR2LEN(p) 1
# define MB_CPTR2LEN(p) 1
-# define mb_ptr_adv(p) ++p
-# define mb_cptr_adv(p) ++p
-# define mb_ptr_back(s, p) --p
+# define MB_PTR_ADV(p) ++p
+# define MB_CPTR_ADV(p) ++p
+# define MB_PTR_BACK(s, p) --p
# define MB_COPY_CHAR(f, t) *t++ = *f++
# define MB_CHARLEN(p) STRLEN(p)
# define MB_CHAR2LEN(c) 1
return NULL;
/* Truncate the line to fit it in the window */
len = 0;
- for (p = s; *p != NUL; mb_ptr_adv(p))
+ for (p = s; *p != NUL; MB_PTR_ADV(p))
{
len += ptr2cells(p);
if (len >= Columns - lead_len)
char_u *p)
{
if (p > line)
- mb_ptr_back(line, p);
+ MB_PTR_BACK(line, p);
return p;
}
#ifdef USE_X11R6_XIM
-static void xim_instantiate_cb(Display *display, XPointer client_data, XPointer call_data);
static void xim_destroy_cb(XIM im, XPointer client_data, XPointer call_data);
static void
if (s != NULL)
{
STRCPY(s, f);
- for (d = s; *d != NUL; mb_ptr_adv(d))
+ for (d = s; *d != NUL; MB_PTR_ADV(d))
if (vim_ispathsep(*d))
*d = '%';
d = concat_fnames(dir, s, TRUE);
#ifdef WIN3264
if (retval != NULL)
- for (t = gettail(retval); *t != NUL; mb_ptr_adv(t))
+ for (t = gettail(retval); *t != NUL; MB_PTR_ADV(t))
if (*t == ':')
*t = '%';
#endif
if (buf_fname == NULL)
buf_fname = buf->b_fname;
else
- for (t = gettail(buf_fname); *t != NUL; mb_ptr_adv(t))
+ for (t = gettail(buf_fname); *t != NUL; MB_PTR_ADV(t))
if (*t == ':')
*t = '%';
}
{
if (*arg == '\\')
STRMOVE(arg, arg + 1);
- mb_ptr_adv(arg);
+ MB_PTR_ADV(arg);
}
if (*arg != NUL)
{
STRCPY(tearpath, menu_path);
idx = (int)(next_name - path_name - 1);
- for (s = tearpath; *s && s < tearpath + idx; mb_ptr_adv(s))
+ for (s = tearpath; *s && s < tearpath + idx; MB_PTR_ADV(s))
{
if ((*s == '\\' || *s == Ctrl_V) && s[1])
{
{
char_u *p;
- for (p = name; *p && *p != '.'; mb_ptr_adv(p))
+ for (p = name; *p && *p != '.'; MB_PTR_ADV(p))
{
if (*p == '\\' || *p == Ctrl_V)
{
{
char_u *p;
- for (p = name; *p && *p != '.'; mb_ptr_adv(p))
+ for (p = name; *p && *p != '.'; MB_PTR_ADV(p))
if (*p == '\\')
STRMOVE(p, p + 1);
}
}
/* advance to the next character */
- mb_ptr_adv(r);
+ MB_PTR_ADV(r);
}
if (copy)
while (old_size < repl_size && p > leader)
{
- mb_ptr_back(leader, p);
+ MB_PTR_BACK(leader, p);
old_size += ptr2cells(p);
}
l = lead_repl_len - (int)(endp - p);
while (*s != NUL && --column >= 0)
{
col += win_lbr_chartabsize(wp, line, s, (colnr_T)col, NULL);
- mb_ptr_adv(s);
+ MB_PTR_ADV(s);
}
/*
{
if (vim_ispathsep_nocolon(*p2))
p1 = p2 + 1;
- mb_ptr_adv(p2);
+ MB_PTR_ADV(p2);
}
return p1;
}
dir_end = next_dir_end;
look_for_sep = TRUE;
}
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
return dir_end;
}
getnextcomp(char_u *fname)
{
while (*fname && !vim_ispathsep(*fname))
- mb_ptr_adv(fname);
+ MB_PTR_ADV(fname);
if (*fname)
++fname;
return fname;
{
if (vim_ispathsep(**psep))
return OK;
- mb_ptr_back(path, *psep);
+ MB_PTR_BACK(path, *psep);
}
return FAIL;
/* skip to the file or directory name */
if (cutoff != NULL)
while (vim_ispathsep(*cutoff))
- mb_ptr_adv(cutoff);
+ MB_PTR_ADV(cutoff);
return cutoff;
}
static int
has_env_var(char_u *p)
{
- for ( ; *p; mb_ptr_adv(p))
+ for ( ; *p; MB_PTR_ADV(p))
{
if (*p == '\\' && p[1] != NUL)
++p;
static int
has_special_wildchar(char_u *p)
{
- for ( ; *p; mb_ptr_adv(p))
+ for ( ; *p; MB_PTR_ADV(p))
{
/* Allow for escaping. */
if (*p == '\\' && p[1] != NUL)
/* Find the last path separator before the space. */
p1 = p_sh;
- for (p2 = p_sh; p2 < p; mb_ptr_adv(p2))
+ for (p2 = p_sh; p2 < p; MB_PTR_ADV(p2))
if (vim_ispathsep(*p2))
p1 = p2 + 1;
p = vim_strnsave(p1, (int)(p - p1));
/* Count a tab for what it's worth (if list mode not on) */
#ifdef FEAT_LINEBREAK
csize = win_lbr_chartabsize(curwin, line, ptr, col, &head);
- mb_ptr_adv(ptr);
+ MB_PTR_ADV(ptr);
#else
csize = lbr_chartabsize_adv(line, &ptr, col);
#endif
/* First count the number of extra bytes required. */
length = (unsigned)STRLEN(string) + 3; /* two quotes and a trailing NUL */
- for (p = string; *p != NUL; mb_ptr_adv(p))
+ for (p = string; *p != NUL; MB_PTR_ADV(p))
{
# ifdef WIN32
if (!p_ssl)
{
if (*p == c)
retval = p;
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
return retval;
}
{
if (vim_strchr(charset, *s) != NULL)
return s;
- mb_ptr_adv(s);
+ MB_PTR_ADV(s);
}
return NULL;
}
* Used for systems where stat() ignores a trailing slash on a file name.
* The Vim code assumes a trailing slash is only ignored for a directory.
*/
- int
+ static int
illegal_slash(char *name)
{
if (name[0] == NUL)
return FALSE; /* trailing slash for a directory */
return TRUE;
}
+
+/*
+ * Special implementation of mch_stat() for Solaris.
+ */
+ int
+vim_stat(const char *name, stat_T *stp)
+{
+ /* On Solaris stat() accepts "file/" as if it was "file". Return -1 if
+ * the name ends in "/" and it's not a directory. */
+ return illegal_slash(n) ? -1 : stat(n, p);
+}
#endif
#if defined(CURSOR_SHAPE) || defined(PROTO)
* the part of which is displayed at the block's beginning. Let's start
* searching from the next character. */
if (bd.startspaces)
- mb_ptr_adv(non_white);
+ MB_PTR_ADV(non_white);
/* The character's column is in "bd.start_vcol". */
non_white_col = bd.start_vcol;
if (verbatim_copy_width + incr > destination_col)
break;
verbatim_copy_width += incr;
- mb_ptr_adv(verbatim_copy_end);
+ MB_PTR_ADV(verbatim_copy_end);
}
/* If "destination_col" is different from the width of the initial
goto end;
p = ml_get_cursor();
if (dir == FORWARD && *p != NUL)
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
ptr = vim_strsave(p);
if (ptr == NULL)
goto end;
oldp = ml_get_curline();
p = oldp + curwin->w_cursor.col;
if (dir == FORWARD && *p != NUL)
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
ptr = vim_strnsave(oldp, p - oldp);
if (ptr == NULL)
goto end;
if (has_mbyte)
{
cend = curr + currsize;
- mb_ptr_back(curr, cend);
+ MB_PTR_BACK(curr, cend);
endcurr1 = (*mb_ptr2char)(cend);
if (cend > curr)
{
- mb_ptr_back(curr, cend);
+ MB_PTR_BACK(curr, cend);
endcurr2 = (*mb_ptr2char)(cend);
}
}
}
#endif
prev_pstart = pstart;
- mb_ptr_adv(pstart);
+ MB_PTR_ADV(pstart);
}
bdp->start_char_vcols = incr;
if (bdp->start_vcol < oap->start_vcol) /* line too short */
{
if (ptr2cells(s) != 1)
errmsg = (char_u *)N_("E595: contains unprintable or wide character");
- mb_ptr_adv(s);
+ MB_PTR_ADV(s);
}
}
#endif
#ifdef BACKSLASH_IN_FILENAME
/* For MS-Windows et al. we don't double backslashes at the start and
* before a file name character. */
- for (var = buf; *var != NUL; mb_ptr_adv(var))
+ for (var = buf; *var != NUL; MB_PTR_ADV(var))
if (var[0] == '\\' && var[1] == '\\'
&& expand_option_idx >= 0
&& (options[expand_option_idx].flags & P_EXPAND)
for (p = p_langmap; p[0] != NUL; )
{
for (p2 = p; p2[0] != NUL && p2[0] != ',' && p2[0] != ';';
- mb_ptr_adv(p2))
+ MB_PTR_ADV(p2))
{
if (p2[0] == '\\' && p2[1] != NUL)
++p2;
to = NUL;
if (p2 == NULL)
{
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
if (p[0] != ',')
{
if (p[0] == '\\')
langmap_mapchar[from & 255] = to;
/* Advance to next pair */
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
if (p2 != NULL)
{
- mb_ptr_adv(p2);
+ MB_PTR_ADV(p2);
if (*p == ';')
{
p = p2;
int
mch_has_exp_wildcard(char_u *p)
{
- for ( ; *p; mb_ptr_adv(p))
+ for ( ; *p; MB_PTR_ADV(p))
{
if (*p == '\\' && p[1] != NUL)
++p;
int
mch_has_wildcard(char_u *p)
{
- for ( ; *p; mb_ptr_adv(p))
+ for ( ; *p; MB_PTR_ADV(p))
{
if (*p == '\\' && p[1] != NUL)
++p;
{
if (*p == psepcN)
*p = psepc;
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
}
vim_strncpy((char_u *)buf, (char_u *)name, sizeof(buf) - 1);
p = buf + STRLEN(buf);
if (p > buf)
- mb_ptr_back(buf, p);
+ MB_PTR_BACK(buf, p);
/* Remove trailing '\\' except root path. */
if (p > buf && (*p == '\\' || *p == '/') && p[-1] != ':')
int
mch_has_exp_wildcard(char_u *p)
{
- for ( ; *p; mb_ptr_adv(p))
+ for ( ; *p; MB_PTR_ADV(p))
{
if (vim_strchr((char_u *)"?*[", *p) != NULL
|| (*p == '~' && p[1] != NUL))
int
mch_has_wildcard(char_u *p)
{
- for ( ; *p; mb_ptr_adv(p))
+ for ( ; *p; MB_PTR_ADV(p))
{
if (vim_strchr((char_u *)
# ifdef VIM_BACKTICK
int
mch_has_exp_wildcard(char_u *p)
{
- for ( ; *p; mb_ptr_adv(p))
+ for ( ; *p; MB_PTR_ADV(p))
{
if (*p == '\\' && p[1] != NUL)
++p;
int
mch_has_wildcard(char_u *p)
{
- for ( ; *p; mb_ptr_adv(p))
+ for ( ; *p; MB_PTR_ADV(p))
{
if (*p == '\\' && p[1] != NUL)
++p;
{
char_u *p = pchBuf;
for (n = 0; n < cchwritten; n++)
- mb_cptr_adv(p);
+ MB_CPTR_ADV(p);
written = p - pchBuf;
g_coord.X += (SHORT)mb_string2cells(pchBuf, written);
}
case 3: p = pum_array[idx].pum_extra; break;
}
if (p != NULL)
- for ( ; ; mb_ptr_adv(p))
+ for ( ; ; MB_PTR_ADV(p))
{
if (s == NULL)
s = p;
{
size -= has_mbyte
? (*mb_ptr2cells)(rt) : 1;
- mb_ptr_adv(rt);
+ MB_PTR_ADV(rt);
} while (size > pum_width);
if (size < pum_width)
int after_pathsep(char_u *b, char_u *p);
int same_directory(char_u *f1, char_u *f2);
int vim_chdirfile(char_u *fname);
-int illegal_slash(char *name);
+int vim_stat(const char *name, stat_T *stp);
char_u *parse_shape_opt(int what);
int get_shape_idx(int mouse);
void update_mouseshape(int shape_idx);
{
++p;
if (*p != ']' && *p != NUL)
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
else if (*p == '\\'
&& !reg_cpo_bsl
mymagic = MAGIC_OFF;
get_cpo_flags();
- for (; p[0] != NUL; mb_ptr_adv(p))
+ for (; p[0] != NUL; MB_PTR_ADV(p))
{
if (p[0] == dirc) /* found end of regexp */
break;
{
if (cstrncmp(s, prog->regmust, &prog->regmlen) == 0)
break; /* Found it. */
- mb_ptr_adv(s);
+ MB_PTR_ADV(s);
}
#endif
else
{
if (cstrncmp(s, prog->regmust, &prog->regmlen) == 0)
break; /* Found it. */
- mb_ptr_adv(s);
+ MB_PTR_ADV(s);
}
if (s == NULL) /* Not present. */
goto theend;
return TRUE;
}
-#define ADVANCE_REGINPUT() mb_ptr_adv(reginput)
+#define ADVANCE_REGINPUT() MB_PTR_ADV(reginput)
/*
* The arguments from BRACE_LIMITS are stored here. They are actually local
{
/* Skip composing characters. */
while (utf_iscomposing(utf_ptr2char(reginput)))
- mb_cptr_adv(reginput);
+ MB_CPTR_ADV(reginput);
}
#endif
break;
no = FAIL;
else
{
- mb_ptr_back(regline, rp->rs_un.regsave.rs_u.ptr);
+ MB_PTR_BACK(regline, rp->rs_un.regsave.rs_u.ptr);
if (limit > 0 && (long)(behind_pos.rs_u.ptr
- rp->rs_un.regsave.rs_u.ptr) > limit)
no = FAIL;
fast_breakcheck();
}
else
- mb_ptr_back(regline, reginput);
+ MB_PTR_BACK(regline, reginput);
}
else
{
while (*scan != NUL && count < maxcount)
{
++count;
- mb_ptr_adv(scan);
+ MB_PTR_ADV(scan);
}
if (!REG_MULTI || !WITH_NL(OP(p)) || reglnum > rex.reg_maxline
|| rex.reg_line_lbr || count == maxcount)
{
if (vim_isIDc(PTR2CHAR(scan)) && (testval || !VIM_ISDIGIT(*scan)))
{
- mb_ptr_adv(scan);
+ MB_PTR_ADV(scan);
}
else if (*scan == NUL)
{
if (vim_iswordp_buf(scan, rex.reg_buf)
&& (testval || !VIM_ISDIGIT(*scan)))
{
- mb_ptr_adv(scan);
+ MB_PTR_ADV(scan);
}
else if (*scan == NUL)
{
{
if (vim_isfilec(PTR2CHAR(scan)) && (testval || !VIM_ISDIGIT(*scan)))
{
- mb_ptr_adv(scan);
+ MB_PTR_ADV(scan);
}
else if (*scan == NUL)
{
else if (vim_isprintc(PTR2CHAR(scan)) == 1
&& (testval || !VIM_ISDIGIT(*scan)))
{
- mb_ptr_adv(scan);
+ MB_PTR_ADV(scan);
}
else if (rex.reg_line_lbr && *scan == '\n' && WITH_NL(OP(p)))
++scan;
{
int had_backslash = FALSE;
- for (s = eval_result; *s != NUL; mb_ptr_adv(s))
+ for (s = eval_result; *s != NUL; MB_PTR_ADV(s))
{
/* Change NL to CR, so that it becomes a line break,
* unless called from vim_regexec_nl().
EMSG(_(e_nopresub));
return FAIL;
}
- for (lp = reg_prev_sub; *lp != NUL; mb_cptr_adv(lp))
+ for (lp = reg_prev_sub; *lp != NUL; MB_CPTR_ADV(lp))
{
EMIT(PTR2CHAR(lp));
if (lp != reg_prev_sub)
else
EMIT(result);
regparse = endp;
- mb_ptr_adv(regparse);
+ MB_PTR_ADV(regparse);
return OK;
}
/*
if (*regparse == '^') /* negated range */
{
negated = TRUE;
- mb_ptr_adv(regparse);
+ MB_PTR_ADV(regparse);
EMIT(NFA_START_NEG_COLL);
}
else
startc = '-';
EMIT(startc);
EMIT(NFA_CONCAT);
- mb_ptr_adv(regparse);
+ MB_PTR_ADV(regparse);
}
/* Emit the OR branches for each character in the [] */
emit_range = FALSE;
{
emit_range = TRUE;
startc = oldstartc;
- mb_ptr_adv(regparse);
+ MB_PTR_ADV(regparse);
continue; /* reading the end of the range */
}
)
)
{
- mb_ptr_adv(regparse);
+ MB_PTR_ADV(regparse);
if (*regparse == 'n')
startc = reg_string ? NL : NFA_NEWL;
/* TODO(RE) This needs more testing */
startc = coll_get_char();
got_coll_char = TRUE;
- mb_ptr_back(old_regparse, regparse);
+ MB_PTR_BACK(old_regparse, regparse);
}
else
{
}
}
- mb_ptr_adv(regparse);
+ MB_PTR_ADV(regparse);
} /* while (p < endp) */
- mb_ptr_back(old_regparse, regparse);
+ MB_PTR_BACK(old_regparse, regparse);
if (*regparse == '-') /* if last, '-' is just a char */
{
EMIT('-');
/* skip the trailing ] */
regparse = endp;
- mb_ptr_adv(regparse);
+ MB_PTR_ADV(regparse);
/* Mark end of the collection. */
if (negated == TRUE)
#ifdef FEAT_MBYTE
prev_ptr = ptr;
#endif
- mb_ptr_adv(ptr);
+ MB_PTR_ADV(ptr);
}
/* When:
* Found last space before word: check for line break.
*/
if (wp->w_p_lbr && c0 == c
- && vim_isbreak(c) && !vim_isbreak(*ptr))
+ && VIM_ISBREAK(c) && !VIM_ISBREAK(*ptr))
{
# ifdef FEAT_MBYTE
int mb_off = has_mbyte ? (*mb_head_off)(line, ptr - 1) : 0;
{
s += skip_status_match_char(xp, s);
len += ptr2cells(s);
- mb_ptr_adv(s);
+ MB_PTR_ADV(s);
}
return len;
while (len > room)
{
len -= ptr2cells(p);
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
else
#endif
/* We search forward until the cursor, because searching backwards is
* very slow for DBCS encodings. */
- for (p = line; p < line + curwin->w_cursor.col; mb_ptr_adv(p))
+ for (p = line; p < line + curwin->w_cursor.col; MB_PTR_ADV(p))
if (*p == '>' || *p == '<')
{
lc = *p;
{
if (*p == '<') /* find '<' under/before cursor */
break;
- mb_ptr_back(line, p);
+ MB_PTR_BACK(line, p);
if (*p == '>') /* find '>' before cursor */
break;
}
pos.lnum = curwin->w_cursor.lnum;
pos.col = (colnr_T)(p - line);
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
if (end_tag)
/* check that there is a '/' after the '<' */
return *p == '/';
*/
inc_cursor();
p = ml_get_cursor();
- for (cp = p; *cp != NUL && *cp != '>' && !vim_iswhite(*cp); mb_ptr_adv(cp))
+ for (cp = p; *cp != NUL && *cp != '>' && !vim_iswhite(*cp); MB_PTR_ADV(cp))
;
len = (int)(cp - p);
if (len == 0)
{
do
{
- mb_ptr_adv(mi.mi_fend);
+ MB_PTR_ADV(mi.mi_fend);
} while (*mi.mi_fend != NUL && spell_iswordp(mi.mi_fend, wp));
if (capcol != NULL && *capcol == 0 && wp->w_s->b_cap_prog != NULL)
/* case-fold the word with one non-word character, so that we can check
* for the word end. */
if (*mi.mi_fend != NUL)
- mb_ptr_adv(mi.mi_fend);
+ MB_PTR_ADV(mi.mi_fend);
(void)spell_casefold(ptr, (int)(mi.mi_fend - ptr), mi.mi_fword,
MAXWLEN + 1);
else if (mi.mi_end == ptr)
/* Always include at least one character. Required for when there
* is a mixup in "midword". */
- mb_ptr_adv(mi.mi_end);
+ MB_PTR_ADV(mi.mi_end);
else if (mi.mi_result == SP_BAD
&& LANGP_ENTRY(wp->w_s->b_langp, 0)->lp_slang->sl_nobreak)
{
fp = mi.mi_fword;
for (;;)
{
- mb_ptr_adv(p);
- mb_ptr_adv(fp);
+ MB_PTR_ADV(p);
+ MB_PTR_ADV(fp);
if (p >= mi.mi_end)
break;
mi.mi_compoff = (int)(fp - mi.mi_fword);
p = mip->mi_word;
if (STRNCMP(ptr, p, wlen) != 0)
{
- for (s = ptr; s < ptr + wlen; mb_ptr_adv(s))
- mb_ptr_adv(p);
+ for (s = ptr; s < ptr + wlen; MB_PTR_ADV(s))
+ MB_PTR_ADV(p);
wlen = (int)(p - mip->mi_word);
}
}
{
/* case folding may have changed the length */
p = mip->mi_word;
- for (s = ptr; s < ptr + mip->mi_compoff; mb_ptr_adv(s))
- mb_ptr_adv(p);
+ for (s = ptr; s < ptr + mip->mi_compoff; MB_PTR_ADV(s))
+ MB_PTR_ADV(p);
}
else
#endif
* character we do not accept a Onecap word. We do
* accept a no-caps word, even when the dictionary
* word specifies ONECAP. */
- mb_ptr_back(mip->mi_word, p);
+ MB_PTR_BACK(mip->mi_word, p);
if (spell_iswordp_nmw(p, mip->mi_win)
? capflags == WF_ONECAP
: (flags & WF_ONECAP) != 0
p = mip->mi_fword;
if (STRNCMP(ptr, p, wlen) != 0)
{
- for (s = ptr; s < ptr + wlen; mb_ptr_adv(s))
- mb_ptr_adv(p);
+ for (s = ptr; s < ptr + wlen; MB_PTR_ADV(s))
+ MB_PTR_ADV(p);
mip->mi_compoff = (int)(p - mip->mi_fword);
}
}
p = mip->mi_fend;
do
{
- mb_ptr_adv(mip->mi_fend);
+ MB_PTR_ADV(mip->mi_fend);
} while (*mip->mi_fend != NUL && spell_iswordp(mip->mi_fend, mip->mi_win));
/* Include the non-word character so that we can check for the word end. */
if (*mip->mi_fend != NUL)
- mb_ptr_adv(mip->mi_fend);
+ MB_PTR_ADV(mip->mi_fend);
(void)spell_casefold(p, (int)(mip->mi_fend - p),
mip->mi_fword + mip->mi_fwordlen,
int past_second = FALSE; /* past second word char */
/* find first letter */
- for (p = word; !spell_iswordp_nmw(p, curwin); mb_ptr_adv(p))
+ for (p = word; !spell_iswordp_nmw(p, curwin); MB_PTR_ADV(p))
if (end == NULL ? *p == NUL : p >= end)
return 0; /* only non-word characters, illegal word */
#ifdef FEAT_MBYTE
* Need to check all letters to find a word with mixed upper/lower.
* But a word with an upper char only at start is a ONECAP.
*/
- for ( ; end == NULL ? *p != NUL : p < end; mb_ptr_adv(p))
+ for ( ; end == NULL ? *p != NUL : p < end; MB_PTR_ADV(p))
if (spell_iswordp_nmw(p, curwin))
{
c = PTR2CHAR(p);
/* Count the number of UPPER and lower case letters. */
l = u = 0;
first = FALSE;
- for (p = word; p < end; mb_ptr_adv(p))
+ for (p = word; p < end; MB_PTR_ADV(p))
{
c = PTR2CHAR(p);
if (SPELL_ISUPPER(c))
p = line + curwin->w_cursor.col;
/* Backup to before start of word. */
while (p > line && spell_iswordp_nmw(p, curwin))
- mb_ptr_back(line, p);
+ MB_PTR_BACK(line, p);
/* Forward to start of word. */
while (*p != NUL && !spell_iswordp_nmw(p, curwin))
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
if (!spell_iswordp_nmw(p, curwin)) /* No word found. */
{
p = line + endcol;
for (;;)
{
- mb_ptr_back(line, p);
+ MB_PTR_BACK(line, p);
if (p == line || spell_iswordp_nmw(p, curwin))
break;
if (vim_regexec(®match, p, 0)
/* Get pointer to last char of previous word. */
p = preword + sp->ts_prewordlen;
- mb_ptr_back(preword, p);
+ MB_PTR_BACK(preword, p);
}
}
/* Give a penalty when changing non-word char to word
* char, e.g., "thes," -> "these". */
p = fword + sp->ts_fidx;
- mb_ptr_back(fword, p);
+ MB_PTR_BACK(fword, p);
if (!spell_iswordp(p, curwin))
{
p = preword + STRLEN(preword);
- mb_ptr_back(preword, p);
+ MB_PTR_BACK(preword, p);
if (spell_iswordp(p, curwin))
newscore += SCORE_NONWORD;
}
* to the score. Also for the soundfold
* tree (might seem illogical but does
* give better scores). */
- mb_ptr_back(tword, p);
+ MB_PTR_BACK(tword, p);
if (c == mb_ptr2char(p))
sp->ts_score -= SCORE_INS
- SCORE_INSDUP;
char_u *p;
int i = 0;
- for (p = fword; p < fword + flen; mb_ptr_adv(p))
+ for (p = fword; p < fword + flen; MB_PTR_ADV(p))
++i;
- for (p = word; i > 0; mb_ptr_adv(p))
+ for (p = word; i > 0; MB_PTR_ADV(p))
--i;
return (int)(p - word);
}
badlen = (int)(pbad - su->su_badptr);
if (goodlen <= 0 || badlen <= 0)
break;
- mb_ptr_back(goodword, pgood);
- mb_ptr_back(su->su_badptr, pbad);
+ MB_PTR_BACK(goodword, pgood);
+ MB_PTR_BACK(su->su_badptr, pbad);
#ifdef FEAT_MBYTE
if (has_mbyte)
{
char_u *p = start;
while (*p != NUL && spell_iswordp(p, win))
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
return p;
}
line = ml_get_curline();
for (p = line + startcol; p > line; )
{
- mb_ptr_back(line, p);
+ MB_PTR_BACK(line, p);
if (spell_iswordp_nmw(p, curwin))
break;
}
while (p > line)
{
col = (int)(p - line);
- mb_ptr_back(line, p);
+ MB_PTR_BACK(line, p);
if (!spell_iswordp(p, curwin))
break;
col = 0;
for (p = from, s = to; *p != NUL && *s != NUL; )
{
c = mb_cptr2char_adv(&p);
- mb_cptr_adv(s);
+ MB_CPTR_ADV(s);
if (c >= 256)
++lp->sl_sal_first[c & 0xff];
}
{
p = aff_entry->ae_add
+ STRLEN(aff_entry->ae_add);
- mb_ptr_back(aff_entry->ae_add, p);
+ MB_PTR_BACK(aff_entry->ae_add, p);
if (PTR2CHAR(p) == c_up)
{
upper = TRUE;
{
/* Replace underscore with space (can't include a space
* directly). */
- for (p = items[1]; *p != NUL; mb_ptr_adv(p))
+ for (p = items[1]; *p != NUL; MB_PTR_ADV(p))
if (*p == '_')
*p = ' ';
- for (p = items[2]; *p != NUL; mb_ptr_adv(p))
+ for (p = items[2]; *p != NUL; MB_PTR_ADV(p))
if (*p == '_')
*p = ' ';
add_fromto(spin, items[0][3] == 'S'
/* Truncate the word at the "/", set "afflist" to what follows.
* Replace "\/" by "/" and "\\" by "\". */
afflist = NULL;
- for (p = w; *p != NUL; mb_ptr_adv(p))
+ for (p = w; *p != NUL; MB_PTR_ADV(p))
{
if (*p == '\\' && (p[1] == '\\' || p[1] == '/'))
STRMOVE(p, p + 1);
{
i = mb_charlen(ae->ae_chop);
for ( ; i > 0; --i)
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
else
#endif
p = newword + STRLEN(newword);
i = (int)MB_CHARLEN(ae->ae_chop);
for ( ; i > 0; --i)
- mb_ptr_back(newword, p);
+ MB_PTR_BACK(newword, p);
*p = NUL;
}
if (ae->ae_add != NULL)
if (off > 0)
{
while (off-- > 0 && *p != NUL)
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
else if (off < 0)
{
while (off++ < 0 && base < p)
- mb_ptr_back(base, p);
+ MB_PTR_BACK(base, p);
}
col = (int)(p - base);
}
if (off > 0)
{
while (off-- && *p != NUL)
- mb_ptr_adv(p);
+ MB_PTR_ADV(p);
}
else if (off < 0)
{
while (off++ && base < p)
- mb_ptr_back(base, p);
+ MB_PTR_BACK(base, p);
}
col = (int)(p - base);
}
tail = p + 1;
if (p[1] != NUL)
while (vim_ispathsep(*tail))
- mb_ptr_adv(tail);
+ MB_PTR_ADV(tail);
else if (p > start)
--p; /* strip preceding path separator */
STRMOVE(p, tail);
/* Skip to after ".." or "../" or "..///". */
tail = p + 2;
while (vim_ispathsep(*tail))
- mb_ptr_adv(tail);
+ MB_PTR_ADV(tail);
if (components > 0) /* strip one preceding component */
{
--p;
/* Skip back to after previous '/'. */
while (p > start && !after_pathsep(start, p))
- mb_ptr_back(start, p);
+ MB_PTR_BACK(start, p);
if (!do_strip)
{
while (count < vcol && *ptr != NUL)
{
count += win_lbr_chartabsize(wp, line, ptr, count, NULL);
- mb_ptr_adv(ptr);
+ MB_PTR_ADV(ptr);
}
return (int)(ptr - line);
}
munged_name = vim_strsave(ffname);
if (munged_name == NULL)
return NULL;
- for (p = munged_name; *p != NUL; mb_ptr_adv(p))
+ for (p = munged_name; *p != NUL; MB_PTR_ADV(p))
if (vim_ispathsep(*p))
*p = '%';
}
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 451,
/**/
450,
/**/
*/
ptr = line + col;
while (*ptr != NUL && !vim_isfilec(*ptr))
- mb_ptr_adv(ptr);
+ MB_PTR_ADV(ptr);
if (*ptr == NUL) /* nothing found */
{
if (options & FNAME_MESS)
projects / vim / commitdiff