Extract strings.c from misc2.c

4 files changed, 562 insertions, 518 deletions

diff --git a/src/misc2.c b/src/misc2.c
index d946bd66f5..06a4764250 100644
--- a/src/misc2.c
+++ b/src/misc2.c
@@ -592,92 +592,6 @@ int leftcol_changed(void)
 }
 
 /*
- * Copy "string" into newly allocated memory.
- */
-char_u *vim_strsave(char_u *string)
-{
-  char_u      *p;
-  unsigned len;
-
-  len = (unsigned)STRLEN(string) + 1;
-  p = alloc(len);
-  if (p != NULL)
-    memmove(p, string, (size_t)len);
-  return p;
-}
-
-/*
- * Copy up to "len" bytes of "string" into newly allocated memory and
- * terminate with a NUL.
- * The allocated memory always has size "len + 1", also when "string" is
- * shorter.
- */
-char_u *vim_strnsave(char_u *string, int len)
-{
-  char_u      *p;
-
-  p = alloc((unsigned)(len + 1));
-  STRNCPY(p, string, len);
-  p[len] = NUL;
-  return p;
-}
-
-/*
- * Same as vim_strsave(), but any characters found in esc_chars are preceded
- * by a backslash.
- */
-char_u *vim_strsave_escaped(char_u *string, char_u *esc_chars)
-{
-  return vim_strsave_escaped_ext(string, esc_chars, '\\', FALSE);
-}
-
-/*
- * Same as vim_strsave_escaped(), but when "bsl" is TRUE also escape
- * characters where rem_backslash() would remove the backslash.
- * Escape the characters with "cc".
- */
-char_u *vim_strsave_escaped_ext(char_u *string, char_u *esc_chars, int cc, int bsl)
-{
-  char_u      *p;
-  char_u      *p2;
-  char_u      *escaped_string;
-  unsigned length;
-  int l;
-
-  /*
-   * First count the number of backslashes required.
-   * Then allocate the memory and insert them.
-   */
-  length = 1;                           /* count the trailing NUL */
-  for (p = string; *p; p++) {
-    if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) {
-      length += l;                      /* count a multibyte char */
-      p += l - 1;
-      continue;
-    }
-    if (vim_strchr(esc_chars, *p) != NULL || (bsl && rem_backslash(p)))
-      ++length;                         /* count a backslash */
-    ++length;                           /* count an ordinary char */
-  }
-  escaped_string = alloc(length);
-  p2 = escaped_string;
-  for (p = string; *p; p++) {
-    if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) {
-      memmove(p2, p, (size_t)l);
-      p2 += l;
-      p += l - 1;                     /* skip multibyte char  */
-      continue;
-    }
-    if (vim_strchr(esc_chars, *p) != NULL || (bsl && rem_backslash(p)))
-      *p2++ = cc;
-    *p2++ = *p;
-  }
-  *p2 = NUL;
-
-  return escaped_string;
-}
-
-/*
  * Return TRUE when 'shell' has "csh" in the tail.
  */
 int csh_like_shell(void)
