Problem: Too many #ifdefs.
Solution: Graduate FEAT_MBYTE, part 3.
for (;;) /* repeat until we got a character */
{
-# ifdef FEAT_MBYTE
len = Read(raw_in, (char *)buf, (long)maxlen / input_conv.vc_factor);
-# else
- len = Read(raw_in, (char *)buf, (long)maxlen);
-# endif
if (len > 0)
{
-#ifdef FEAT_MBYTE
/* Convert from 'termencoding' to 'encoding'. */
if (input_conv.vc_type != CONV_NONE)
len = convert_input(buf, len, maxlen);
-#endif
return len;
}
}
# else
if (title != NULL)
{
-# ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
/* Convert the title from 'encoding' to the active codepage. */
return;
}
}
-# endif
SetConsoleTitle((LPCSTR)title);
}
# endif
else
#endif
{
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *wname;
vim_free(cname);
}
if (nResult == FAIL) /* fall back to non-wide function */
-#endif
{
if (_fullpath((char *)buf, (const char *)fname, len - 1) == NULL)
{
int
mch_isFullName(char_u *fname)
{
-#ifdef FEAT_MBYTE
/* WinNT and later can use _MAX_PATH wide characters for a pathname, which
* means that the maximum pathname is _MAX_PATH * 3 bytes when 'enc' is
* UTF-8. */
char szName[_MAX_PATH * 3 + 1];
-#else
- char szName[_MAX_PATH + 1];
-#endif
/* A name like "d:/foo" and "//server/share" is absolute */
if ((fname[0] && fname[1] == ':' && (fname[2] == '/' || fname[2] == '\\'))
return stat(name, stp);
}
-#ifdef FEAT_MBYTE
static int
wstat_symlink_aware(const WCHAR *name, stat_T *stp)
{
-# if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__MINGW32__)
+#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__MINGW32__)
/* Work around for VC12 or earlier (and MinGW). _wstat() can't handle
* symlinks properly.
* VC9 or earlier: _wstat() doesn't support a symlink at all. It retrieves
return n;
}
}
-# endif
+#endif
return _wstat(name, (struct _stat *)stp);
}
-#endif
/*
* stat() can't handle a trailing '/' or '\', remove it first.
int
vim_stat(const char *name, stat_T *stp)
{
-#ifdef FEAT_MBYTE
/* WinNT and later can use _MAX_PATH wide characters for a pathname, which
* means that the maximum pathname is _MAX_PATH * 3 bytes when 'enc' is
* UTF-8. */
char_u buf[_MAX_PATH * 3 + 1];
-#else
- char_u buf[_MAX_PATH + 1];
-#endif
char_u *p;
vim_strncpy((char_u *)buf, (char_u *)name, sizeof(buf) - 1);
STRCAT(buf, "\\");
}
}
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *wp = enc_to_utf16(buf, NULL);
return n;
}
}
-#endif
return stat_symlink_aware((char *)buf, stp);
}
if (*path == NUL) /* drive name only */
return 0;
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *p = enc_to_utf16((char_u *)path, NULL);
return n;
}
}
-#endif
return chdir(path); /* let the normal chdir() do the rest */
}
#define IDC_PRINTTEXT2 402
#define IDC_PROGRESS 403
-#if !defined(FEAT_MBYTE)
-# define vimSetDlgItemText(h, i, s) SetDlgItemText(h, i, s)
-#else
static BOOL
vimSetDlgItemText(HWND hDlg, int nIDDlgItem, char_u *s)
{
}
return SetDlgItemText(hDlg, nIDDlgItem, (LPCSTR)s);
}
-#endif
/*
* Convert BGR to RGB for Windows GDI calls
char_u *printer_name = (char_u *)devname + devname->wDeviceOffset;
char_u *port_name = (char_u *)devname +devname->wOutputOffset;
char_u *text = (char_u *)_("to %s on %s");
-#ifdef FEAT_MBYTE
char_u *printer_name_orig = printer_name;
char_u *port_name_orig = port_name;
if (to_free != NULL)
port_name = to_free;
}
-#endif
prt_name = alloc((unsigned)(STRLEN(printer_name) + STRLEN(port_name)
+ STRLEN(text)));
if (prt_name != NULL)
wsprintf((char *)prt_name, (const char *)text,
printer_name, port_name);
-#ifdef FEAT_MBYTE
if (printer_name != printer_name_orig)
vim_free(printer_name);
if (port_name != port_name_orig)
vim_free(port_name);
-#endif
}
GlobalUnlock(prt_dlg.hDevNames);
{
int ret;
char szBuffer[300];
-#if defined(FEAT_MBYTE)
WCHAR *wp = NULL;
-#endif
hDlgPrint = CreateDialog(GetModuleHandle(NULL), TEXT("PrintDlgBox"),
prt_dlg.hwndOwner, PrintDlgProc);
wsprintf(szBuffer, _("Printing '%s'"), gettail(psettings->jobname));
vimSetDlgItemText(hDlgPrint, IDC_PRINTTEXT1, (char_u *)szBuffer);
-#if defined(FEAT_MBYTE)
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
wp = enc_to_utf16(psettings->jobname, NULL);
if (wp != NULL)
vim_free(wp);
}
else
-#endif
{
DOCINFO di;
int
mch_print_text_out(char_u *p, int len)
{
-#if defined(FEAT_PROPORTIONAL_FONTS) || defined(FEAT_MBYTE)
SIZE sz;
-#endif
-#if defined(FEAT_MBYTE)
WCHAR *wp = NULL;
int wlen = len;
}
return ret;
}
-#endif
TextOut(prt_dlg.hDC, prt_pos_x + prt_left_margin,
prt_pos_y + prt_top_margin,
(LPCSTR)p, len);
CHAR buf[MAX_PATH]; // could have simply reused 'wsz'...
char_u *rfname = NULL;
int len;
-# ifdef FEAT_MBYTE
IShellLinkW *pslw = NULL;
WIN32_FIND_DATAW ffdw; // we get those free of charge
-# endif
/* Check if the file name ends in ".lnk". Avoid calling
* CoCreateInstance(), it's quite slow. */
CoInitialize(NULL);
-# ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
// create a link manager object and request its interface
}
goto shortcut_end;
}
-# endif
// create a link manager object and request its interface
hr = CoCreateInstance(
&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
ppf->lpVtbl->Release(ppf);
if (psl != NULL)
psl->lpVtbl->Release(psl);
-# ifdef FEAT_MBYTE
if (pslw != NULL)
pslw->lpVtbl->Release(pslw);
-# endif
CoUninitialize();
return rfname;
COPYDATASTRUCT data;
data.dwData = COPYDATA_ENCODING;
-#ifdef FEAT_MBYTE
data.cbData = (DWORD)STRLEN(p_enc) + 1;
data.lpData = p_enc;
-#else
- data.cbData = (DWORD)STRLEN("latin1") + 1;
- data.lpData = "latin1";
-#endif
(void)SendMessage(target, WM_COPYDATA, (WPARAM)message_window,
(LPARAM)(&data));
}
switch (data->dwData)
{
case COPYDATA_ENCODING:
-# ifdef FEAT_MBYTE
/* Remember the encoding that the client uses. */
vim_free(client_enc);
client_enc = enc_canonize((char_u *)data->lpData);
-# endif
return 1;
case COPYDATA_KEYS:
int i;
int ret = FAIL;
static LOGFONT *lastlf = NULL;
-#ifdef FEAT_MBYTE
char_u *acpname = NULL;
-#endif
*lf = s_lfDefault;
if (name == NULL)
return OK;
-#ifdef FEAT_MBYTE
/* Convert 'name' from 'encoding' to the current codepage, because
* lf->lfFaceName uses the current codepage.
* TODO: Use Wide APIs instead of ANSI APIs. */
enc_to_acp(name, (int)STRLEN(name), &acpname, &len);
name = acpname;
}
-#endif
if (STRCMP(name, "*") == 0)
{
#if defined(FEAT_GUI_W32)
if (lastlf != NULL)
mch_memmove(lastlf, lf, sizeof(LOGFONT));
}
-#ifdef FEAT_MBYTE
vim_free(acpname);
-#endif
return ret;
}
retval = TRUE;
if (!test_only)
{
-#if defined(FEAT_XFONTSET) || defined(FEAT_MBYTE)
- if (text_prop.encoding == XA_STRING
-# ifdef FEAT_MBYTE
- && !has_mbyte
-# endif
- )
+ if (text_prop.encoding == XA_STRING && !has_mbyte)
{
-#endif
if (get_title)
oldtitle = vim_strsave((char_u *)text_prop.value);
else
oldicon = vim_strsave((char_u *)text_prop.value);
-#if defined(FEAT_XFONTSET) || defined(FEAT_MBYTE)
}
else
{
oldicon = vim_strsave((char_u *)text_prop.value);
}
}
-#endif
}
XFree((void *)text_prop.value);
}
* systems X_HAVE_UTF8_STRING may be defined in a header file but
* Xutf8SetWMProperties() is not in the X11 library. Configure checks for
* that and defines HAVE_XUTF8SETWMPROPERTIES. */
-#if defined(X_HAVE_UTF8_STRING) && defined(FEAT_MBYTE)
+#if defined(X_HAVE_UTF8_STRING)
# if X_HAVE_UTF8_STRING && HAVE_XUTF8SETWMPROPERTIES
# define USE_UTF8_STRING
# endif
{
# define BUFLEN 100 /* length for buffer, pseudo tty limit is 128 */
char_u buffer[BUFLEN + 1];
-# ifdef FEAT_MBYTE
int buffer_off = 0; /* valid bytes in buffer[] */
-# endif
char_u ta_buf[BUFLEN + 1]; /* TypeAHead */
int ta_len = 0; /* valid bytes in ta_buf[] */
int len;
}
else if (ta_buf[i] == '\r')
ta_buf[i] = '\n';
-# ifdef FEAT_MBYTE
if (has_mbyte)
i += (*mb_ptr2len_len)(ta_buf + i,
ta_len + len - i) - 1;
-# endif
}
/*
{
if (ta_buf[i] == '\n' || ta_buf[i] == '\b')
msg_putchar(ta_buf[i]);
-# ifdef FEAT_MBYTE
else if (has_mbyte)
{
int l = (*mb_ptr2len)(ta_buf + i);
msg_outtrans_len(ta_buf + i, l);
i += l - 1;
}
-# endif
else
msg_outtrans_len(ta_buf + i, 1);
}
while (RealWaitForChar(fromshell_fd, 10L, NULL, NULL))
{
len = read_eintr(fromshell_fd, buffer
-# ifdef FEAT_MBYTE
+ buffer_off, (size_t)(BUFLEN - buffer_off)
-# else
- , (size_t)BUFLEN
-# endif
);
if (len <= 0) /* end of file or error */
goto finished;
ga_append(&ga, buffer[i]);
}
}
-# ifdef FEAT_MBYTE
else if (has_mbyte)
{
int l;
}
buffer_off = 0;
}
-# endif /* FEAT_MBYTE */
else
{
buffer[len] = NUL;
free(argv);
if (tofree != NULL)
free(tofree);
-#ifdef FEAT_MBYTE
free_cmd_argsW();
-#endif
return 0;
}
{
if (*p == '^' && vim_strchr(escaped, p[1]) != NULL)
mch_memmove(p, p + 1, l--);
-#ifdef FEAT_MBYTE
n = (*mb_ptr2len)(p);
-#else
- n = 1;
-#endif
p += n;
l -= n;
}
{
int n = 1;
-#ifdef FEAT_MBYTE
if (ch2 == NUL)
{
int i;
}
}
else
-#endif
typeahead[typeaheadlen] = c;
if (ch2 != NUL)
{
if ((modifiers & MOD_MASK_ALT)
&& n == 1
&& (typeahead[typeaheadlen] & 0x80) == 0
-#ifdef FEAT_MBYTE
&& !enc_dbcs
-#endif
)
{
-#ifdef FEAT_MBYTE
n = (*mb_char2bytes)(typeahead[typeaheadlen] | 0x80,
typeahead + typeaheadlen);
-#else
- typeahead[typeaheadlen] |= 0x80;
-#endif
modifiers &= ~MOD_MASK_ALT;
}
return FALSE;
}
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *p = enc_to_utf16((char_u *)name, NULL);
return TRUE;
}
}
-#endif
curpath = getenv("PATH");
newpath = (char*)alloc((unsigned)(STRLEN(curpath) + 3));
}
-#ifdef FEAT_MBYTE
/*
* fname_casew(): Wide version of fname_case(). Set the case of the file name,
* if it already exists. When "len" is > 0, also expand short to long
wcscpy(name, szTrueName);
return OK;
}
-#endif
/*
* fname_case(): Set the case of the file name, if it already exists.
slash_adjust(name);
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *p = enc_to_utf16(name, NULL);
}
return;
}
-#endif
/* If 'enc' is utf-8, flen can be larger than _MAX_PATH.
* So we should check this after calling wide function. */
porigPrev = porig;
while (*porig != NUL && *porig != psepc)
{
-#ifdef FEAT_MBYTE
int l;
if (enc_dbcs)
*ptrue++ = *porig++;
}
else
-#endif
*ptrue++ = *porig++;
}
*ptrue = NUL;
char szUserName[256 + 1]; /* UNLEN is 256 */
DWORD cch = sizeof szUserName;
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR wszUserName[256 + 1]; /* UNLEN is 256 */
}
}
}
-#endif
if (GetUserName(szUserName, &cch))
{
vim_strncpy(s, (char_u *)szUserName, len - 1);
{
DWORD cch = len;
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR wszHostName[256 + 1];
}
}
}
-#endif
if (!GetComputerName((LPSTR)s, &cch))
vim_strncpy(s, (char_u *)"PC (Win32 Vim)", len - 1);
}
* But the Win32s known bug list says that getcwd() doesn't work
* so use the Win32 system call instead. <Negri>
*/
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR wbuf[_MAX_PATH + 1];
}
return FAIL;
}
-#endif
if (GetCurrentDirectory(len, (LPSTR)buf) == 0)
return FAIL;
lfnlen = GetLongPathNameA((LPCSTR)buf, (LPSTR)abuf, _MAX_PATH);
{
long n = -1;
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *p = enc_to_utf16(name, NULL);
}
}
if (n == -1)
-#endif
n = _chmod((const char *)name, perm);
if (n == -1)
return FAIL;
int
mch_mkdir(char_u *name)
{
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *p;
vim_free(p);
return retval;
}
-#endif
return _mkdir((const char *)name);
}
int
mch_rmdir(char_u *name)
{
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *p;
vim_free(p);
return retval;
}
-#endif
return _rmdir((const char *)name);
}
int res = FALSE;
WIN32_FIND_DATAA findDataA;
DWORD fileFlags = 0, reparseTag = 0;
-#ifdef FEAT_MBYTE
WCHAR *wn = NULL;
WIN32_FIND_DATAW findDataW;
}
}
else
-#endif
{
hFind = FindFirstFile((LPCSTR)name, &findDataA);
if (hFind != INVALID_HANDLE_VALUE)
{
HANDLE hFile;
int res = FILEINFO_READ_FAIL;
-#ifdef FEAT_MBYTE
WCHAR *wn = NULL;
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
vim_free(wn);
}
else
-#endif
hFile = CreateFile((LPCSTR)fname, /* file name */
GENERIC_READ, /* access mode */
FILE_SHARE_READ | FILE_SHARE_WRITE, /* share mode */
win32_getattrs(char_u *name)
{
int attr;
-#ifdef FEAT_MBYTE
WCHAR *p = NULL;
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
vim_free(p);
}
else
-#endif
attr = GetFileAttributes((char *)name);
return attr;
win32_setattrs(char_u *name, int attrs)
{
int res;
-#ifdef FEAT_MBYTE
WCHAR *p = NULL;
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
vim_free(p);
}
else
-#endif
res = SetFileAttributes((char *)name, attrs);
return res ? 0 : -1;
{
HANDLE hFile;
int type;
-#ifdef FEAT_MBYTE
WCHAR *wn = NULL;
-#endif
/* We can't open a file with a name "\\.\con" or "\\.\prn" and trying to
* read from it later will cause Vim to hang. Thus return NODE_WRITABLE
if (STRNCMP(name, "\\\\.\\", 4) == 0)
return NODE_WRITABLE;
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
wn = enc_to_utf16(name, NULL);
vim_free(wn);
}
else
-#endif
hFile = CreateFile((LPCSTR)name, /* file name */
GENERIC_WRITE, /* access mode */
0, /* share mode */
p = (struct my_acl *)alloc_clear((unsigned)sizeof(struct my_acl));
if (p != NULL)
{
-# ifdef FEAT_MBYTE
WCHAR *wn = NULL;
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
vim_free(wn);
}
else
-# endif
{
/* Try to retrieve the entire security descriptor. */
err = GetNamedSecurityInfo(
if (p != NULL)
{
-# ifdef FEAT_MBYTE
WCHAR *wn = NULL;
-# endif
/* Set security flags */
if (p->pSidOwner)
if (p->pSacl)
sec_info |= SACL_SECURITY_INFORMATION;
-# ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
wn = enc_to_utf16(fname, NULL);
if (wn != NULL)
vim_free(wn);
}
else
-# endif
{
(void)SetNamedSecurityInfo(
(LPSTR)fname, // Abstract filename
LPVOID *env,
char *cwd)
{
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
BOOL ret;
return ret;
}
fallback:
-#endif
return CreateProcess(
NULL, /* Executable name */
cmd, /* Command to execute */
char *cmd,
INT n_show_cmd)
{
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *wcmd = enc_to_utf16((char_u *)cmd, NULL);
return ret;
}
}
-#endif
return ShellExecute(NULL, NULL, cmd, NULL, NULL, n_show_cmd);
}
while (ret != 0 && availableBytes > 0)
{
repeatCount++;
- toRead =
-# ifdef FEAT_MBYTE
- (DWORD)(BUFLEN - *buffer_off);
-# else
- (DWORD)BUFLEN;
-# endif
+ toRead = (DWORD)(BUFLEN - *buffer_off);
toRead = availableBytes < toRead ? availableBytes : toRead;
- ReadFile(g_hChildStd_OUT_Rd, buffer
-# ifdef FEAT_MBYTE
- + *buffer_off, toRead
-# else
- , toRead
-# endif
- , &len, NULL);
+ ReadFile(g_hChildStd_OUT_Rd, buffer + *buffer_off, toRead , &len, NULL);
/* If we haven't read anything, there is a problem */
if (len == 0)
ga_append(ga, buffer[i]);
}
}
-# ifdef FEAT_MBYTE
else if (has_mbyte)
{
int l;
}
*buffer_off = 0;
}
-# endif /* FEAT_MBYTE */
else
{
buffer[len] = NUL;
}
else if (ta_buf[i] == '\r')
ta_buf[i] = '\n';
-# ifdef FEAT_MBYTE
if (has_mbyte)
i += (*mb_ptr2len_len)(ta_buf + i,
ta_len + len - i) - 1;
-# endif
}
/*
{
if (ta_buf[i] == '\n' || ta_buf[i] == '\b')
msg_putchar(ta_buf[i]);
-# ifdef FEAT_MBYTE
else if (has_mbyte)
{
int l = (*mb_ptr2len)(ta_buf + i);
msg_outtrans_len(ta_buf + i, l);
i += l - 1;
}
-# endif
else
msg_outtrans_len(ta_buf + i, 1);
}
}
#else
-# ifdef FEAT_MBYTE
static int
mch_system(char *cmd, int options)
{
}
return system(cmd);
}
-# else
-# define mch_system(c, o) system(c)
-# endif
#endif
int tmode = cur_tmode;
#ifdef FEAT_TITLE
char szShellTitle[512];
-# ifdef FEAT_MBYTE
int did_set_title = FALSE;
/* Change the title to reflect that we are in a subshell. */
}
}
if (!did_set_title)
-# endif
/* Change the title to reflect that we are in a subshell. */
if (GetConsoleTitle(szShellTitle, sizeof(szShellTitle) - 4) > 0)
{
"External commands will not pause after completion.\n"
"See :help win32-vimrun for more information.");
char *title = _("Vim Warning");
-# ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *wmsg = enc_to_utf16((char_u *)msg, NULL);
vim_free(wtitle);
}
else
-# endif
MessageBox(NULL, msg, title, MB_ICONWARNING);
need_vimrun_warning = FALSE;
}
DWORD dwFlagsAndAttributes)
{
HANDLE h;
-# ifdef FEAT_MBYTE
WCHAR *wn = NULL;
+
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
wn = enc_to_utf16(fname, NULL);
}
}
if (wn == NULL)
-# endif
h = CreateFile((LPCSTR)fname, dwDesiredAccess, dwShareMode,
lpSecurityAttributes, dwCreationDisposition,
dwFlagsAndAttributes, NULL);
COORD coord = g_coord;
DWORD written;
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
static WCHAR *unicodebuf = NULL;
}
}
else
-#endif
{
if (!USE_VTP)
{
int
mch_remove(char_u *name)
{
-#ifdef FEAT_MBYTE
WCHAR *wn = NULL;
int n;
-#endif
/*
* On Windows, deleting a directory's symbolic link is done by
win32_setattrs(name, FILE_ATTRIBUTE_NORMAL);
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
wn = enc_to_utf16(name, NULL);
return n;
}
}
-#endif
return DeleteFile((LPCSTR)name) ? 0 : -1;
}
return (long_u)((ms.ullTotalPhys - WINNT_RESERVE_BYTES) / 1024);
}
-#ifdef FEAT_MBYTE
/*
* Same code as below, but with wide functions and no comments.
* Return 0 for success, non-zero for failure.
return 0;
}
-#endif
/*
char szNewPath[_MAX_PATH+1];
char *pszFilePart;
HANDLE hf;
-#ifdef FEAT_MBYTE
WCHAR *wold = NULL;
WCHAR *wnew = NULL;
int retval = -1;
vim_free(wnew);
return retval;
}
-#endif
/*
* No need to play tricks unless the file name contains a "~" as the
{
HANDLE hFile;
int retval = -1; /* default: fail */
-#ifdef FEAT_MBYTE
WCHAR *wn = NULL;
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
wn = enc_to_utf16((char_u *)n, NULL);
-#endif
if (mch_isdir((char_u *)n))
{
char TempName[_MAX_PATH + 16] = "";
-#ifdef FEAT_MBYTE
WCHAR TempNameW[_MAX_PATH + 16] = L"";
-#endif
if (p & R_OK)
{
/* Read check is performed by seeing if we can do a find file on
* the directory for any file. */
-#ifdef FEAT_MBYTE
if (wn != NULL)
{
int i;
(void)FindClose(hFile);
}
else
-#endif
{
char *pch;
WIN32_FIND_DATA d;
* directories on read-only network shares. However, in
* directories whose ACL allows writes but denies deletes will end
* up keeping the temporary file :-(. */
-#ifdef FEAT_MBYTE
if (wn != NULL)
{
if (!GetTempFileNameW(wn, L"VIM", 0, TempNameW))
DeleteFileW(TempNameW);
}
else
-#endif
{
if (!GetTempFileName(n, "VIM", 0, TempName))
goto getout;
DWORD access_mode = ((p & W_OK) ? GENERIC_WRITE : 0)
| ((p & R_OK) ? GENERIC_READ : 0);
-#ifdef FEAT_MBYTE
if (wn != NULL)
hFile = CreateFileW(wn, access_mode, share_mode,
NULL, OPEN_EXISTING, 0, NULL);
else
-#endif
hFile = CreateFile(n, access_mode, share_mode,
NULL, OPEN_EXISTING, 0, NULL);
if (hFile == INVALID_HANDLE_VALUE)
retval = 0; /* success */
getout:
-#ifdef FEAT_MBYTE
vim_free(wn);
-#endif
return retval;
}
-#if defined(FEAT_MBYTE) || defined(PROTO)
/*
* Version of open() that may use UTF-16 file name.
*/
mch_open(const char *name, int flags, int mode)
{
/* _wopen() does not work with Borland C 5.5: creates a read-only file. */
-# ifndef __BORLANDC__
+#ifndef __BORLANDC__
WCHAR *wn;
int f;
return f;
}
}
-# endif
+#endif
/* open() can open a file which name is longer than _MAX_PATH bytes
* and shorter than _MAX_PATH characters successfully, but sometimes it
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
-# if defined(DEBUG) && _MSC_VER >= 1400
+#if defined(DEBUG) && _MSC_VER >= 1400
/* Work around an annoying assertion in the Microsoft debug CRT
* when mode's text/binary setting doesn't match _get_fmode(). */
char newMode = mode[strlen(mode) - 1];
_set_fmode(_O_TEXT);
else if (newMode == 'b')
_set_fmode(_O_BINARY);
-# endif
+#endif
wn = enc_to_utf16((char_u *)name, NULL);
wm = enc_to_utf16((char_u *)mode, NULL);
if (wn != NULL && wm != NULL)
vim_free(wn);
vim_free(wm);
-# if defined(DEBUG) && _MSC_VER >= 1400
+#if defined(DEBUG) && _MSC_VER >= 1400
_set_fmode(oldMode);
-# endif
+#endif
return f;
}
return fopen(name, mode);
}
-#endif
-#ifdef FEAT_MBYTE
/*
* SUB STREAM (aka info stream) handling:
*
vim_free(fromw);
vim_free(tow);
}
-#endif
/*
* Copy file attributes from file "from" to file "to".
int
mch_copy_file_attribute(char_u *from, char_u *to)
{
-#ifdef FEAT_MBYTE
/* File streams only work on Windows NT and later. */
PlatformId();
copy_infostreams(from, to);
-#endif
return 0;
}
#endif
-#if defined(FEAT_MBYTE) || defined(PROTO)
/*
* The command line arguments in UCS2
*/
set_alist_count();
}
-#endif
int
mch_setenv(char *var, char *value, int x)
sprintf((char *)envbuf, "%s=%s", var, value);
-#ifdef FEAT_MBYTE
if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
{
WCHAR *p = enc_to_utf16(envbuf, NULL);
if (p == NULL)
return -1;
_wputenv(p);
-# ifdef libintl_wputenv
+#ifdef libintl_wputenv
libintl_wputenv(p);
-# endif
+#endif
/* Unlike Un*x systems, we can free the string for _wputenv(). */
vim_free(p);
}
else
-#endif
{
_putenv((char *)envbuf);
#ifdef libintl_putenv
else
state->linebuf = IObuff;
-#ifdef FEAT_MBYTE
// Convert a line if it contains a non-ASCII character.
if (state->vc.vc_type != CONV_NONE && has_non_ascii(state->linebuf))
{
}
}
}
-#endif
return QF_OK;
}
#endif
}
-#ifdef FEAT_MBYTE
remove_bom(state->linebuf);
-#endif
return QF_OK;
}
linenr_T lnumfirst,
linenr_T lnumlast)
{
-#ifdef FEAT_MBYTE
pstate->vc.vc_type = CONV_NONE;
if (enc != NULL && *enc != NUL)
convert_setup(&pstate->vc, enc, p_enc);
-#endif
if (efile != NULL && (pstate->fd = mch_fopen((char *)efile, "r")) == NULL)
{
fclose(pstate->fd);
vim_free(pstate->growbuf);
-#ifdef FEAT_MBYTE
if (pstate->vc.vc_type != CONV_NONE)
convert_setup(&pstate->vc, NULL, NULL);
-#endif
}
/*
return;
#endif
}
-#ifdef FEAT_MBYTE
enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : p_menc;
-#endif
if (is_loclist_cmd(eap->cmdidx))
wp = curwin;
}
if (au_name != NULL)
apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name, NULL, FALSE, curbuf);
-#ifdef FEAT_MBYTE
enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : p_menc;
-#endif
#ifdef FEAT_BROWSE
if (cmdmod.browse)
{
hgr_search_file(
qf_info_T *qi,
char_u *fname,
-#ifdef FEAT_MBYTE
vimconv_T *p_vc,
-#endif
regmatch_T *p_regmatch)
{
FILE *fd;
while (!vim_fgets(IObuff, IOSIZE, fd) && !got_int)
{
char_u *line = IObuff;
-#ifdef FEAT_MBYTE
+
// Convert a line if 'encoding' is not utf-8 and
// the line contains a non-ASCII character.
if (p_vc->vc_type != CONV_NONE
if (line == NULL)
line = IObuff;
}
-#endif
if (vim_regexec(p_regmatch, line, (colnr_T)0))
{
) == FAIL)
{
got_int = TRUE;
-#ifdef FEAT_MBYTE
if (line != IObuff)
vim_free(line);
-#endif
break;
}
}
-#ifdef FEAT_MBYTE
if (line != IObuff)
vim_free(line);
-#endif
++lnum;
line_breakcheck();
}
hgr_search_files_in_dir(
qf_info_T *qi,
char_u *dirname,
- regmatch_T *p_regmatch
-#ifdef FEAT_MBYTE
- , vimconv_T *p_vc
-#endif
+ regmatch_T *p_regmatch,
+ vimconv_T *p_vc
#ifdef FEAT_MULTI_LANG
, char_u *lang
#endif
continue;
#endif
- hgr_search_file(qi, fnames[fi],
-#ifdef FEAT_MBYTE
- p_vc,
-#endif
- p_regmatch);
+ hgr_search_file(qi, fnames[fi], p_vc, p_regmatch);
}
FreeWild(fcount, fnames);
}
{
char_u *p;
-#ifdef FEAT_MBYTE
vimconv_T vc;
// Help files are in utf-8 or latin1, convert lines when 'encoding'
vc.vc_type = CONV_NONE;
if (!enc_utf8)
convert_setup(&vc, (char_u *)"utf-8", p_enc);
-#endif
// Go through all the directories in 'runtimepath'
p = p_rtp;
{
copy_option_part(&p, NameBuff, MAXPATHL, ",");
- hgr_search_files_in_dir(qi, NameBuff, p_regmatch
-#ifdef FEAT_MBYTE
- , &vc
-#endif
+ hgr_search_files_in_dir(qi, NameBuff, p_regmatch, &vc
#ifdef FEAT_MULTI_LANG
, lang
#endif
);
}
-#ifdef FEAT_MBYTE
if (vc.vc_type != CONV_NONE)
convert_setup(&vc, NULL, NULL);
-#endif
}
/*
static char_u e_missingbracket[] = N_("E769: Missing ] after %s[");
static char_u e_reverse_range[] = N_("E944: Reverse range in character class");
-#ifdef FEAT_MBYTE
static char_u e_large_class[] = N_("E945: Range too large in character class");
-#endif
static char_u e_unmatchedpp[] = N_("E53: Unmatched %s%%(");
static char_u e_unmatchedp[] = N_("E54: Unmatched %s(");
static char_u e_unmatchedpar[] = N_("E55: Unmatched %s)");
done = TRUE;
}
-#ifdef FEAT_MBYTE
-# define ri_digit(c) (c < 0x100 && (class_tab[c] & RI_DIGIT))
-# define ri_hex(c) (c < 0x100 && (class_tab[c] & RI_HEX))
-# define ri_octal(c) (c < 0x100 && (class_tab[c] & RI_OCTAL))
-# define ri_word(c) (c < 0x100 && (class_tab[c] & RI_WORD))
-# define ri_head(c) (c < 0x100 && (class_tab[c] & RI_HEAD))
-# define ri_alpha(c) (c < 0x100 && (class_tab[c] & RI_ALPHA))
-# define ri_lower(c) (c < 0x100 && (class_tab[c] & RI_LOWER))
-# define ri_upper(c) (c < 0x100 && (class_tab[c] & RI_UPPER))
-# define ri_white(c) (c < 0x100 && (class_tab[c] & RI_WHITE))
-#else
-# define ri_digit(c) (class_tab[c] & RI_DIGIT)
-# define ri_hex(c) (class_tab[c] & RI_HEX)
-# define ri_octal(c) (class_tab[c] & RI_OCTAL)
-# define ri_word(c) (class_tab[c] & RI_WORD)
-# define ri_head(c) (class_tab[c] & RI_HEAD)
-# define ri_alpha(c) (class_tab[c] & RI_ALPHA)
-# define ri_lower(c) (class_tab[c] & RI_LOWER)
-# define ri_upper(c) (class_tab[c] & RI_UPPER)
-# define ri_white(c) (class_tab[c] & RI_WHITE)
-#endif
+#define ri_digit(c) (c < 0x100 && (class_tab[c] & RI_DIGIT))
+#define ri_hex(c) (c < 0x100 && (class_tab[c] & RI_HEX))
+#define ri_octal(c) (c < 0x100 && (class_tab[c] & RI_OCTAL))
+#define ri_word(c) (c < 0x100 && (class_tab[c] & RI_WORD))
+#define ri_head(c) (c < 0x100 && (class_tab[c] & RI_HEAD))
+#define ri_alpha(c) (c < 0x100 && (class_tab[c] & RI_ALPHA))
+#define ri_lower(c) (c < 0x100 && (class_tab[c] & RI_LOWER))
+#define ri_upper(c) (c < 0x100 && (class_tab[c] & RI_UPPER))
+#define ri_white(c) (c < 0x100 && (class_tab[c] & RI_WHITE))
/* flags for regflags */
#define RF_ICASE 1 /* ignore case */
static char_u *regpiece(int *);
static char_u *regatom(int *);
static char_u *regnode(int);
-#ifdef FEAT_MBYTE
static int use_multibytecode(int c);
-#endif
static int prog_magic_wrong(void);
static char_u *regnext(char_u *);
static void regc(int b);
-#ifdef FEAT_MBYTE
static void regmbc(int c);
-# define REGMBC(x) regmbc(x);
-# define CASEMBC(x) case x:
-#else
-# define regmbc(c) regc(c)
-# define REGMBC(x)
-# define CASEMBC(x)
-#endif
+#define REGMBC(x) regmbc(x);
+#define CASEMBC(x) case x:
static void reginsert(int, char_u *);
static void reginsert_nr(int op, long val, char_u *opnd);
static void reginsert_limits(int, long, long, char_u *);
if (p[1] == '=')
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
l = (*mb_ptr2len)(p + 2);
-#endif
if (p[l + 2] == '=' && p[l + 3] == ']')
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
c = mb_ptr2char(p + 2);
else
-#endif
c = p[2];
*pp += l + 4;
return c;
static void
reg_equi_class(int c)
{
-#ifdef FEAT_MBYTE
if (enc_utf8 || STRCMP(p_enc, "latin1") == 0
|| STRCMP(p_enc, "iso-8859-15") == 0)
-#endif
{
#ifdef EBCDIC
int i;
if (p[0] != NUL && p[1] == '.')
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
l = (*mb_ptr2len)(p + 2);
-#endif
if (p[l + 2] == '.' && p[l + 3] == ']')
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
c = mb_ptr2char(p + 2);
else
-#endif
c = p[2];
*pp += l + 4;
return c;
static char_u *
skip_anyof(char_u *p)
{
-#ifdef FEAT_MBYTE
int l;
-#endif
if (*p == '^') /* Complement of range. */
++p;
++p;
while (*p != NUL && *p != ']')
{
-#ifdef FEAT_MBYTE
if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
p += l;
else
-#endif
if (*p == '-')
{
++p;
if (OP(scan) == EXACTLY)
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
r->regstart = (*mb_ptr2char)(OPERAND(scan));
else
-#endif
r->regstart = *OPERAND(scan);
}
else if ((OP(scan) == BOW
|| OP(scan) == MCLOSE + 0 || OP(scan) == NCLOSE)
&& OP(regnext(scan)) == EXACTLY)
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
r->regstart = (*mb_ptr2char)(OPERAND(regnext(scan)));
else
-#endif
r->regstart = *OPERAND(regnext(scan));
}
cont = FALSE;
break;
case Magic('Z'):
-#ifdef FEAT_MBYTE
regflags |= RF_ICOMBINE;
-#endif
skipchr_keepstart();
break;
case Magic('c'):
p = vim_strchr(classchars, no_Magic(c));
if (p == NULL)
EMSG_RET_NULL(_("E63: invalid use of \\_"));
-#ifdef FEAT_MBYTE
+
/* When '.' is followed by a composing char ignore the dot, so that
* the composing char is matched here. */
if (enc_utf8 && c == Magic('.') && utf_iscomposing(peekchr()))
c = getchr();
goto do_multibyte;
}
-#endif
ret = regnode(classcodes[p - classchars] + extra);
*flagp |= HASWIDTH | SIMPLE;
break;
EMSG2_RET_NULL(
_("E678: Invalid character after %s%%[dxouU]"),
reg_magic == MAGIC_ALL);
-#ifdef FEAT_MBYTE
if (use_multibytecode(i))
ret = regnode(MULTIBYTECODE);
else
-#endif
ret = regnode(EXACTLY);
if (i == 0)
regc(0x0a);
else
-#ifdef FEAT_MBYTE
regmbc(i);
-#else
- regc(i);
-#endif
regc(NUL);
*flagp |= HASWIDTH;
break;
endc = get_coll_element(®parse);
if (endc == 0)
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
endc = mb_ptr2char_adv(®parse);
else
-#endif
endc = *regparse++;
}
if (startc > endc)
EMSG_RET_NULL(_(e_reverse_range));
-#ifdef FEAT_MBYTE
if (has_mbyte && ((*mb_char2len)(startc) > 1
|| (*mb_char2len)(endc) > 1))
{
regmbc(startc);
}
else
-#endif
{
#ifdef EBCDIC
int alpha_only = FALSE;
if (startc == 0)
regc(0x0a);
else
-#ifdef FEAT_MBYTE
regmbc(startc);
-#else
- regc(startc);
-#endif
}
else
{
}
else
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
int len;
regc(*regparse++);
}
else
-#endif
{
startc = *regparse++;
regc(startc);
{
int len;
-#ifdef FEAT_MBYTE
/* A multi-byte character is handled as a separate atom if it's
* before a multi and when it's a composing char. */
if (use_multibytecode(c))
*flagp |= HASWIDTH | SIMPLE;
break;
}
-#endif
ret = regnode(EXACTLY);
&& !is_Magic(c))); ++len)
{
c = no_Magic(c);
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
regmbc(c);
}
}
else
-#endif
regc(c);
c = getchr();
}
return ret;
}
-#ifdef FEAT_MBYTE
/*
* Return TRUE if MULTIBYTECODE should be used instead of EXACTLY for
* character "c".
&& (re_multi_type(peekchr()) != NOT_MULTI
|| (enc_utf8 && utf_iscomposing(c)));
}
-#endif
/*
* Emit a node.
*regcode++ = b;
}
-#ifdef FEAT_MBYTE
/*
* Emit (if appropriate) a multi-byte character of code
*/
else
regcode += (*mb_char2bytes)(c, regcode);
}
-#endif
/*
* Insert an operator in front of already-emitted operand
* Next character can never be (made) magic?
* Then backslashing it won't do anything.
*/
-#ifdef FEAT_MBYTE
if (has_mbyte)
curchr = (*mb_ptr2char)(regparse + 1);
else
-#endif
curchr = c;
}
break;
}
-#ifdef FEAT_MBYTE
default:
if (has_mbyte)
curchr = (*mb_ptr2char)(regparse);
-#endif
}
}
prevchr_len = 0;
if (regparse[prevchr_len] != NUL)
{
-#ifdef FEAT_MBYTE
if (enc_utf8)
/* exclude composing chars that mb_ptr2len does include */
prevchr_len += utf_ptr2len(regparse + prevchr_len);
else if (has_mbyte)
prevchr_len += (*mb_ptr2len)(regparse + prevchr_len);
else
-#endif
++prevchr_len;
}
regparse += prevchr_len;
* contains '\c' or '\C' the value is overruled. */
int reg_ic;
-#ifdef FEAT_MBYTE
/* Similar to "reg_ic", but only for 'combining' characters. Set with \Z
* flag in the regexp. Defaults to false, always. */
int reg_icombine;
-#endif
/* Copy of "rmm_maxcol": maximum column to search for a match. Zero when
* there is no maximum. */
rex.reg_buf = curbuf;
rex.reg_win = NULL;
rex.reg_ic = rmp->rm_ic;
-#ifdef FEAT_MBYTE
rex.reg_icombine = FALSE;
-#endif
rex.reg_maxcol = 0;
return bt_regexec_both(line, col, NULL, NULL);
rex.reg_maxline = rex.reg_buf->b_ml.ml_line_count - lnum;
rex.reg_line_lbr = FALSE;
rex.reg_ic = rmp->rmm_ic;
-#ifdef FEAT_MBYTE
rex.reg_icombine = FALSE;
-#endif
rex.reg_maxcol = rmp->rmm_maxcol;
return bt_regexec_both(NULL, col, tm, timed_out);
else if (prog->regflags & RF_NOICASE)
rex.reg_ic = FALSE;
-#ifdef FEAT_MBYTE
/* If pattern contains "\Z" overrule value of rex.reg_icombine */
if (prog->regflags & RF_ICOMBINE)
rex.reg_icombine = TRUE;
-#endif
/* If there is a "must appear" string, look for it. */
if (prog->regmust != NULL)
{
int c;
-#ifdef FEAT_MBYTE
if (has_mbyte)
c = (*mb_ptr2char)(prog->regmust);
else
-#endif
c = *prog->regmust;
s = line + col;
* This is used very often, esp. for ":global". Use three versions of
* the loop to avoid overhead of conditions.
*/
- if (!rex.reg_ic
-#ifdef FEAT_MBYTE
- && !has_mbyte
-#endif
- )
+ if (!rex.reg_ic && !has_mbyte)
while ((s = vim_strbyte(s, c)) != NULL)
{
if (cstrncmp(s, prog->regmust, &prog->regmlen) == 0)
break; /* Found it. */
++s;
}
-#ifdef FEAT_MBYTE
else if (!rex.reg_ic || (!enc_utf8 && mb_char2len(c) > 1))
while ((s = vim_strchr(s, c)) != NULL)
{
break; /* Found it. */
MB_PTR_ADV(s);
}
-#endif
else
while ((s = cstrchr(s, c)) != NULL)
{
{
int c;
-#ifdef FEAT_MBYTE
if (has_mbyte)
c = (*mb_ptr2char)(rex.line + col);
else
-#endif
c = rex.line[col];
if (prog->regstart == NUL
|| prog->regstart == c
- || (rex.reg_ic && ((
-#ifdef FEAT_MBYTE
- (enc_utf8 && utf_fold(prog->regstart) == utf_fold(c)))
+ || (rex.reg_ic
+ && (((enc_utf8 && utf_fold(prog->regstart) == utf_fold(c)))
|| (c < 255 && prog->regstart < 255 &&
-#endif
MB_TOLOWER(prog->regstart) == MB_TOLOWER(c)))))
retval = regtry(prog, col, tm, timed_out);
else
{
/* Skip until the char we know it must start with.
* Used often, do some work to avoid call overhead. */
- if (!rex.reg_ic
-#ifdef FEAT_MBYTE
- && !has_mbyte
-#endif
- )
+ if (!rex.reg_ic && !has_mbyte)
s = vim_strbyte(rex.line + col, prog->regstart);
else
s = cstrchr(rex.line + col, prog->regstart);
}
if (rex.line[col] == NUL)
break;
-#ifdef FEAT_MBYTE
if (has_mbyte)
col += (*mb_ptr2len)(rex.line + col);
else
-#endif
++col;
#ifdef FEAT_RELTIME
/* Check for timeout once in a twenty times to avoid overhead. */
return 1 + rex.lnum;
}
-#ifdef FEAT_MBYTE
/*
* Get class of previous character.
*/
{
if (rex.input > rex.line)
return mb_get_class_buf(rex.input - 1
- - (*mb_head_off)(rex.line, rex.input - 1), rex.reg_buf);
+ - (*mb_head_off)(rex.line, rex.input - 1), rex.reg_buf);
return -1;
}
-#endif
/*
* Return TRUE if the current rex.input position matches the Visual area.
{
if (WITH_NL(op))
op -= ADD_NL;
-#ifdef FEAT_MBYTE
if (has_mbyte)
c = (*mb_ptr2char)(rex.input);
else
-#endif
c = *rex.input;
switch (op)
{
case BOW: /* \<word; rex.input points to w */
if (c == NUL) /* Can't match at end of line */
status = RA_NOMATCH;
-#ifdef FEAT_MBYTE
else if (has_mbyte)
{
int this_class;
else if (reg_prev_class() == this_class)
status = RA_NOMATCH; /* previous char is in same word */
}
-#endif
else
{
if (!vim_iswordc_buf(c, rex.reg_buf) || (rex.input > rex.line
case EOW: /* word\>; rex.input points after d */
if (rex.input == rex.line) /* Can't match at start of line */
status = RA_NOMATCH;
-#ifdef FEAT_MBYTE
else if (has_mbyte)
{
int this_class, prev_class;
|| prev_class == 0 || prev_class == 1)
status = RA_NOMATCH;
}
-#endif
else
{
if (!vim_iswordc_buf(rex.input[-1], rex.reg_buf)
opnd = OPERAND(scan);
/* Inline the first byte, for speed. */
if (*opnd != *rex.input
- && (!rex.reg_ic || (
-#ifdef FEAT_MBYTE
- !enc_utf8 &&
-#endif
- MB_TOLOWER(*opnd) != MB_TOLOWER(*rex.input))))
+ && (!rex.reg_ic
+ || (!enc_utf8
+ && MB_TOLOWER(*opnd) != MB_TOLOWER(*rex.input))))
status = RA_NOMATCH;
else if (*opnd == NUL)
{
}
else
{
- if (opnd[1] == NUL
-#ifdef FEAT_MBYTE
- && !(enc_utf8 && rex.reg_ic)
-#endif
- )
+ if (opnd[1] == NUL && !(enc_utf8 && rex.reg_ic))
{
len = 1; /* matched a single byte above */
}
if (cstrncmp(opnd, rex.input, &len) != 0)
status = RA_NOMATCH;
}
-#ifdef FEAT_MBYTE
/* Check for following composing character, unless %C
* follows (skips over all composing chars). */
if (status != RA_NOMATCH
* for voweled Hebrew texts. */
status = RA_NOMATCH;
}
-#endif
if (status != RA_NOMATCH)
rex.input += len;
}
ADVANCE_REGINPUT();
break;
-#ifdef FEAT_MBYTE
case MULTIBYTECODE:
if (has_mbyte)
{
else
status = RA_NOMATCH;
break;
-#endif
case RE_COMPOSING:
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
/* Skip composing characters. */
while (utf_iscomposing(utf_ptr2char(rex.input)))
MB_CPTR_ADV(rex.input);
}
-#endif
break;
case NOTHING:
}
else
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
char_u *line =
+ rp->rs_un.regsave.rs_u.pos.col - 1) + 1;
}
else
-#endif
--rp->rs_un.regsave.rs_u.pos.col;
}
}
do_class:
while (count < maxcount)
{
-#ifdef FEAT_MBYTE
int l;
-#endif
+
if (*scan == NUL)
{
if (!REG_MULTI || !WITH_NL(OP(p)) || rex.lnum > rex.reg_maxline
if (got_int)
break;
}
-#ifdef FEAT_MBYTE
else if (has_mbyte && (l = (*mb_ptr2len)(scan)) > 1)
{
if (testval != 0)
break;
scan += l;
}
-#endif
else if ((class_tab[*scan] & mask) == testval)
++scan;
else if (rex.reg_line_lbr && *scan == '\n' && WITH_NL(OP(p)))
break;
}
-#ifdef FEAT_MBYTE
case MULTIBYTECODE:
{
int i, len, cf = 0;
}
}
break;
-#endif
case ANYOF:
case ANYOF + ADD_NL:
case ANYBUT + ADD_NL:
while (count < maxcount)
{
-#ifdef FEAT_MBYTE
int len;
-#endif
+
if (*scan == NUL)
{
if (!REG_MULTI || !WITH_NL(OP(p)) || rex.lnum > rex.reg_maxline
}
else if (rex.reg_line_lbr && *scan == '\n' && WITH_NL(OP(p)))
++scan;
-#ifdef FEAT_MBYTE
else if (has_mbyte && (len = (*mb_ptr2len)(scan)) > 1)
{
if ((cstrchr(opnd, (*mb_ptr2char)(scan)) == NULL) == testval)
break;
scan += len;
}
-#endif
else
{
if ((cstrchr(opnd, *scan) == NULL) == testval)
sprintf(buf + STRLEN(buf), "BRACE_COMPLEX%d", OP(op) - BRACE_COMPLEX);
p = NULL;
break;
-#ifdef FEAT_MBYTE
case MULTIBYTECODE:
p = "MULTIBYTECODE";
break;
-#endif
case NEWL:
p = "NEWL";
break;
return OK;
}
-#ifdef FEAT_MBYTE
typedef struct
{
int a, b, c;
*c2 = *c3 = 0;
}
}
-#endif
/*
* Compare two strings, ignore case if rex.reg_ic set.
else
result = MB_STRNICMP(s1, s2, *n);
-#ifdef FEAT_MBYTE
/* if it failed and it's utf8 and we want to combineignore: */
if (result != 0 && enc_utf8 && rex.reg_icombine)
{
if (result == 0)
*n = (int)(str2 - s2);
}
-#endif
return result;
}
char_u *p;
int cc;
- if (!rex.reg_ic
-#ifdef FEAT_MBYTE
- || (!enc_utf8 && mb_char2len(c) > 1)
-#endif
- )
+ if (!rex.reg_ic || (!enc_utf8 && mb_char2len(c) > 1))
return vim_strchr(s, c);
/* tolower() and toupper() can be slow, comparing twice should be a lot
* faster (esp. when using MS Visual C++!).
* For UTF-8 need to use folded case. */
-#ifdef FEAT_MBYTE
if (enc_utf8 && c > 0x80)
cc = utf_fold(c);
else
-#endif
if (MB_ISUPPER(c))
cc = MB_TOLOWER(c);
else if (MB_ISLOWER(c))
else
return vim_strchr(s, c);
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
for (p = s; *p != NUL; p += (*mb_ptr2len)(p))
}
}
else
-#endif
/* Faster version for when there are no multi-byte characters. */
for (p = s; *p != NUL; ++p)
if (*p == c || *p == cc)
{
if (*p == '\\' && p[1]) /* skip escaped characters */
++p;
-#ifdef FEAT_MBYTE
if (has_mbyte)
p += (*mb_ptr2len)(p) - 1;
-#endif
}
}
c = *src++;
}
}
-#ifdef FEAT_MBYTE
else if (has_mbyte)
c = mb_ptr2char(src - 1);
-#endif
/* Write to buffer, if copy is set. */
if (func_one != (fptr_T)NULL)
else /* just copy */
cc = c;
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
int totlen = mb_ptr2len(src - 1);
}
src += totlen - 1;
}
- else
-#endif
- if (copy)
+ else if (copy)
*dst = cc;
dst++;
}
}
else
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
c = mb_ptr2char(s);
else
-#endif
c = *s;
if (func_one != (fptr_T)NULL)
else /* just copy */
cc = c;
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
int l;
mb_char2bytes(cc, dst);
dst += mb_char2len(cc) - 1;
}
- else
-#endif
- if (copy)
+ else if (copy)
*dst = cc;
dst++;
}
s = ret;
while (p->c > 0)
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
s += (*mb_char2bytes)(p->c, s);
else
-#endif
*s++ = p->c;
p = p->out;
}
nfa_emit_equi_class(int c)
{
#define EMIT2(c) EMIT(c); EMIT(NFA_CONCAT);
-#ifdef FEAT_MBYTE
-# define EMITMBC(c) EMIT(c); EMIT(NFA_CONCAT);
-#else
-# define EMITMBC(c)
-#endif
+#define EMITMBC(c) EMIT(c); EMIT(NFA_CONCAT);
-#ifdef FEAT_MBYTE
if (enc_utf8 || STRCMP(p_enc, "latin1") == 0
|| STRCMP(p_enc, "iso-8859-15") == 0)
-#endif
{
#ifdef EBCDIC
# define A_circumflex 0x62
int got_coll_char;
char_u *p;
char_u *endp;
-#ifdef FEAT_MBYTE
char_u *old_regparse = regparse;
-#endif
int extra = 0;
int emit_range;
int negated;
siemsg("INTERNAL: Unknown character class char: %d", c);
return FAIL;
}
-#ifdef FEAT_MBYTE
+
/* When '.' is followed by a composing char ignore the dot, so that
* the composing char is matched here. */
if (enc_utf8 && c == Magic('.') && utf_iscomposing(peekchr()))
c = getchr();
goto nfa_do_multibyte;
}
-#endif
EMIT(nfa_classcodes[p - classchars]);
if (extra == NFA_ADD_NL)
{
EMIT(NFA_RANGE);
EMIT(NFA_CONCAT);
}
- else
-#ifdef FEAT_MBYTE
- if (has_mbyte && ((*mb_char2len)(startc) > 1
+ else if (has_mbyte && ((*mb_char2len)(startc) > 1
|| (*mb_char2len)(endc) > 1))
{
/* Emit the characters in the range.
}
}
else
-#endif
{
#ifdef EBCDIC
int alpha_only = FALSE;
default:
{
-#ifdef FEAT_MBYTE
int plen;
nfa_do_multibyte:
regparse = old_regparse + plen;
}
else
-#endif
{
c = no_Magic(c);
EMIT(c);
break;
case Magic('Z'):
-#ifdef FEAT_MBYTE
regflags |= RF_ICOMBINE;
-#endif
skipchr_keepstart();
break;
case Magic('c'):
case NFA_START_COLL:
case NFA_START_NEG_COLL:
/* matches some character, including composing chars */
-#ifdef FEAT_MBYTE
if (enc_utf8)
len += MB_MAXBYTES;
else if (has_mbyte)
len += 2;
else
-#endif
++len;
if (state->c != NFA_ANY)
{
case NFA_NUPPER_IC:
case NFA_ANY_COMPOSING:
/* possibly non-ascii */
-#ifdef FEAT_MBYTE
if (has_mbyte)
len += 3;
else
-#endif
++len;
break;
break;
}
-#ifdef FEAT_MBYTE
case NFA_COMPOSING: /* char with composing char */
#if 0
/* TODO */
}
#endif
/* FALLTHROUGH */
-#endif
case NFA_MOPEN: /* \( \) Submatch */
case NFA_MOPEN1:
case NFA_ZOPEN8: mclose = NFA_ZCLOSE8; break;
case NFA_ZOPEN9: mclose = NFA_ZCLOSE9; break;
#endif
-#ifdef FEAT_MBYTE
case NFA_COMPOSING: mclose = NFA_END_COMPOSING; break;
-#endif
default:
/* NFA_MOPEN, NFA_MOPEN1 .. NFA_MOPEN9 */
mclose = *p + NSUBEXP;
goto theend;
patch(e.out, s1);
-#ifdef FEAT_MBYTE
if (mopen == NFA_COMPOSING)
/* COMPOSING->out1 = END_COMPOSING */
patch(list1(&s->out1), s1);
-#endif
PUSH(frag(s, list1(&s1->out)));
break;
if ((int)(rex.input - rex.line) >= state->val)
{
rex.input -= state->val;
-#ifdef FEAT_MBYTE
if (has_mbyte)
rex.input -= mb_head_off(rex.line, rex.input);
-#endif
}
else
rex.input = rex.line;
char_u *s;
/* Used often, do some work to avoid call overhead. */
- if (!rex.reg_ic
-#ifdef FEAT_MBYTE
- && !has_mbyte
-#endif
- )
+ if (!rex.reg_ic && !has_mbyte)
s = vim_strbyte(rex.line + *colp, c);
else
s = cstrchr(rex.line + *colp, c);
len2 += MB_CHAR2LEN(c2);
}
if (match
-#ifdef FEAT_MBYTE
/* check that no composing char follows */
&& !(enc_utf8
- && utf_iscomposing(PTR2CHAR(rex.line + col + len2)))
-#endif
- )
+ && utf_iscomposing(PTR2CHAR(rex.line + col + len2))))
{
cleanup_subexpr();
if (REG_MULTI)
int curc;
int clen;
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
curc = (*mb_ptr2char)(rex.input);
clen = (*mb_ptr2len)(rex.input);
}
else
-#endif
{
curc = *rex.input;
clen = 1;
{
case NFA_MATCH:
{
-#ifdef FEAT_MBYTE
/* If the match ends before a composing characters and
* rex.reg_icombine is not set, that is not really a match. */
if (enc_utf8 && !rex.reg_icombine && utf_iscomposing(curc))
break;
-#endif
+
nfa_match = TRUE;
copy_sub(&submatch->norm, &t->subs.norm);
#ifdef FEAT_SYN_HL
if (curc == NUL)
result = FALSE;
-#ifdef FEAT_MBYTE
else if (has_mbyte)
{
int this_class;
else if (reg_prev_class() == this_class)
result = FALSE;
}
-#endif
else if (!vim_iswordc_buf(curc, rex.reg_buf)
|| (rex.input > rex.line
&& vim_iswordc_buf(rex.input[-1], rex.reg_buf)))
result = TRUE;
if (rex.input == rex.line)
result = FALSE;
-#ifdef FEAT_MBYTE
else if (has_mbyte)
{
int this_class, prev_class;
|| prev_class == 0 || prev_class == 1)
result = FALSE;
}
-#endif
else if (!vim_iswordc_buf(rex.input[-1], rex.reg_buf)
|| (rex.input[0] != NUL
&& vim_iswordc_buf(curc, rex.reg_buf)))
}
break;
-#ifdef FEAT_MBYTE
case NFA_COMPOSING:
{
int mc = curc;
ADD_STATE_IF_MATCH(end);
break;
}
-#endif
case NFA_NEWL:
if (curc == NUL && !rex.reg_line_lbr && REG_MULTI
case NFA_ANY_COMPOSING:
/* On a composing character skip over it. Otherwise do
* nothing. Always matches. */
-#ifdef FEAT_MBYTE
if (enc_utf8 && utf_iscomposing(curc))
{
add_off = clen;
}
else
-#endif
{
add_here = TRUE;
add_off = 0;
/* Bail out quickly when there can't be a match, avoid the
* overhead of win_linetabsize() on long lines. */
if (op != 1 && col > t->state->val
-#ifdef FEAT_MBYTE
- * (has_mbyte ? MB_MAXBYTES : 1)
-#endif
- )
+ * (has_mbyte ? MB_MAXBYTES : 1))
break;
result = FALSE;
if (op == 1 && col - 1 > t->state->val && col > 100)
if (!result && rex.reg_ic)
result = MB_TOLOWER(c) == MB_TOLOWER(curc);
-#ifdef FEAT_MBYTE
/* If rex.reg_icombine is not set only skip over the character
* itself. When it is set skip over composing characters. */
if (result && enc_utf8 && !rex.reg_icombine)
clen = utf_ptr2len(rex.input);
-#endif
ADD_STATE_IF_MATCH(t->state);
break;
}
else if (prog->regflags & RF_NOICASE)
rex.reg_ic = FALSE;
-#ifdef FEAT_MBYTE
/* If pattern contains "\Z" overrule value of rex.reg_icombine */
if (prog->regflags & RF_ICOMBINE)
rex.reg_icombine = TRUE;
-#endif
rex.line = line;
rex.lnum = 0; /* relative to line */
/* If match_text is set it contains the full text that must match.
* Nothing else to try. Doesn't handle combining chars well. */
- if (prog->match_text != NULL
-#ifdef FEAT_MBYTE
- && !rex.reg_icombine
-#endif
- )
+ if (prog->match_text != NULL && !rex.reg_icombine)
return find_match_text(col, prog->regstart, prog->match_text);
}
rex.reg_buf = curbuf;
rex.reg_win = NULL;
rex.reg_ic = rmp->rm_ic;
-#ifdef FEAT_MBYTE
rex.reg_icombine = FALSE;
-#endif
rex.reg_maxcol = 0;
return nfa_regexec_both(line, col, NULL, NULL);
}
rex.reg_maxline = rex.reg_buf->b_ml.ml_line_count - lnum;
rex.reg_line_lbr = FALSE;
rex.reg_ic = rmp->rmm_ic;
-#ifdef FEAT_MBYTE
rex.reg_icombine = FALSE;
-#endif
rex.reg_maxcol = rmp->rmm_maxcol;
return nfa_regexec_both(NULL, col, tm, timed_out);
static int next_search_hl_pos(match_T *shl, linenr_T lnum, posmatch_T *pos, colnr_T mincol);
#endif
static void screen_char(unsigned off, int row, int col);
-#ifdef FEAT_MBYTE
static void screen_char_2(unsigned off, int row, int col);
-#endif
static void screenclear2(void);
static void lineclear(unsigned off, int width, int attr);
static void lineinvalid(unsigned off, int width);
int ret = 0;
schar_T *screenline; /* copy from ScreenLines[] */
sattr_T *screenattr; /* copy from ScreenAttrs[] */
-#ifdef FEAT_MBYTE
int i;
u8char_T *screenlineUC = NULL; /* copy from ScreenLinesUC[] */
u8char_T *screenlineC[MAX_MCO]; /* copy from ScreenLinesC[][] */
schar_T *screenline2 = NULL; /* copy from ScreenLines2[] */
-#endif
redraw_later(type);
if (msg_scrolled || (State != NORMAL && State != NORMAL_BUSY) || exiting)
(long_u)(rows * cols * sizeof(sattr_T)), FALSE);
if (screenline == NULL || screenattr == NULL)
ret = 2;
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
screenlineUC = (u8char_T *)lalloc(
if (screenline2 == NULL)
ret = 2;
}
-#endif
if (ret != 2)
{
mch_memmove(screenattr + r * cols,
ScreenAttrs + LineOffset[cmdline_row + r],
(size_t)cols * sizeof(sattr_T));
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
mch_memmove(screenlineUC + r * cols,
mch_memmove(screenline2 + r * cols,
ScreenLines2 + LineOffset[cmdline_row + r],
(size_t)cols * sizeof(schar_T));
-#endif
}
update_screen(0);
mch_memmove(ScreenAttrs + off,
screenattr + r * cols,
(size_t)cols * sizeof(sattr_T));
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
mch_memmove(ScreenLinesUC + off,
mch_memmove(ScreenLines2 + off,
screenline2 + r * cols,
(size_t)cols * sizeof(schar_T));
-#endif
screen_line(cmdline_row + r, 0, cols, cols, FALSE);
}
ret = 4;
vim_free(screenline);
vim_free(screenattr);
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
vim_free(screenlineUC);
}
if (enc_dbcs == DBCS_JPNU)
vim_free(screenline2);
-#endif
/* Show the intro message when appropriate. */
maybe_intro_message();
* uses that. */
gui.col = gui_cursor_col;
gui.row = gui_cursor_row;
-# ifdef FEAT_MBYTE
gui.col = mb_fix_col(gui.col, gui.row);
-# endif
gui_update_cursor(FALSE, FALSE);
gui_may_flush();
screen_cur_col = gui.col;
int i;
for (i = 0; i < Rows; ++i)
-# ifdef FEAT_MBYTE
if (enc_utf8)
if ((*mb_off2cells)(LineOffset[i] + Columns - 2,
LineOffset[i] + screen_Columns) > 1)
else
screen_draw_rectangle(i, Columns - 1, 1, 1, FALSE);
else
-# endif
screen_char(LineOffset[i] + Columns - 1, i, Columns - 1);
}
#endif
{
int off = (int)(current_ScreenLine - ScreenLines);
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
int cells;
}
}
else
-#endif
{
int len = (int)STRLEN(text);
{
ScreenLines[off] = cmdwin_type;
ScreenAttrs[off] = HL_ATTR(HLF_AT);
-#ifdef FEAT_MBYTE
if (enc_utf8)
ScreenLinesUC[off] = 0;
-#endif
++col;
}
#endif
#endif
)
{
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
if (fill_fold >= 0x80)
col++;
}
else
-#endif
ScreenLines[off + col++] = fill_fold;
}
int i;
mch_memmove(ScreenLines + off, buf, (size_t)len);
-# ifdef FEAT_MBYTE
if (enc_utf8)
vim_memset(ScreenLinesUC + off, 0, sizeof(u8char_T) * (size_t)len);
-# endif
for (i = 0; i < len; ++i)
ScreenAttrs[off + i] = attr;
}
int cur_checked_col = 0; /* checked column for current line */
#endif
int extra_check = 0; // has extra highlighting
-#ifdef FEAT_MBYTE
int multi_attr = 0; /* attributes desired by multibyte */
int mb_l = 1; /* multi-byte byte length */
int mb_c = 0; /* decoded multi-byte character */
int mb_utf8 = FALSE; /* screen char is UTF-8 char */
int u8cc[MAX_MCO]; /* composing UTF-8 chars */
-#endif
#ifdef FEAT_DIFF
int filler_lines; /* nr of filler lines to be drawn */
int filler_todo; /* nr of filler lines still to do + 1 */
v = wp->w_leftcol;
if (v > 0 && !number_only)
{
-#ifdef FEAT_MBYTE
char_u *prev_ptr = ptr;
-#endif
+
while (vcol < v && *ptr != NUL)
{
c = win_lbr_chartabsize(wp, line, ptr, (colnr_T)vcol, NULL);
vcol += c;
-#ifdef FEAT_MBYTE
prev_ptr = ptr;
-#endif
MB_PTR_ADV(ptr);
}
if (vcol > v)
{
vcol -= c;
-#ifdef FEAT_MBYTE
ptr = prev_ptr;
-#else
- --ptr;
-#endif
/* If the character fits on the screen, don't need to skip it.
* Except for a TAB. */
- if ((
-#ifdef FEAT_MBYTE
- (*mb_ptr2cells)(ptr) >= c ||
-#endif
- *ptr == TAB) && col == 0)
+ if (( (*mb_ptr2cells)(ptr) >= c || *ptr == TAB) && col == 0)
n_skip = v - vcol;
}
/* Highlight one character for an empty match. */
if (shl->startcol == shl->endcol)
{
-#ifdef FEAT_MBYTE
if (has_mbyte && line[shl->endcol] != NUL)
shl->endcol += (*mb_ptr2len)(line + shl->endcol);
else
-#endif
++shl->endcol;
}
if ((long)shl->startcol < v) /* match at leftcol */
{
/* handle Visual or match highlighting in this line */
if (vcol == fromcol
-#ifdef FEAT_MBYTE
|| (has_mbyte && vcol + 1 == fromcol && n_extra == 0
&& (*mb_ptr2cells)(ptr) > 1)
-#endif
|| ((int)vcol_prev == fromcol_prev
&& vcol_prev < vcol /* not at margin */
&& vcol < tocol))
&& v >= (long)shl->startcol
&& v < (long)shl->endcol)
{
-#ifdef FEAT_MBYTE
int tmp_col = v + MB_PTR2LEN(ptr);
if (shl->endcol < tmp_col)
shl->endcol = tmp_col;
-#endif
shl->attr_cur = shl->attr;
#ifdef FEAT_CONCEAL
if (cur != NULL && syn_name2id((char_u *)"Conceal")
{
/* highlight empty match, try again after
* it */
-#ifdef FEAT_MBYTE
if (has_mbyte)
shl->endcol += (*mb_ptr2len)(line
+ shl->endcol);
else
-#endif
++shl->endcol;
}
if (c_extra != NUL || (n_extra == 1 && c_final != NUL))
{
c = (n_extra == 1 && c_final != NUL) ? c_final : c_extra;
-#ifdef FEAT_MBYTE
mb_c = c; /* doesn't handle non-utf-8 multi-byte! */
if (enc_utf8 && utf_char2len(c) > 1)
{
}
else
mb_utf8 = FALSE;
-#endif
}
else
{
c = *p_extra;
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
mb_c = c;
p_extra += mb_l - 1;
}
}
-#endif
++p_extra;
}
--n_extra;
#ifdef FEAT_LINEBREAK
c0 = *ptr;
#endif
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
mb_c = c;
if (mb_c < 0x80)
{
c = mb_c;
-# ifdef FEAT_LINEBREAK
+#ifdef FEAT_LINEBREAK
c0 = mb_c;
-# endif
+#endif
}
mb_utf8 = TRUE;
}
}
-#endif
++ptr;
if (extra_check)
char_u *prev_ptr, *p;
int len;
hlf_T spell_hlf = HLF_COUNT;
-# ifdef FEAT_MBYTE
if (has_mbyte)
{
prev_ptr = ptr - mb_l;
v -= mb_l - 1;
}
else
-# endif
prev_ptr = ptr - 1;
/* Use nextline[] if possible, it has the start of the
if (wp->w_p_lbr && c0 == c
&& VIM_ISBREAK(c) && !VIM_ISBREAK((int)*ptr))
{
-# ifdef FEAT_MBYTE
int mb_off = has_mbyte ? (*mb_head_off)(line, ptr - 1) : 0;
-# endif
- char_u *p = ptr - (
-# ifdef FEAT_MBYTE
- mb_off +
-# endif
- 1);
+ char_u *p = ptr - (mb_off + 1);
/* TODO: is passing p for start of the line OK? */
n_extra = win_lbr_chartabsize(wp, line, p, (colnr_T)vcol,
- vcol % (int)wp->w_buffer->b_p_ts - 1;
# endif
-# ifdef FEAT_MBYTE
c_extra = mb_off > 0 ? MB_FILLER_CHAR : ' ';
-# else
- c_extra = ' ';
-# endif
c_final = NUL;
if (VIM_ISWHITE(c))
{
*/
if (wp->w_p_list
&& (((c == 160
-#ifdef FEAT_MBYTE
- || (mb_utf8 && (mb_c == 160 || mb_c == 0x202f))
-#endif
- ) && lcs_nbsp)
+ || (mb_utf8 && (mb_c == 160 || mb_c == 0x202f)))
+ && lcs_nbsp)
|| (c == ' ' && lcs_space && ptr - line <= trailcol)))
{
c = (c == ' ') ? lcs_space : lcs_nbsp;
extra_attr = HL_ATTR(HLF_8);
saved_attr2 = char_attr; /* save current attr */
}
-#ifdef FEAT_MBYTE
mb_c = c;
if (enc_utf8 && utf_char2len(c) > 1)
{
}
else
mb_utf8 = FALSE;
-#endif
}
if (trailcol != MAXCOL && ptr > line + trailcol && c == ' ')
extra_attr = HL_ATTR(HLF_8);
saved_attr2 = char_attr; /* save current attr */
}
-#ifdef FEAT_MBYTE
mb_c = c;
if (enc_utf8 && utf_char2len(c) > 1)
{
}
else
mb_utf8 = FALSE;
-#endif
}
}
/* if n_extra > 0, it gives the number of chars, to
* use for a tab, else we need to calculate the width
* for a tab */
-#ifdef FEAT_MBYTE
len = (tab_len * mb_char2len(lcs_tab2));
if (n_extra > 0)
len += n_extra - tab_len;
-#endif
c = lcs_tab1;
p = alloc((unsigned)(len + 1));
vim_memset(p, ' ', len);
tab_len = i;
break;
}
-#ifdef FEAT_MBYTE
mb_char2bytes(lcs_tab2, p);
p += mb_char2len(lcs_tab2);
n_extra += mb_char2len(lcs_tab2)
- (saved_nextra > 0 ? 1 : 0);
-#else
- p[i] = lcs_tab2;
-#endif
}
p_extra = p_extra_free;
#ifdef FEAT_CONCEAL
tab_len += vc_saved;
}
#endif
-#ifdef FEAT_MBYTE
mb_utf8 = FALSE; /* don't draw as UTF-8 */
-#endif
if (wp->w_p_list)
{
c = (n_extra == 0 && lcs_tab3) ? lcs_tab3 : lcs_tab1;
n_attr = tab_len + 1;
extra_attr = HL_ATTR(HLF_8);
saved_attr2 = char_attr; /* save current attr */
-#ifdef FEAT_MBYTE
mb_c = c;
if (enc_utf8 && utf_char2len(c) > 1)
{
u8cc[0] = 0;
c = 0xc0;
}
-#endif
}
else
{
extra_attr = HL_ATTR(HLF_AT);
n_attr = 1;
}
-#ifdef FEAT_MBYTE
mb_c = c;
if (enc_utf8 && utf_char2len(c) > 1)
{
}
else
mb_utf8 = FALSE; /* don't draw as UTF-8 */
-#endif
}
else if (c != NUL)
{
extra_attr = HL_ATTR(HLF_8);
saved_attr2 = char_attr; /* save current attr */
}
-#ifdef FEAT_MBYTE
mb_utf8 = FALSE; /* don't draw as UTF-8 */
-#endif
}
#ifdef FEAT_VIRTUALEDIT
else if (VIsual_active
is_concealing = TRUE;
n_skip = 1;
}
-# ifdef FEAT_MBYTE
mb_c = c;
if (enc_utf8 && utf_char2len(c) > 1)
{
}
else
mb_utf8 = FALSE; /* don't draw as UTF-8 */
-# endif
}
else
{
{
c = lcs_prec;
lcs_prec_todo = NUL;
-#ifdef FEAT_MBYTE
if (has_mbyte && (*mb_char2cells)(mb_c) > 1)
{
/* Double-width character being overwritten by the "precedes"
}
else
mb_utf8 = FALSE; /* don't draw as UTF-8 */
-#endif
if (!attr_pri)
{
saved_attr3 = char_attr; /* save current attr */
{
/* Add a blank character to highlight. */
ScreenLines[off] = ' ';
-#ifdef FEAT_MBYTE
if (enc_utf8)
ScreenLinesUC[off] = 0;
-#endif
}
#ifdef FEAT_SEARCH_EXTRA
if (area_attr == 0)
while (col < wp->w_width)
{
ScreenLines[off] = ' ';
-#ifdef FEAT_MBYTE
if (enc_utf8)
ScreenLinesUC[off] = 0;
-#endif
++col;
if (draw_color_col)
draw_color_col = advance_color_col(VCOL_HLC,
{
c = lcs_ext;
char_attr = HL_ATTR(HLF_AT);
-#ifdef FEAT_MBYTE
mb_c = c;
if (enc_utf8 && utf_char2len(c) > 1)
{
}
else
mb_utf8 = FALSE;
-#endif
}
#ifdef FEAT_SYN_HL
/*
* Store the character.
*/
-#if defined(FEAT_RIGHTLEFT) && defined(FEAT_MBYTE)
+#if defined(FEAT_RIGHTLEFT)
if (has_mbyte && wp->w_p_rl && (*mb_char2cells)(mb_c) > 1)
{
/* A double-wide character is: put first halve in left cell. */
}
#endif
ScreenLines[off] = c;
-#ifdef FEAT_MBYTE
if (enc_dbcs == DBCS_JPNU)
{
if ((mb_c & 0xff00) == 0x8e00)
multi_attr = 0;
}
else
-#endif
ScreenAttrs[off] = char_attr;
-#ifdef FEAT_MBYTE
if (has_mbyte && (*mb_char2cells)(mb_c) > 1)
{
/* Need to fill two screen columns. */
}
#endif
}
-#endif
#ifdef FEAT_RIGHTLEFT
if (wp->w_p_rl)
{
}
-# ifdef FEAT_MBYTE
if (has_mbyte && (*mb_char2cells)(mb_c) > 1)
{
/* Need to fill two screen columns. */
-# ifdef FEAT_RIGHTLEFT
+# ifdef FEAT_RIGHTLEFT
if (wp->w_p_rl)
{
--boguscols;
--col;
}
else
-# endif
+# endif
{
++boguscols;
++col;
}
}
-# endif
# ifdef FEAT_RIGHTLEFT
if (wp->w_p_rl)
#ifdef FEAT_GUI
&& !gui.in_use
#endif
-#ifdef FEAT_MBYTE
&& !(has_mbyte
&& ((*mb_off2cells)(LineOffset[screen_row],
LineOffset[screen_row] + screen_Columns)
|| (*mb_off2cells)(LineOffset[screen_row - 1]
+ (int)Columns - 2,
LineOffset[screen_row] + screen_Columns)
- == 2))
-#endif
- )
+ == 2)))
{
/* First make sure we are at the end of the screen line,
* then output the same character again to let the
+ (unsigned)Columns - 1,
screen_row - 1, (int)(Columns - 1));
-#ifdef FEAT_MBYTE
/* When there is a multi-byte character, just output a
* space to keep it simple. */
if (has_mbyte && MB_BYTE2LEN(ScreenLines[LineOffset[
screen_row - 1] + (Columns - 1)]) > 1)
out_char(' ');
else
-#endif
out_char(ScreenLines[LineOffset[screen_row - 1]
+ (Columns - 1)]);
/* force a redraw of the first char on the next line */
return row;
}
-#ifdef FEAT_MBYTE
/*
* Return if the composing characters at "off_from" and "off_to" differ.
* Only to be used when ScreenLinesUC[off_from] != 0.
}
return FALSE;
}
-#endif
/*
* Check whether the given character needs redrawing:
if (cols > 0
&& ((ScreenLines[off_from] != ScreenLines[off_to]
|| ScreenAttrs[off_from] != ScreenAttrs[off_to])
-
-#ifdef FEAT_MBYTE
|| (enc_dbcs != 0
&& MB_BYTE2LEN(ScreenLines[off_from]) > 1
&& (enc_dbcs == DBCS_JPNU && ScreenLines[off_from] == 0x8e
&& comp_char_differs(off_from, off_to))
|| ((*mb_off2cells)(off_from, off_from + cols) > 1
&& ScreenLines[off_from + 1]
- != ScreenLines[off_to + 1])))
-#endif
- ))
+ != ScreenLines[off_to + 1])))))
return TRUE;
return FALSE;
}
{
unsigned off_from;
unsigned off_to;
-#ifdef FEAT_MBYTE
unsigned max_off_from;
unsigned max_off_to;
-#endif
int col = 0;
int hl;
int force = FALSE; /* force update rest of the line */
#endif
;
int redraw_next; /* redraw_this for next character */
-#ifdef FEAT_MBYTE
int clear_next = FALSE;
int char_cells; /* 1: normal char */
/* 2: occupies two display cells */
# define CHAR_CELLS char_cells
-#else
-# define CHAR_CELLS 1
-#endif
/* Check for illegal row and col, just in case. */
if (row >= Rows)
off_from = (unsigned)(current_ScreenLine - ScreenLines);
off_to = LineOffset[row] + coloff;
-#ifdef FEAT_MBYTE
max_off_from = off_from + screen_Columns;
max_off_to = LineOffset[row] + screen_Columns;
-#endif
#ifdef FEAT_RIGHTLEFT
if (rlflag)
{
while (col <= endcol && ScreenLines[off_to] == ' '
&& ScreenAttrs[off_to] == 0
-# ifdef FEAT_MBYTE
- && (!enc_utf8 || ScreenLinesUC[off_to] == 0)
-# endif
- )
+ && (!enc_utf8 || ScreenLinesUC[off_to] == 0))
{
++off_to;
++col;
while (col < endcol)
{
-#ifdef FEAT_MBYTE
if (has_mbyte && (col + 1 < endcol))
char_cells = (*mb_off2cells)(off_from, max_off_from);
else
char_cells = 1;
-#endif
redraw_this = redraw_next;
redraw_next = force || char_needs_redraw(off_from + CHAR_CELLS,
else
screen_attr = 0; /* highlighting has stopped */
}
-#ifdef FEAT_MBYTE
if (enc_dbcs != 0)
{
/* Check if overwriting a double-byte with a single-byte or
&& (*mb_off2cells)(off_to, max_off_to) == 1
&& (*mb_off2cells)(off_to + 1, max_off_to) > 1)))
clear_next = TRUE;
-#endif
ScreenLines[off_to] = ScreenLines[off_from];
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
ScreenLinesUC[off_to] = ScreenLinesUC[off_from];
}
if (char_cells == 2)
ScreenLines[off_to + 1] = ScreenLines[off_from + 1];
-#endif
#if defined(FEAT_GUI) || defined(UNIX)
/* The bold trick makes a single column of pixels appear in the
}
#endif
ScreenAttrs[off_to] = ScreenAttrs[off_from];
-#ifdef FEAT_MBYTE
+
/* For simplicity set the attributes of second half of a
* double-wide character equal to the first half. */
if (char_cells == 2)
if (enc_dbcs != 0 && char_cells == 2)
screen_char_2(off_to, row, col + coloff);
else
-#endif
screen_char(off_to, row, col + coloff);
}
else if ( p_wiv
col += CHAR_CELLS;
}
-#ifdef FEAT_MBYTE
if (clear_next)
{
/* Clear the second half of a double-wide character of which the left
ScreenLinesUC[off_to] = 0;
screen_char(off_to, row, col + coloff);
}
-#endif
if (clear_width > 0
#ifdef FEAT_RIGHTLEFT
/* blank out the rest of the line */
while (col < clear_width && ScreenLines[off_to] == ' '
&& ScreenAttrs[off_to] == 0
-#ifdef FEAT_MBYTE
- && (!enc_utf8 || ScreenLinesUC[off_to] == 0)
-#endif
- )
+ && (!enc_utf8 || ScreenLinesUC[off_to] == 0))
{
++off_to;
++col;
if (hl > HL_ALL || (hl & HL_BOLD))
{
int prev_cells = 1;
-# ifdef FEAT_MBYTE
+
if (enc_utf8)
/* for utf-8, ScreenLines[char_offset + 1] == 0 means
* that its width is 2. */
screen_char_2(off_to - prev_cells, row,
col + coloff - prev_cells);
else
-# endif
screen_char(off_to - prev_cells, row,
col + coloff - prev_cells);
}
c = fillchar_vsep(&hl);
if (ScreenLines[off_to] != (schar_T)c
-#ifdef FEAT_MBYTE
|| (enc_utf8 && (int)ScreenLinesUC[off_to]
!= (c >= 0x80 ? c : 0))
-#endif
|| ScreenAttrs[off_to] != hl)
{
ScreenLines[off_to] = c;
ScreenAttrs[off_to] = hl;
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
if (c >= 0x80)
else
ScreenLinesUC[off_to] = 0;
}
-#endif
screen_char(off_to, row, col + coloff);
}
}
#ifdef FEAT_MENU
int emenu;
#endif
-#if defined(FEAT_MBYTE) || defined(FEAT_MENU)
int l;
-#endif
if (matches == NULL) /* interrupted completion? */
return;
-#ifdef FEAT_MBYTE
if (has_mbyte)
buf = alloc((unsigned)Columns * MB_MAXBYTES + 1);
else
-#endif
buf = alloc((unsigned)Columns + 1);
if (buf == NULL)
return;
{
s += skip_status_match_char(xp, s);
clen += ptr2cells(s);
-#ifdef FEAT_MBYTE
if (has_mbyte && (l = (*mb_ptr2len)(s)) > 1)
{
STRNCPY(buf + len, s, l);
len += l;
}
else
-#endif
{
STRCPY(buf + len, transchar_byte(*s));
len += (int)STRLEN(buf + len);
p = (char_u *)"<"; /* No room for file name! */
len = 1;
}
- else
-#ifdef FEAT_MBYTE
- if (has_mbyte)
- {
- int clen = 0, i;
-
- /* Count total number of display cells. */
- clen = mb_string2cells(p, -1);
+ else if (has_mbyte)
+ {
+ int clen = 0, i;
- /* Find first character that will fit.
- * Going from start to end is much faster for DBCS. */
- for (i = 0; p[i] != NUL && clen >= this_ru_col - 1;
- i += (*mb_ptr2len)(p + i))
- clen -= (*mb_ptr2cells)(p + i);
- len = clen;
- if (i > 0)
- {
- p = p + i - 1;
- *p = '<';
- ++len;
- }
+ /* Count total number of display cells. */
+ clen = mb_string2cells(p, -1);
- }
- else
-#endif
- if (len > this_ru_col - 1)
+ /* Find first character that will fit.
+ * Going from start to end is much faster for DBCS. */
+ for (i = 0; p[i] != NUL && clen >= this_ru_col - 1;
+ i += (*mb_ptr2len)(p + i))
+ clen -= (*mb_ptr2cells)(p + i);
+ len = clen;
+ if (i > 0)
{
- p += len - (this_ru_col - 1);
+ p = p + i - 1;
*p = '<';
- len = this_ru_col - 1;
+ ++len;
}
+ }
+ else if (len > this_ru_col - 1)
+ {
+ p += len - (this_ru_col - 1);
+ *p = '<';
+ len = this_ru_col - 1;
+ }
+
row = W_WINROW(wp) + wp->w_height;
screen_puts(p, row, wp->w_wincol, attr);
screen_fill(row, row + 1, len + wp->w_wincol,
len = (int)STRLEN(buf);
while (width < maxwidth && len < (int)sizeof(buf) - 1)
{
-#ifdef FEAT_MBYTE
len += (*mb_char2bytes)(fillchar, buf + len);
-#else
- buf[len++] = fillchar;
-#endif
++width;
}
buf[len] = NUL;
{
char_u buf[MB_MAXBYTES + 1];
-#ifdef FEAT_MBYTE
if (has_mbyte)
buf[(*mb_char2bytes)(c, buf)] = NUL;
else
-#endif
{
buf[0] = c;
buf[1] = NUL;
bytes[0] = ScreenLines[off];
bytes[1] = NUL;
-#ifdef FEAT_MBYTE
if (enc_utf8 && ScreenLinesUC[off] != 0)
bytes[utfc_char2bytes(off, bytes)] = NUL;
else if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
bytes[1] = ScreenLines[off + 1];
bytes[2] = NUL;
}
-#endif
}
}
-#ifdef FEAT_MBYTE
/*
* Return TRUE if composing characters for screen posn "off" differs from
* composing characters in "u8cc".
}
return FALSE;
}
-#endif
/*
* Put string '*text' on the screen at position 'row' and 'col', with
char_u *ptr = text;
int len = textlen;
int c;
-#ifdef FEAT_MBYTE
unsigned max_off;
int mbyte_blen = 1;
int mbyte_cells = 1;
int u8c = 0;
int u8cc[MAX_MCO];
int clear_next_cell = FALSE;
-# ifdef FEAT_ARABIC
+#ifdef FEAT_ARABIC
int prev_c = 0; /* previous Arabic character */
int pc, nc, nc1;
int pcc[MAX_MCO];
-# endif
#endif
-#if defined(FEAT_MBYTE) || defined(FEAT_GUI) || defined(UNIX)
int force_redraw_this;
int force_redraw_next = FALSE;
-#endif
int need_redraw;
if (ScreenLines == NULL || row >= screen_Rows) /* safety check */
return;
off = LineOffset[row] + col;
-#ifdef FEAT_MBYTE
/* When drawing over the right halve of a double-wide char clear out the
* left halve. Only needed in a terminal. */
if (has_mbyte && col > 0 && col < screen_Columns
-# ifdef FEAT_GUI
+#ifdef FEAT_GUI
&& !gui.in_use
-# endif
+#endif
&& mb_fix_col(col, row) != col)
{
ScreenLines[off - 1] = ' ';
/* force the cell at "col" to be redrawn */
force_redraw_next = TRUE;
}
-#endif
-#ifdef FEAT_MBYTE
max_off = LineOffset[row] + screen_Columns;
-#endif
while (col < screen_Columns
&& (len < 0 || (int)(ptr - text) < len)
&& *ptr != NUL)
{
c = *ptr;
-#ifdef FEAT_MBYTE
/* check if this is the first byte of a multibyte */
if (has_mbyte)
{
else
u8c = utfc_ptr2char(ptr, u8cc);
mbyte_cells = utf_char2cells(u8c);
-# ifdef UNICODE16
+#ifdef UNICODE16
/* Non-BMP character: display as ? or fullwidth ?. */
if (u8c >= 0x10000)
{
if (attr == 0)
attr = HL_ATTR(HLF_8);
}
-# endif
-# ifdef FEAT_ARABIC
+#endif
+#ifdef FEAT_ARABIC
if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c))
{
/* Do Arabic shaping. */
}
else
prev_c = u8c;
-# endif
+#endif
if (col + mbyte_cells > screen_Columns)
{
/* Only 1 cell left, but character requires 2 cells:
}
}
}
-#endif
-#if defined(FEAT_MBYTE) || defined(FEAT_GUI) || defined(UNIX)
force_redraw_this = force_redraw_next;
force_redraw_next = FALSE;
-#endif
need_redraw = ScreenLines[off] != c
-#ifdef FEAT_MBYTE
|| (mbyte_cells == 2
&& ScreenLines[off + 1] != (enc_dbcs ? ptr[1] : 0))
|| (enc_dbcs == DBCS_JPNU
(u8char_T)(c < 0x80 && u8cc[0] == 0 ? 0 : u8c)
|| (ScreenLinesUC[off] != 0
&& screen_comp_differs(off, u8cc))))
-#endif
|| ScreenAttrs[off] != attr
|| exmode_active;
- if (need_redraw
-#if defined(FEAT_MBYTE) || defined(FEAT_GUI) || defined(UNIX)
- || force_redraw_this
-#endif
- )
+ if (need_redraw || force_redraw_this)
{
#if defined(FEAT_GUI) || defined(UNIX)
/* The bold trick makes a single row of pixels appear in the next
force_redraw_next = TRUE;
}
#endif
-#ifdef FEAT_MBYTE
/* When at the end of the text and overwriting a two-cell
* character with a one-cell character, need to clear the next
* cell. Also when overwriting the left halve of a two-cell char
&& (*mb_off2cells)(off, max_off) == 1
&& (*mb_off2cells)(off + 1, max_off) > 1)))
ScreenLines[off + mbyte_blen] = 0;
-#endif
ScreenLines[off] = c;
ScreenAttrs[off] = attr;
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
if (c < 0x80 && u8cc[0] == 0)
screen_char(off, row, col);
}
else
-#endif
screen_char(off, row, col);
}
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
off += mbyte_cells;
}
}
else
-#endif
{
++off;
++col;
}
}
-#if defined(FEAT_MBYTE) || defined(FEAT_GUI) || defined(UNIX)
/* If we detected the next character needs to be redrawn, but the text
* doesn't extend up to there, update the character here. */
if (force_redraw_next && col < screen_Columns)
{
-# ifdef FEAT_MBYTE
if (enc_dbcs != 0 && dbcs_off2cells(off, max_off) > 1)
screen_char_2(off, row, col);
else
-# endif
screen_char(off, row, col);
}
-#endif
}
#ifdef FEAT_SEARCH_EXTRA
shl->lnum = 0;
break;
}
-#ifdef FEAT_MBYTE
if (has_mbyte)
matchcol += mb_ptr2len(ml);
else
-#endif
++matchcol;
}
else
if (screen_attr != attr)
screen_start_highlight(attr);
-#ifdef FEAT_MBYTE
if (enc_utf8 && ScreenLinesUC[off] != 0)
{
char_u buf[MB_MAXBYTES + 1];
if (utf_ambiguous_width(ScreenLinesUC[off]))
{
if (*p_ambw == 'd'
-# ifdef FEAT_GUI
+#ifdef FEAT_GUI
&& !gui.in_use
-# endif
+#endif
)
{
/* Clear the two screen cells. If the character is actually
out_str(buf);
}
else
-#endif
{
-#ifdef FEAT_MBYTE
out_flush_check();
-#endif
out_char(ScreenLines[off]);
-#ifdef FEAT_MBYTE
/* double-byte character in single-width cell */
if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
out_char(ScreenLines2[off]);
-#endif
}
screen_cur_col++;
}
-#ifdef FEAT_MBYTE
-
/*
* Used for enc_dbcs only: Put one double-wide character at ScreenLines["off"]
* on the screen at position 'row' and 'col'.
out_char(ScreenLines[off + 1]);
++screen_cur_col;
}
-#endif
/*
* Draw a rectangle of the screen, inverted when "invert" is TRUE.
{
int r, c;
int off;
-#ifdef FEAT_MBYTE
int max_off;
-#endif
/* Can't use ScreenLines unless initialized */
if (ScreenLines == NULL)
for (r = row; r < row + height; ++r)
{
off = LineOffset[r];
-#ifdef FEAT_MBYTE
max_off = off + screen_Columns;
-#endif
for (c = col; c < col + width; ++c)
{
-#ifdef FEAT_MBYTE
if (enc_dbcs != 0 && dbcs_off2cells(off + c, max_off) > 1)
{
screen_char_2(off + c, r, c);
++c;
}
else
-#endif
{
screen_char(off + c, r, c);
-#ifdef FEAT_MBYTE
if (utf_off2cells(off + c, max_off) > 1)
++c;
-#endif
}
}
}
{
ScreenLines[off] = ' ';
ScreenAttrs[off] = attr;
-# ifdef FEAT_MBYTE
if (enc_utf8)
ScreenLinesUC[off] = 0;
-# endif
}
/*
!IS_CTERM);
for (row = start_row; row < end_row; ++row)
{
-#ifdef FEAT_MBYTE
if (has_mbyte
-# ifdef FEAT_GUI
+#ifdef FEAT_GUI
&& !gui.in_use
-# endif
+#endif
)
{
/* When drawing over the right halve of a double-wide char clear
if (end_col < screen_Columns && mb_fix_col(end_col, row) != end_col)
screen_puts_len((char_u *)" ", 1, row, end_col, 0);
}
-#endif
/*
* Try to use delete-line termcap code, when no attributes or in a
* "normal" terminal, where a bold/italic space is just a
end_off = LineOffset[row] + end_col;
/* skip blanks (used often, keep it fast!) */
-#ifdef FEAT_MBYTE
if (enc_utf8)
while (off < end_off && ScreenLines[off] == ' '
&& ScreenAttrs[off] == 0 && ScreenLinesUC[off] == 0)
++off;
else
-#endif
while (off < end_off && ScreenLines[off] == ' '
&& ScreenAttrs[off] == 0)
++off;
for (col = start_col; col < end_col; ++col)
{
if (ScreenLines[off] != c
-#ifdef FEAT_MBYTE
|| (enc_utf8 && (int)ScreenLinesUC[off]
!= (c >= 0x80 ? c : 0))
-#endif
|| ScreenAttrs[off] != attr
#if defined(FEAT_GUI) || defined(UNIX)
|| force_next
}
#endif
ScreenLines[off] = c;
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
if (c >= 0x80)
else
ScreenLinesUC[off] = 0;
}
-#endif
ScreenAttrs[off] = attr;
if (!did_delete || c != ' ')
screen_char(off, row, col);
int outofmem = FALSE;
int len;
schar_T *new_ScreenLines;
-#ifdef FEAT_MBYTE
u8char_T *new_ScreenLinesUC = NULL;
u8char_T *new_ScreenLinesC[MAX_MCO];
schar_T *new_ScreenLines2 = NULL;
int i;
-#endif
sattr_T *new_ScreenAttrs;
unsigned *new_LineOffset;
char_u *new_LineWraps;
if ((ScreenLines != NULL
&& Rows == screen_Rows
&& Columns == screen_Columns
-#ifdef FEAT_MBYTE
&& enc_utf8 == (ScreenLinesUC != NULL)
&& (enc_dbcs == DBCS_JPNU) == (ScreenLines2 != NULL)
- && p_mco == Screen_mco
-#endif
- )
+ && p_mco == Screen_mco)
|| Rows == 0
|| Columns == 0
|| (!full_screen && ScreenLines == NULL))
new_ScreenLines = (schar_T *)lalloc((long_u)(
(Rows + 1) * Columns * sizeof(schar_T)), FALSE);
-#ifdef FEAT_MBYTE
vim_memset(new_ScreenLinesC, 0, sizeof(u8char_T *) * MAX_MCO);
if (enc_utf8)
{
if (enc_dbcs == DBCS_JPNU)
new_ScreenLines2 = (schar_T *)lalloc((long_u)(
(Rows + 1) * Columns * sizeof(schar_T)), FALSE);
-#endif
new_ScreenAttrs = (sattr_T *)lalloc((long_u)(
(Rows + 1) * Columns * sizeof(sattr_T)), FALSE);
new_LineOffset = (unsigned *)lalloc((long_u)(
outofmem = TRUE;
give_up:
-#ifdef FEAT_MBYTE
for (i = 0; i < p_mco; ++i)
if (new_ScreenLinesC[i] == NULL)
break;
-#endif
if (new_ScreenLines == NULL
-#ifdef FEAT_MBYTE
|| (enc_utf8 && (new_ScreenLinesUC == NULL || i != p_mco))
|| (enc_dbcs == DBCS_JPNU && new_ScreenLines2 == NULL)
-#endif
|| new_ScreenAttrs == NULL
|| new_LineOffset == NULL
|| new_LineWraps == NULL
done_outofmem_msg = TRUE;
}
VIM_CLEAR(new_ScreenLines);
-#ifdef FEAT_MBYTE
VIM_CLEAR(new_ScreenLinesUC);
for (i = 0; i < p_mco; ++i)
VIM_CLEAR(new_ScreenLinesC[i]);
VIM_CLEAR(new_ScreenLines2);
-#endif
VIM_CLEAR(new_ScreenAttrs);
VIM_CLEAR(new_LineOffset);
VIM_CLEAR(new_LineWraps);
{
(void)vim_memset(new_ScreenLines + new_row * Columns,
' ', (size_t)Columns * sizeof(schar_T));
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
(void)vim_memset(new_ScreenLinesUC + new_row * Columns,
if (enc_dbcs == DBCS_JPNU)
(void)vim_memset(new_ScreenLines2 + new_row * Columns,
0, (size_t)Columns * sizeof(schar_T));
-#endif
(void)vim_memset(new_ScreenAttrs + new_row * Columns,
0, (size_t)Columns * sizeof(sattr_T));
old_row = new_row + (screen_Rows - Rows);
len = screen_Columns;
else
len = Columns;
-#ifdef FEAT_MBYTE
/* When switching to utf-8 don't copy characters, they
* may be invalid now. Also when p_mco changes. */
if (!(enc_utf8 && ScreenLinesUC == NULL)
&& p_mco == Screen_mco)
-#endif
mch_memmove(new_ScreenLines + new_LineOffset[new_row],
ScreenLines + LineOffset[old_row],
(size_t)len * sizeof(schar_T));
-#ifdef FEAT_MBYTE
if (enc_utf8 && ScreenLinesUC != NULL
&& p_mco == Screen_mco)
{
mch_memmove(new_ScreenLines2 + new_LineOffset[new_row],
ScreenLines2 + LineOffset[old_row],
(size_t)len * sizeof(schar_T));
-#endif
mch_memmove(new_ScreenAttrs + new_LineOffset[new_row],
ScreenAttrs + LineOffset[old_row],
(size_t)len * sizeof(sattr_T));
free_screenlines();
ScreenLines = new_ScreenLines;
-#ifdef FEAT_MBYTE
ScreenLinesUC = new_ScreenLinesUC;
for (i = 0; i < p_mco; ++i)
ScreenLinesC[i] = new_ScreenLinesC[i];
Screen_mco = p_mco;
ScreenLines2 = new_ScreenLines2;
-#endif
ScreenAttrs = new_ScreenAttrs;
LineOffset = new_LineOffset;
LineWraps = new_LineWraps;
void
free_screenlines(void)
{
-#ifdef FEAT_MBYTE
int i;
vim_free(ScreenLinesUC);
for (i = 0; i < Screen_mco; ++i)
vim_free(ScreenLinesC[i]);
vim_free(ScreenLines2);
-#endif
vim_free(ScreenLines);
vim_free(ScreenAttrs);
vim_free(LineOffset);
lineclear(unsigned off, int width, int attr)
{
(void)vim_memset(ScreenLines + off, ' ', (size_t)width * sizeof(schar_T));
-#ifdef FEAT_MBYTE
if (enc_utf8)
(void)vim_memset(ScreenLinesUC + off, 0,
(size_t)width * sizeof(u8char_T));
-#endif
(void)vim_memset(ScreenAttrs + off, attr, (size_t)width * sizeof(sattr_T));
}
mch_memmove(ScreenLines + off_to, ScreenLines + off_from,
wp->w_width * sizeof(schar_T));
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
int i;
if (enc_dbcs == DBCS_JPNU)
mch_memmove(ScreenLines2 + off_to, ScreenLines2 + off_from,
wp->w_width * sizeof(schar_T));
-#endif
mch_memmove(ScreenAttrs + off_to, ScreenAttrs + off_from,
wp->w_width * sizeof(sattr_T));
}
if (i != 0)
cost = 999; /* different attributes, don't do it */
}
-#ifdef FEAT_MBYTE
if (enc_utf8)
{
/* Don't use an UTF-8 char for positioning, it's slow. */
break;
}
}
-#endif
}
/*
{
if (ScreenAttrs[off] != screen_attr)
screen_stop_highlight();
-#ifdef FEAT_MBYTE
out_flush_check();
-#endif
out_char(ScreenLines[off]);
-#ifdef FEAT_MBYTE
if (enc_dbcs == DBCS_JPNU
&& ScreenLines[off] == 0x8e)
out_char(ScreenLines2[off]);
-#endif
++off;
}
}
#ifdef FEAT_RIGHTLEFT
/* With 'rightleft' set and the cursor on a double-wide
* character, position it on the leftmost column. */
- curwin->w_p_rl ? ((int)curwin->w_width - curwin->w_wcol - (
-# ifdef FEAT_MBYTE
- (has_mbyte
+ curwin->w_p_rl ? ((int)curwin->w_width - curwin->w_wcol
+ - ((has_mbyte
&& (*mb_ptr2cells)(ml_get_cursor()) == 2
- && vim_isprintc(gchar_cursor())) ? 2 :
-# endif
- 1)) :
+ && vim_isprintc(gchar_cursor())) ? 2 : 1)) :
#endif
curwin->w_wcol));
}
shorten_dir(NameBuff);
len = vim_strsize(NameBuff);
p = NameBuff;
-#ifdef FEAT_MBYTE
if (has_mbyte)
while (len > room)
{
len -= ptr2cells(p);
MB_PTR_ADV(p);
}
- else
-#endif
- if (len > room)
+ else if (len > room)
{
p += len - room;
len = room;
/* need at least 3 chars left for get_rel_pos() + NUL */
while (this_ru_col + o < width && RULER_BUF_LEN > i + 4)
{
-#ifdef FEAT_MBYTE
if (has_mbyte)
i += (*mb_char2bytes)(fillchar, buffer + i);
else
-#endif
buffer[i++] = fillchar;
++o;
}
get_rel_pos(wp, buffer + i, RULER_BUF_LEN - i);
}
/* Truncate at window boundary. */
-#ifdef FEAT_MBYTE
if (has_mbyte)
{
o = 0;
}
}
}
- else
-#endif
- if (this_ru_col + (int)STRLEN(buffer) > width)
+ else if (this_ru_col + (int)STRLEN(buffer) > width)
buffer[width - this_ru_col] = NUL;
screen_puts(buffer, row, this_ru_col + off, attr);
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 809,
/**/
808,
/**/
projects / vim / commitdiff