@@ -686,243 +600,6 @@ int csh_like_shell(void)
 }
 
 /*
- * Escape "string" for use as a shell argument with system().
- * This uses single quotes, except when we know we need to use double quotes
- * (MS-Windows without 'shellslash' set).
- * Escape a newline, depending on the 'shell' option.
- * When "do_special" is true also replace "!", "%", "#" and things starting
- * with "<" like "<cfile>".
- * When "do_newline" is false do not escape newline unless it is csh shell.
- * Returns the result in allocated memory.
- */
-char_u *vim_strsave_shellescape(char_u *string, bool do_special, bool do_newline)
-{
-  unsigned length;
-  char_u      *p;
-  char_u      *d;
-  char_u      *escaped_string;
-  int l;
-  int csh_like;
-
-  /* Only csh and similar shells expand '!' within single quotes.  For sh and
-   * the like we must not put a backslash before it, it will be taken
-   * literally.  If do_special is set the '!' will be escaped twice.
-   * Csh also needs to have "\n" escaped twice when do_special is set. */
-  csh_like = csh_like_shell();
-
-  /* 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)) {
-    if (*p == '\'')
-      length += 3;                      /* ' => '\'' */
-    if ((*p == '\n' && (csh_like || do_newline))
-        || (*p == '!' && (csh_like || do_special))) {
-      ++length;                         /* insert backslash */
-      if (csh_like && do_special)
-        ++length;                       /* insert backslash */
-    }
-    if (do_special && find_cmdline_var(p, &l) >= 0) {
-      ++length;                         /* insert backslash */
-      p += l - 1;
-    }
-  }
-
-  /* Allocate memory for the result and fill it. */
-  escaped_string = alloc(length);
-  d = escaped_string;
-
-  /* add opening quote */
-  *d++ = '\'';
-
-  for (p = string; *p != NUL; ) {
-    if (*p == '\'') {
-      *d++ = '\'';
-      *d++ = '\\';
-      *d++ = '\'';
-      *d++ = '\'';
-      ++p;
-      continue;
-    }
-    if ((*p == '\n' && (csh_like || do_newline))
-        || (*p == '!' && (csh_like || do_special))) {
-      *d++ = '\\';
-      if (csh_like && do_special)
-        *d++ = '\\';
-      *d++ = *p++;
-      continue;
-    }
-    if (do_special && find_cmdline_var(p, &l) >= 0) {
-      *d++ = '\\';                    /* insert backslash */
-      while (--l >= 0)                /* copy the var */
-        *d++ = *p++;
-      continue;
-    }
-
-    MB_COPY_CHAR(p, d);
-  }
-
-  /* add terminating quote and finish with a NUL */
-  *d++ = '\'';
-  *d = NUL;
-
-  return escaped_string;
-}
-
-/*
- * Like vim_strsave(), but make all characters uppercase.
- * This uses ASCII lower-to-upper case translation, language independent.
- */
-char_u *vim_strsave_up(char_u *string)
-{
-  char_u *p1;
-
-  p1 = vim_strsave(string);
-  vim_strup(p1);
-  return p1;
-}
-
-/*
- * Like vim_strnsave(), but make all characters uppercase.
- * This uses ASCII lower-to-upper case translation, language independent.
- */
-char_u *vim_strnsave_up(char_u *string, int len)
-{
-  char_u *p1;
-
-  p1 = vim_strnsave(string, len);
-  vim_strup(p1);
-  return p1;
-}
-
-/*
- * ASCII lower-to-upper case translation, language independent.
- */
-void vim_strup(char_u *p)
-{
-  char_u  *p2;
-  int c;
-
-  if (p != NULL) {
-    p2 = p;
-    while ((c = *p2) != NUL)
-      *p2++ = (c < 'a' || c > 'z') ? c : (c - 0x20);
-  }
-}
-
-/*
- * Make string "s" all upper-case and return it in allocated memory.
- * Handles multi-byte characters as well as possible.
- * Returns NULL when out of memory.
- */
-char_u *strup_save(char_u *orig)
-{
-  char_u      *p;
-  char_u      *res;
-
-  res = p = vim_strsave(orig);
-
-  if (res != NULL)
-    while (*p != NUL) {
-      int l;
-
-      if (enc_utf8) {
-        int c, uc;
-        int newl;
-        char_u  *s;
-
-        c = utf_ptr2char(p);
-        uc = utf_toupper(c);
-
-        /* Reallocate string when byte count changes.  This is rare,
-         * thus it's OK to do another malloc()/free(). */
-        l = utf_ptr2len(p);
-        newl = utf_char2len(uc);
-        if (newl != l) {
-          s = alloc((unsigned)STRLEN(res) + 1 + newl - l);
-          memmove(s, res, p - res);
-          STRCPY(s + (p - res) + newl, p + l);
-          p = s + (p - res);
-          vim_free(res);
-          res = s;
-        }
-
-        utf_char2bytes(uc, p);
-        p += newl;
-      } else if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
-        p += l;                 /* skip multi-byte character */
-      else {
-        *p = TOUPPER_LOC(*p);         /* note that toupper() can be a macro */
-        p++;
-      }
-    }
-
-  return res;
-}
-
-/*
- * copy a space a number of times
- */
-void copy_spaces(char_u *ptr, size_t count)
-{
-  size_t i = count;
-  char_u      *p = ptr;
-
-  while (i--)
-    *p++ = ' ';
-}
-
-/*
- * Copy a character a number of times.
- * Does not work for multi-byte characters!
- */
-void copy_chars(char_u *ptr, size_t count, int c)
-{
-  size_t i = count;
-  char_u      *p = ptr;
-
-  while (i--)
-    *p++ = c;
-}
-
-/*
- * delete spaces at the end of a string
- */
-void del_trailing_spaces(char_u *ptr)
-{
-  char_u      *q;
-
-  q = ptr + STRLEN(ptr);
-  while (--q > ptr && vim_iswhite(q[0]) && q[-1] != '\\' && q[-1] != Ctrl_V)
-    *q = NUL;
-}
-
-/*
- * Like strncpy(), but always terminate the result with one NUL.
- * "to" must be "len + 1" long!
- */
-void vim_strncpy(char_u *to, char_u *from, size_t len)
-{
-  STRNCPY(to, from, len);
-  to[len] = NUL;
-}
-
-/*
- * Like strcat(), but make sure the result fits in "tosize" bytes and is
- * always NUL terminated.
- */
-void vim_strcat(char_u *to, char_u *from, size_t tosize)
-{
-  size_t tolen = STRLEN(to);
-  size_t fromlen = STRLEN(from);
-
-  if (tolen + fromlen + 1 > tosize) {
-    memmove(to + tolen, from, tosize - tolen - 1);
-    to[tosize - 1] = NUL;
-  } else
-    STRCPY(to + tolen, from);
-}
-
-/*
  * Isolate one part of a string option where parts are separated with
  * "sep_chars".
  * The part is copied into "buf[maxlen]".
@@ -969,143 +646,6 @@ void vim_free(void *x)
   }
 }
 
-#if (!defined(HAVE_STRCASECMP) && !defined(HAVE_STRICMP)) || defined(PROTO)
-/*
- * Compare two strings, ignoring case, using current locale.
- * Doesn't work for multi-byte characters.
- * return 0 for match, < 0 for smaller, > 0 for bigger
- */
-int vim_stricmp(char *s1, char *s2)
-{
-  int i;
-
-  for (;; ) {
-    i = (int)TOLOWER_LOC(*s1) - (int)TOLOWER_LOC(*s2);
-    if (i != 0)
-      return i;                             /* this character different */
-    if (*s1 == NUL)
-      break;                                /* strings match until NUL */
-    ++s1;
-    ++s2;
-  }
-  return 0;                                 /* strings match */
-}
-#endif
-
-#if (!defined(HAVE_STRNCASECMP) && !defined(HAVE_STRNICMP)) || defined(PROTO)
-/*
- * Compare two strings, for length "len", ignoring case, using current locale.
- * Doesn't work for multi-byte characters.
- * return 0 for match, < 0 for smaller, > 0 for bigger
- */
-int vim_strnicmp(char *s1, char *s2, size_t len)
-{
-  int i;
-
-  while (len > 0) {
-    i = (int)TOLOWER_LOC(*s1) - (int)TOLOWER_LOC(*s2);
-    if (i != 0)
-      return i;                             /* this character different */
-    if (*s1 == NUL)
-      break;                                /* strings match until NUL */
-    ++s1;
-    ++s2;
-    --len;
-  }
-  return 0;                                 /* strings match */
-}
-#endif
-
-/*
- * Version of strchr() and strrchr() that handle unsigned char strings
- * with characters from 128 to 255 correctly.  It also doesn't return a
- * pointer to the NUL at the end of the string.
- */
-char_u *vim_strchr(char_u *string, int c)
-{
-  char_u      *p;
-  int b;
-
-  p = string;
-  if (enc_utf8 && c >= 0x80) {
-    while (*p != NUL) {
-      if (utf_ptr2char(p) == c)
-        return p;
-      p += (*mb_ptr2len)(p);
-    }
-    return NULL;
-  }
-  if (enc_dbcs != 0 && c > 255) {
-    int n2 = c & 0xff;
-
-    c = ((unsigned)c >> 8) & 0xff;
-    while ((b = *p) != NUL) {
-      if (b == c && p[1] == n2)
-        return p;
-      p += (*mb_ptr2len)(p);
-    }
-    return NULL;
-  }
-  if (has_mbyte) {
-    while ((b = *p) != NUL) {
-      if (b == c)
-        return p;
-      p += (*mb_ptr2len)(p);
-    }
-    return NULL;
-  }
-  while ((b = *p) != NUL) {
-    if (b == c)
-      return p;
-    ++p;
-  }
-  return NULL;
-}
-
-/*
- * Version of strchr() that only works for bytes and handles unsigned char
- * strings with characters above 128 correctly. It also doesn't return a
- * pointer to the NUL at the end of the string.
- */
-char_u *vim_strbyte(char_u *string, int c)
-{
-  char_u      *p = string;
-
-  while (*p != NUL) {
-    if (*p == c)
-      return p;
-    ++p;
-  }
-  return NULL;
-}
-
-/*
- * Search for last occurrence of "c" in "string".
- * Return NULL if not found.
- * Does not handle multi-byte char for "c"!
- */
-char_u *vim_strrchr(char_u *string, int c)
-{
-  char_u      *retval = NULL;
-  char_u      *p = string;
-
-  while (*p) {
-    if (*p == c)
-      retval = p;
-    mb_ptr_adv(p);
-  }
-  return retval;
-}
-
-/*
- * Vim has its own isspace() function, because on some machines isspace()
- * can't handle characters above 128.
- */
-int vim_isspace(int x)
-{
-  return (x >= 9 && x <= 13) || x == ' ';
-}
-
 /*
  * Return the current end-of-line type: EOL_DOS, EOL_UNIX or EOL_MAC.
  */
@@ -1334,21 +874,6 @@ int vim_chdir(char_u *new_dir)
   return r;
 }
 
-/*
- * Sort an array of strings.
- */
-static int
-sort_compare(const void *s1, const void *s2);
-
-static int sort_compare(const void *s1, const void *s2)
-{
-  return STRCMP(*(char **)s1, *(char **)s2);
-}
-
-void sort_strings(char_u **files, int count)
-{
-  qsort((void *)files, (size_t)count, sizeof(char_u *), sort_compare);
-}
 
 /*
  * Print an error message with one or two "%s" and one or two string arguments.
@@ -1496,23 +1021,3 @@ void put_time(FILE *fd, time_t the_time)
     }
   }
 }
-
-
-
-#if (defined(FEAT_MBYTE) && defined(FEAT_QUICKFIX)) \
-  || defined(FEAT_SPELL) || defined(PROTO)
-/*
- * Return TRUE if string "s" contains a non-ASCII character (128 or higher).
- * When "s" is NULL FALSE is returned.
- */
-int has_non_ascii(char_u *s)
-{
-  char_u      *p;
-
-  if (s != NULL)
-    for (p = s; *p != NUL; ++p)
-      if (*p >= 128)
-        return TRUE;
-  return FALSE;
-}
-#endif
diff --git a/src/misc2.h b/src/misc2.h
index e73bbfaddf..7567b11e60 100644
--- a/src/misc2.h
+++ b/src/misc2.h
@@ -24,32 +24,10 @@ void check_cursor_col_win(win_T *win);
 void check_cursor(void);
 void adjust_cursor_col(void);
 int leftcol_changed(void);
-char_u *vim_strsave(char_u *string);
-char_u *vim_strnsave(char_u *string, int len);
-char_u *vim_strsave_escaped(char_u *string, char_u *esc_chars);
-char_u *vim_strsave_escaped_ext(char_u *string, char_u *esc_chars,
-                                int cc,
-                                int bsl);
 int csh_like_shell(void);
-char_u *vim_strsave_shellescape(char_u *string, bool do_special, bool do_newline);
-char_u *vim_strsave_up(char_u *string);
-char_u *vim_strnsave_up(char_u *string, int len);
-void vim_strup(char_u *p);
-char_u *strup_save(char_u *orig);
-void copy_spaces(char_u *ptr, size_t count);
-void copy_chars(char_u *ptr, size_t count, int c);
-void del_trailing_spaces(char_u *ptr);
-void vim_strncpy(char_u *to, char_u *from, size_t len);
-void vim_strcat(char_u *to, char_u *from, size_t tosize);
 int copy_option_part(char_u **option, char_u *buf, int maxlen,
                      char *sep_chars);
 void vim_free(void *x);
-int vim_stricmp(char *s1, char *s2);
-int vim_strnicmp(char *s1, char *s2, size_t len);
-char_u *vim_strchr(char_u *string, int c);
-char_u *vim_strbyte(char_u *string, int c);
-char_u *vim_strrchr(char_u *string, int c);
-int vim_isspace(int x);
 int get_fileformat(buf_T *buf);
 int get_fileformat_force(buf_T *buf, exarg_T *eap);
 void set_fileformat(int t, int opt_flags);
@@ -59,7 +37,6 @@ int get_real_state(void);
 int vim_chdirfile(char_u *fname);
 int illegal_slash(char *name);
 int vim_chdir(char_u *new_dir);
-void sort_strings(char_u **files, int count);
 int emsg3(char_u *s, char_u *a1, char_u *a2);
 int emsgn(char_u *s, int64_t n);
 int get2c(FILE *fd);
diff --git a/src/strings.c b/src/strings.c
new file mode 100644
index 0000000000..f9c4e2f1db
--- /dev/null
+++ b/src/strings.c
@@ -0,0 +1,536 @@
+#include <string.h>
+
+#include "vim.h"
+#include "strings.h"
+#include "misc2.h"
+#include "file_search.h"
+#include "blowfish.h"
+#include "buffer.h"
+#include "charset.h"
+#include "diff.h"
+#include "edit.h"
+#include "eval.h"
+#include "ex_cmds.h"
+#include "ex_docmd.h"
+#include "ex_getln.h"
+#include "fileio.h"
+#include "fold.h"
+#include "getchar.h"
+#include "mark.h"
+#include "mbyte.h"
+#include "memfile.h"
+#include "memline.h"
+#include "memory.h"
+#include "message.h"
+#include "misc1.h"
+#include "move.h"
+#include "option.h"
+#include "ops.h"
+#include "os_unix.h"
+#include "path.h"
+#include "quickfix.h"
+#include "regexp.h"
+#include "screen.h"
+#include "search.h"
+#include "spell.h"
+#include "syntax.h"
+#include "tag.h"
+#include "term.h"
+#include "ui.h"
+#include "window.h"
+#include "os/os.h"
+#include "os/shell.h"
+
+/*
+ * Copy "string" into newly allocated memory.
+ */
+char_u *vim_strsave(char_u *string)
+{
+  char_u      *p;
+  unsigned len;
+
+  len = (unsigned)STRLEN(string) + 1;
+  p = alloc(len);
+  if (p != NULL)
+    memmove(p, string, (size_t)len);
+  return p;
+}
+
+/*
+ * Copy up to "len" bytes of "string" into newly allocated memory and
+ * terminate with a NUL.
+ * The allocated memory always has size "len + 1", also when "string" is
+ * shorter.
+ */
+char_u *vim_strnsave(char_u *string, int len)
+{
+  char_u      *p;
+
+  p = alloc((unsigned)(len + 1));
+  STRNCPY(p, string, len);
+  p[len] = NUL;
+  return p;
+}
+
+/*
+ * Same as vim_strsave(), but any characters found in esc_chars are preceded
+ * by a backslash.
+ */
+char_u *vim_strsave_escaped(char_u *string, char_u *esc_chars)
+{
+  return vim_strsave_escaped_ext(string, esc_chars, '\\', FALSE);
+}
+
+/*
+ * Same as vim_strsave_escaped(), but when "bsl" is TRUE also escape
+ * characters where rem_backslash() would remove the backslash.
+ * Escape the characters with "cc".
+ */
+char_u *vim_strsave_escaped_ext(char_u *string, char_u *esc_chars, int cc, int bsl)
+{
+  char_u      *p;
+  char_u      *p2;
+  char_u      *escaped_string;
+  unsigned length;
+  int l;
+
+  /*
+   * First count the number of backslashes required.
+   * Then allocate the memory and insert them.
+   */
+  length = 1;                           /* count the trailing NUL */
+  for (p = string; *p; p++) {
+    if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) {
+      length += l;                      /* count a multibyte char */
+      p += l - 1;
+      continue;
+    }
+    if (vim_strchr(esc_chars, *p) != NULL || (bsl && rem_backslash(p)))
+      ++length;                         /* count a backslash */
+    ++length;                           /* count an ordinary char */
+  }
+  escaped_string = alloc(length);
+  p2 = escaped_string;
+  for (p = string; *p; p++) {
+    if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) {
+      memmove(p2, p, (size_t)l);
+      p2 += l;
+      p += l - 1;                     /* skip multibyte char  */
+      continue;
+    }
+    if (vim_strchr(esc_chars, *p) != NULL || (bsl && rem_backslash(p)))
+      *p2++ = cc;
+    *p2++ = *p;
+  }
+  *p2 = NUL;
+
+  return escaped_string;
+}
+
+/*
+ * Escape "string" for use as a shell argument with system().
+ * This uses single quotes, except when we know we need to use double quotes
+ * (MS-Windows without 'shellslash' set).
+ * Escape a newline, depending on the 'shell' option.
+ * When "do_special" is true also replace "!", "%", "#" and things starting
+ * with "<" like "<cfile>".
+ * When "do_newline" is false do not escape newline unless it is csh shell.
+ * Returns the result in allocated memory.
+ */
+char_u *vim_strsave_shellescape(char_u *string, bool do_special, bool do_newline)
+{
+  unsigned length;
+  char_u      *p;
+  char_u      *d;
+  char_u      *escaped_string;
+  int l;
+  int csh_like;
+
+  /* Only csh and similar shells expand '!' within single quotes.  For sh and
+   * the like we must not put a backslash before it, it will be taken
+   * literally.  If do_special is set the '!' will be escaped twice.
+   * Csh also needs to have "\n" escaped twice when do_special is set. */
+  csh_like = csh_like_shell();
+
+  /* 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)) {
+    if (*p == '\'')
+      length += 3;                      /* ' => '\'' */
+    if ((*p == '\n' && (csh_like || do_newline))
+        || (*p == '!' && (csh_like || do_special))) {
+      ++length;                         /* insert backslash */
+      if (csh_like && do_special)
+        ++length;                       /* insert backslash */
+    }
+    if (do_special && find_cmdline_var(p, &l) >= 0) {
+      ++length;                         /* insert backslash */
+      p += l - 1;
+    }
+  }
+
+  /* Allocate memory for the result and fill it. */
+  escaped_string = alloc(length);
+  d = escaped_string;
+
+  /* add opening quote */
+  *d++ = '\'';
+
+  for (p = string; *p != NUL; ) {
+    if (*p == '\'') {
+      *d++ = '\'';
+      *d++ = '\\';
+      *d++ = '\'';
+      *d++ = '\'';
+      ++p;
+      continue;
+    }
+    if ((*p == '\n' && (csh_like || do_newline))
+        || (*p == '!' && (csh_like || do_special))) {
+      *d++ = '\\';
+      if (csh_like && do_special)
+        *d++ = '\\';
+      *d++ = *p++;
+      continue;
+    }
+    if (do_special && find_cmdline_var(p, &l) >= 0) {
+      *d++ = '\\';                    /* insert backslash */
+      while (--l >= 0)                /* copy the var */
+        *d++ = *p++;
+      continue;
+    }
+
+    MB_COPY_CHAR(p, d);
+  }
+
+  /* add terminating quote and finish with a NUL */
+  *d++ = '\'';
+  *d = NUL;
+
+  return escaped_string;
+}
+
+/*
+ * Like vim_strsave(), but make all characters uppercase.
+ * This uses ASCII lower-to-upper case translation, language independent.
+ */
+char_u *vim_strsave_up(char_u *string)
+{
+  char_u *p1;
+
+  p1 = vim_strsave(string);
+  vim_strup(p1);
+  return p1;
+}
+
+/*
+ * Like vim_strnsave(), but make all characters uppercase.
+ * This uses ASCII lower-to-upper case translation, language independent.
+ */
+char_u *vim_strnsave_up(char_u *string, int len)
+{
+  char_u *p1;
+
+  p1 = vim_strnsave(string, len);
+  vim_strup(p1);
+  return p1;
+}
+
+/*
+ * ASCII lower-to-upper case translation, language independent.
+ */
+void vim_strup(char_u *p)
+{
+  char_u  *p2;
+  int c;
+
+  if (p != NULL) {
+    p2 = p;
+    while ((c = *p2) != NUL)
+      *p2++ = (c < 'a' || c > 'z') ? c : (c - 0x20);
+  }
+}
+
+/*
+ * Make string "s" all upper-case and return it in allocated memory.
+ * Handles multi-byte characters as well as possible.
+ * Returns NULL when out of memory.
+ */
+char_u *strup_save(char_u *orig)
+{
+  char_u      *p;
+  char_u      *res;
+
+  res = p = vim_strsave(orig);
+
+  if (res != NULL)
+    while (*p != NUL) {
+      int l;
+
+      if (enc_utf8) {
+        int c, uc;
+        int newl;
+        char_u  *s;
+
+        c = utf_ptr2char(p);
+        uc = utf_toupper(c);
+
+        /* Reallocate string when byte count changes.  This is rare,
+         * thus it's OK to do another malloc()/free(). */
+        l = utf_ptr2len(p);
+        newl = utf_char2len(uc);
+        if (newl != l) {
+          s = alloc((unsigned)STRLEN(res) + 1 + newl - l);
+          memmove(s, res, p - res);
+          STRCPY(s + (p - res) + newl, p + l);
+          p = s + (p - res);
+          vim_free(res);
+          res = s;
+        }
+
+        utf_char2bytes(uc, p);
+        p += newl;
+      } else if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
+        p += l;                 /* skip multi-byte character */
+      else {
+        *p = TOUPPER_LOC(*p);         /* note that toupper() can be a macro */
+        p++;
+      }
+    }
+
+  return res;
+}
+
+/*
+ * copy a space a number of times
+ */
+void copy_spaces(char_u *ptr, size_t count)
+{
+  size_t i = count;
+  char_u      *p = ptr;
+
+  while (i--)
+    *p++ = ' ';
+}
+
+/*
+ * Copy a character a number of times.
+ * Does not work for multi-byte characters!
+ */
+void copy_chars(char_u *ptr, size_t count, int c)
+{
+  size_t i = count;
+  char_u      *p = ptr;
+
+  while (i--)
+    *p++ = c;
+}
+
+/*
+ * delete spaces at the end of a string
+ */
+void del_trailing_spaces(char_u *ptr)
+{
+  char_u      *q;
+
+  q = ptr + STRLEN(ptr);
+  while (--q > ptr && vim_iswhite(q[0]) && q[-1] != '\\' && q[-1] != Ctrl_V)
+    *q = NUL;
+}
+
+/*
+ * Like strncpy(), but always terminate the result with one NUL.
+ * "to" must be "len + 1" long!
+ */
+void vim_strncpy(char_u *to, char_u *from, size_t len)
+{
+  STRNCPY(to, from, len);
+  to[len] = NUL;
+}
+
+/*
+ * Like strcat(), but make sure the result fits in "tosize" bytes and is
+ * always NUL terminated.
+ */
+void vim_strcat(char_u *to, char_u *from, size_t tosize)
+{
+  size_t tolen = STRLEN(to);
+  size_t fromlen = STRLEN(from);
+
+  if (tolen + fromlen + 1 > tosize) {
+    memmove(to + tolen, from, tosize - tolen - 1);
+    to[tosize - 1] = NUL;
+  } else
+    STRCPY(to + tolen, from);
+}
+
+#if (!defined(HAVE_STRCASECMP) && !defined(HAVE_STRICMP)) || defined(PROTO)
+/*
+ * Compare two strings, ignoring case, using current locale.
+ * Doesn't work for multi-byte characters.
+ * return 0 for match, < 0 for smaller, > 0 for bigger
+ */
+int vim_stricmp(char *s1, char *s2)
+{
+  int i;
+
+  for (;; ) {
+    i = (int)TOLOWER_LOC(*s1) - (int)TOLOWER_LOC(*s2);
+    if (i != 0)
+      return i;                             /* this character different */
+    if (*s1 == NUL)
+      break;                                /* strings match until NUL */
+    ++s1;
+    ++s2;
+  }
+  return 0;                                 /* strings match */
+}
+#endif
+
+#if (!defined(HAVE_STRNCASECMP) && !defined(HAVE_STRNICMP)) || defined(PROTO)
+/*
+ * Compare two strings, for length "len", ignoring case, using current locale.
+ * Doesn't work for multi-byte characters.
+ * return 0 for match, < 0 for smaller, > 0 for bigger
+ */
+int vim_strnicmp(char *s1, char *s2, size_t len)
+{
+  int i;
+
+  while (len > 0) {
+    i = (int)TOLOWER_LOC(*s1) - (int)TOLOWER_LOC(*s2);
+    if (i != 0)
+      return i;                             /* this character different */
+    if (*s1 == NUL)
+      break;                                /* strings match until NUL */
+    ++s1;
+    ++s2;
+    --len;
+  }
+  return 0;                                 /* strings match */
+}
+#endif
+
+/*
+ * Version of strchr() and strrchr() that handle unsigned char strings
+ * with characters from 128 to 255 correctly.  It also doesn't return a
+ * pointer to the NUL at the end of the string.
+ */
+char_u *vim_strchr(char_u *string, int c)
+{
+  char_u      *p;
+  int b;
+
+  p = string;
+  if (enc_utf8 && c >= 0x80) {
+    while (*p != NUL) {
+      if (utf_ptr2char(p) == c)
+        return p;
+      p += (*mb_ptr2len)(p);
+    }
+    return NULL;
+  }
+  if (enc_dbcs != 0 && c > 255) {
+    int n2 = c & 0xff;
+
+    c = ((unsigned)c >> 8) & 0xff;
+    while ((b = *p) != NUL) {
+      if (b == c && p[1] == n2)
+        return p;
+      p += (*mb_ptr2len)(p);
+    }
+    return NULL;
+  }
+  if (has_mbyte) {
+    while ((b = *p) != NUL) {
+      if (b == c)
+        return p;
+      p += (*mb_ptr2len)(p);
+    }
+    return NULL;
+  }
+  while ((b = *p) != NUL) {
+    if (b == c)
+      return p;
+    ++p;
+  }
+  return NULL;
+}
+
+/*
+ * Version of strchr() that only works for bytes and handles unsigned char
+ * strings with characters above 128 correctly. It also doesn't return a
+ * pointer to the NUL at the end of the string.
+ */
+char_u *vim_strbyte(char_u *string, int c)
+{
+  char_u      *p = string;
+
+  while (*p != NUL) {
+    if (*p == c)
+      return p;
+    ++p;
+  }
+  return NULL;
+}
+
+/*
+ * Search for last occurrence of "c" in "string".
+ * Return NULL if not found.
+ * Does not handle multi-byte char for "c"!
+ */
+char_u *vim_strrchr(char_u *string, int c)
+{
+  char_u      *retval = NULL;
+  char_u      *p = string;
+
+  while (*p) {
+    if (*p == c)
+      retval = p;
+    mb_ptr_adv(p);
+  }
+  return retval;
+}
+
+/*
+ * Vim has its own isspace() function, because on some machines isspace()
+ * can't handle characters above 128.
+ */
+int vim_isspace(int x)
+{
+  return (x >= 9 && x <= 13) || x == ' ';
+}
+
+/*
+ * Sort an array of strings.
+ */
+static int
+sort_compare(const void *s1, const void *s2);
+
+static int sort_compare(const void *s1, const void *s2)
+{
+  return STRCMP(*(char **)s1, *(char **)s2);
+}
+
+void sort_strings(char_u **files, int count)
+{
+  qsort((void *)files, (size_t)count, sizeof(char_u *), sort_compare);
+}
+
+#if (defined(FEAT_MBYTE) && defined(FEAT_QUICKFIX)) \
+  || defined(FEAT_SPELL) || defined(PROTO)
+/*
+ * Return TRUE if string "s" contains a non-ASCII character (128 or higher).
+ * When "s" is NULL FALSE is returned.
+ */
+int has_non_ascii(char_u *s)
+{
+  char_u      *p;
+
+  if (s != NULL)
+    for (p = s; *p != NUL; ++p)
+      if (*p >= 128)
+        return TRUE;
+  return FALSE;
+}
+#endif
diff --git a/src/strings.h b/src/strings.h
new file mode 100644
index 0000000000..bd34d870ea
--- /dev/null
+++ b/src/strings.h
@@ -0,0 +1,26 @@
+#ifndef NEOVIM_STRINGS_H
+#define NEOVIM_STRINGS_H
+char_u *vim_strsave(char_u *string);
+char_u *vim_strnsave(char_u *string, int len);
+char_u *vim_strsave_escaped(char_u *string, char_u *esc_chars);
+char_u *vim_strsave_escaped_ext(char_u *string, char_u *esc_chars,
+                                int cc,
+                                int bsl);
+char_u *vim_strsave_shellescape(char_u *string, bool do_special, bool do_newline);
+char_u *vim_strsave_up(char_u *string);
+char_u *vim_strnsave_up(char_u *string, int len);
+void vim_strup(char_u *p);
+char_u *strup_save(char_u *orig);
+void copy_spaces(char_u *ptr, size_t count);
+void copy_chars(char_u *ptr, size_t count, int c);
+void del_trailing_spaces(char_u *ptr);
+void vim_strncpy(char_u *to, char_u *from, size_t len);
+void vim_strcat(char_u *to, char_u *from, size_t tosize);
+int vim_stricmp(char *s1, char *s2);
+int vim_strnicmp(char *s1, char *s2, size_t len);
+char_u *vim_strchr(char_u *string, int c);
+char_u *vim_strbyte(char_u *string, int c);
+char_u *vim_strrchr(char_u *string, int c);
+int vim_isspace(int x);
+void sort_strings(char_u **files, int count);
+#endif