Merge pull request #5761 from jamessan/vim-7.4.1752

Catchup with upstream quickfix patches

13 files changed, 2332 insertions, 1255 deletions

diff --git a/runtime/doc/index.txt b/runtime/doc/index.txt
index bd2df5d1e5..1f4557fe30 100644
--- a/runtime/doc/index.txt
+++ b/runtime/doc/index.txt
@@ -1129,6 +1129,7 @@ tag	      command	      action ~
 |:caddfile|	:caddf[ile]	add error message to current quickfix list
 |:call|		:cal[l]		call a function
 |:catch|	:cat[ch]	part of a :try command
+|:cbottom|	:cbo[ttom]	scroll to the bottom of the quickfix window
 |:cbuffer|	:cb[uffer]	parse error messages and jump to first error
 |:cc|		:cc		go to specific error
 |:cclose|	:ccl[ose]	close quickfix window
@@ -1286,6 +1287,7 @@ tag	      command	      action ~
 |:last|		:la[st]		go to the last file in the argument list
 |:language|	:lan[guage]	set the language (locale)
 |:later|	:lat[er]	go to newer change, redo
+|:lbottom|	:lbo[ttom]	scroll to the bottom of the location window
 |:lbuffer|	:lb[uffer]	parse locations and jump to first location
 |:lcd|		:lc[d]		change directory locally
 |:lchdir|	:lch[dir]	change directory locally
diff --git a/runtime/doc/quickfix.txt b/runtime/doc/quickfix.txt
index 7c1fc30eba..cbb2a23a48 100644
--- a/runtime/doc/quickfix.txt
+++ b/runtime/doc/quickfix.txt
@@ -1,4 +1,4 @@
-*quickfix.txt*  For Vim version 7.4.  Last change: 2016 Jul 01
+*quickfix.txt*  For Vim version 7.4.  Last change: 2016 Jul 07
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -428,6 +428,17 @@ EXECUTE A COMMAND IN ALL THE BUFFERS IN QUICKFIX OR LOCATION LIST:
 :lw[indow] [height]	Same as ":cwindow", except use the window showing the
 			location list for the current window.
 
+							*:cbo* *:cbottom*
+:cbo[ttom]		Put the cursor in the last line of the quickfix window
+			and scroll to make it visible.  This is useful for
+			when errors are added by an asynchronous callback.
+			Only call it once in a while if there are many
+			updates to avoid a lot of redrawing.
+
+							*:lbo* *:lbottom*
+:lbo[ttom]		Same as ":cbottom", except use the window showing the
+			location list for the current window.
+
 Normally the quickfix window is at the bottom of the screen.  If there are
 vertical splits, it's at the bottom of the rightmost column of windows.  To
 make it always occupy the full width: >
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 2f0e8ad974..0418a737eb 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -609,6 +609,7 @@ struct file_buffer {
   int b_p_bomb;                 ///< 'bomb'
   char_u *b_p_bh;               ///< 'bufhidden'
   char_u *b_p_bt;               ///< 'buftype'
+  bool b_has_qf_entry;          ///< quickfix exists for buffer
   int b_p_bl;                   ///< 'buflisted'
   int b_p_cin;                  ///< 'cindent'
   char_u *b_p_cino;             ///< 'cinoptions'
@@ -1036,11 +1037,11 @@ struct window_S {
    */
   int w_wrow, w_wcol;               /* cursor position in window */
 
-  linenr_T w_botline;               /* number of the line below the bottom of
-                                       the screen */
-  int w_empty_rows;                 /* number of ~ rows in window */
-  int w_filler_rows;                /* number of filler rows at the end of the
-                                       window */
+  linenr_T w_botline;               // number of the line below the bottom of
+                                    // the window
+  int w_empty_rows;                 // number of ~ rows in window
+  int w_filler_rows;                // number of filler rows at the end of the
+                                    // window
 
   /*
    * Info about the lines currently in the window is remembered to avoid
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 39e121eb53..bdbd77337d 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -158,7 +158,7 @@ static char *e_listdictarg = N_(
 static char *e_emptykey = N_("E713: Cannot use empty key for Dictionary");
 static char *e_listreq = N_("E714: List required");
 static char *e_dictreq = N_("E715: Dictionary required");
-static char *e_strreq = N_("E114: String required");
+static char *e_stringreq = N_("E928: String required");
 static char *e_toomanyarg = N_("E118: Too many arguments for function: %s");
 static char *e_dictkey = N_("E716: Key not present in Dictionary: %s");
 static char *e_funcexts = N_(
@@ -14996,6 +14996,7 @@ static void f_setline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void set_qf_ll_list(win_T *wp, typval_T *args, typval_T *rettv)
   FUNC_ATTR_NONNULL_ARG(2, 3)
 {
+  static char *e_invact = N_("E927: Invalid action: '%s'");
   char_u *title = NULL;
   int action = ' ';
   rettv->vval.v_number = -1;
@@ -15011,12 +15012,15 @@ static void set_qf_ll_list(win_T *wp, typval_T *args, typval_T *rettv)
     // Option argument was not given.
     goto skip_args;
   } else if (action_arg->v_type != VAR_STRING) {
-    EMSG(_(e_strreq));
+    EMSG(_(e_stringreq));
     return;
   }
   char_u *act = get_tv_string_chk(action_arg);
-  if (*act == 'a' || *act == 'r') {
+  if ((*act == 'a' || *act == 'r' || *act == ' ') && act[1] == NUL) {
     action = *act;
+  } else {
+    EMSG2(_(e_invact), act);
+    return;
   }
 
   typval_T *title_arg = &args[2];
diff --git a/src/nvim/ex_cmds.lua b/src/nvim/ex_cmds.lua
index b056fff667..b998b81284 100644
--- a/src/nvim/ex_cmds.lua
+++ b/src/nvim/ex_cmds.lua
@@ -358,6 +358,12 @@ return {
     func='ex_cbuffer',
   },
   {
+    command='cbottom',
+    flags=bit.bor(TRLBAR),
+    addr_type=ADDR_LINES,
+    func='ex_cbottom',
+  },
+  {
     command='cc',
     flags=bit.bor(RANGE, NOTADR, COUNT, TRLBAR, BANG),
     addr_type=ADDR_LINES,
@@ -1272,6 +1278,12 @@ return {
     func='ex_cbuffer',
   },
   {
+    command='lbottom',
+    flags=bit.bor(TRLBAR),
+    addr_type=ADDR_LINES,
+    func='ex_cbottom',
+  },
+  {
     command='lcd',
     flags=bit.bor(BANG, FILE1, TRLBAR, CMDWIN),
     addr_type=ADDR_LINES,
diff --git a/src/nvim/po/uk.po b/src/nvim/po/uk.po
index bbbb462292..3145931bfe 100644
--- a/src/nvim/po/uk.po
+++ b/src/nvim/po/uk.po
@@ -564,8 +564,8 @@ msgstr "E714: Потрібен список"
 msgid "E715: Dictionary required"
 msgstr "E715: Потрібен словник"
 
-msgid "E114: String required"
-msgstr "E114: Потрібен String"
+msgid "E928: String required"
+msgstr "E928: Потрібен String"
 
 #, c-format
 msgid "E118: Too many arguments for function: %s"
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index f0d77f9e2b..33a84660c1 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -48,8 +48,6 @@ struct dir_stack_T {
   char_u              *dirname;
 };
 
-static struct dir_stack_T   *dir_stack = NULL;
-
 /*
  * For each error the next struct is allocated and linked in a list.
  */
@@ -76,13 +74,14 @@ struct qfline_S {
 #define LISTCOUNT   10
 
 typedef struct qf_list_S {
-  qfline_T    *qf_start;        /* pointer to the first error */
-  qfline_T    *qf_ptr;          /* pointer to the current error */
-  int qf_count;                 /* number of errors (0 means no error list) */
-  int qf_index;                 /* current index in the error list */
-  int qf_nonevalid;             /* TRUE if not a single valid entry found */
-  char_u      *qf_title;        /* title derived from the command that created
-                                 * the error list */
+  qfline_T    *qf_start;        // pointer to the first error
+  qfline_T    *qf_last;         // pointer to the last error
+  qfline_T    *qf_ptr;          // pointer to the current error
+  int qf_count;                 // number of errors (0 means no error list)
+  int qf_index;                 // current index in the error list
+  int qf_nonevalid;             // TRUE if not a single valid entry found
+  char_u      *qf_title;        // title derived from the command that created
+                                // the error list
 } qf_list_T;
 
 struct qf_info_S {
@@ -96,6 +95,15 @@ struct qf_info_S {
   int qf_listcount;                 /* current number of lists */
   int qf_curlist;                   /* current error list */
   qf_list_T qf_lists[LISTCOUNT];
+
+  int qf_dir_curlist;  ///< error list for qf_dir_stack
+  struct dir_stack_T *qf_dir_stack;
+  char_u *qf_directory;
+  struct dir_stack_T *qf_file_stack;
+  char_u *qf_currfile;
+  bool qf_multiline;
+  bool qf_multiignore;
+  bool qf_multiscan;
 };
 
 static qf_info_T ql_info;       /* global quickfix list */
@@ -168,17 +176,268 @@ qf_init (
       qf_title);
 }
 
-/*
- * Read the errorfile "efile" into memory, line by line, building the error
- * list.
- * Alternative: when "efile" is null read errors from buffer "buf".
- * Always use 'errorformat' from "buf" if there is a local value.
- * Then "lnumfirst" and "lnumlast" specify the range of lines to use.
- * Set the title of the list to "qf_title".
- * Return -1 for error, number of errors for success.
- */
-static int 
-qf_init_ext (
+// Maximum number of bytes allowed per line while reading an errorfile.
+static const size_t LINE_MAXLEN = 4096;
+
+static char_u *qf_grow_linebuf(char_u **growbuf, size_t *growbufsiz,
+                               size_t newsz, size_t *allocsz)
+{
+  // If the line exceeds LINE_MAXLEN exclude the last
+  // byte since it's not a NL character.
+  *allocsz = newsz > LINE_MAXLEN ? LINE_MAXLEN - 1 : newsz;
+  if (*growbuf == NULL) {
+    *growbuf = xmalloc(*allocsz + 1);
+    *growbufsiz = *allocsz;
+  } else if (*allocsz > *growbufsiz) {
+    *growbuf = xrealloc(*growbuf, *allocsz + 1);
+    *growbufsiz = *allocsz;
+  }
+  return *growbuf;
+}
+
+static struct fmtpattern
+{
+  char_u convchar;
+  char *pattern;
+} fmt_pat[FMT_PATTERNS] =
+{
+  { 'f', ".\\+" },  // only used when at end
+  { 'n', "\\d\\+" },
+  { 'l', "\\d\\+" },
+  { 'c', "\\d\\+" },
+  { 't', "." },
+  { 'm', ".\\+" },
+  { 'r', ".*" },
+  { 'p', "[- 	.]*" },  // NOLINT(whitespace/tab)
+  { 'v', "\\d\\+" },
+  { 's', ".\\+" }
+};
+
+// Converts a 'errorformat' string to regular expression pattern
+static int efm_to_regpat(char_u *efm, int len, efm_T *fmt_ptr,
+                         char_u *regpat, char_u *errmsg)
+{
+  // Build regexp pattern from current 'errorformat' option
+  char_u *ptr = regpat;
+  *ptr++ = '^';
+  int round = 0;
+  for (char_u *efmp = efm; efmp < efm + len; efmp++) {
+    if (*efmp == '%') {
+      efmp++;
+      int idx;
+      for (idx = 0; idx < FMT_PATTERNS; idx++) {
+        if (fmt_pat[idx].convchar == *efmp) {
+          break;
+        }
+      }
+      if (idx < FMT_PATTERNS) {
+        if (fmt_ptr->addr[idx]) {
+          snprintf((char *)errmsg, CMDBUFFSIZE + 1,
+                   _("E372: Too many %%%c in format string"), *efmp);
+          EMSG(errmsg);
+          return -1;
+        }
+        if ((idx
+             && idx < 6
+             && vim_strchr((char_u *)"DXOPQ", fmt_ptr->prefix) != NULL)
+            || (idx == 6
+                && vim_strchr((char_u *)"OPQ", fmt_ptr->prefix) == NULL)) {
+          snprintf((char *)errmsg, CMDBUFFSIZE + 1,
+                   _("E373: Unexpected %%%c in format string"), *efmp);
+          EMSG(errmsg);
+          return -1;
+        }
+        round++;
+        fmt_ptr->addr[idx] = (char_u)round;
+        *ptr++ = '\\';
+        *ptr++ = '(';
+#ifdef BACKSLASH_IN_FILENAME
+        if (*efmp == 'f') {
+          // Also match "c:" in the file name, even when
+          // checking for a colon next: "%f:".
+          // "\%(\a:\)\="
+          STRCPY(ptr, "\\%(\\a:\\)\\=");
+          ptr += 10;
+        }
+#endif
+        if (*efmp == 'f' && efmp[1] != NUL) {
+          if (efmp[1] != '\\' && efmp[1] != '%') {
+            // A file name may contain spaces, but this isn't
+            // in "\f".  For "%f:%l:%m" there may be a ":" in
+            // the file name.  Use ".\{-1,}x" instead (x is
+            // the next character), the requirement that :999:
+            // follows should work.
+            STRCPY(ptr, ".\\{-1,}");
+            ptr += 7;
+          } else {
+            // File name followed by '\\' or '%': include as
+            // many file name chars as possible.
+            STRCPY(ptr, "\\f\\+");
+            ptr += 4;
+          }
+        } else {
+          char_u *srcptr = (char_u *)fmt_pat[idx].pattern;
+          while ((*ptr = *srcptr++) != NUL) {
+            ptr++;
+          }
+        }
+        *ptr++ = '\\';
+        *ptr++ = ')';
+      } else if (*efmp == '*') {
+        if (*++efmp == '[' || *efmp == '\\') {
+          if ((*ptr++ = *efmp) == '[') {  // %*[^a-z0-9] etc.
+            if (efmp[1] == '^') {
+              *ptr++ = *++efmp;
+            }
+            if (efmp < efm + len) {
+              efmp++;
+              *ptr++ = *efmp;    // could be ']'
+              while (efmp < efm + len) {
+                efmp++;
+                if ((*ptr++ = *efmp) == ']') {
+                  break;
+                }
+              }
+              if (efmp == efm + len) {
+                EMSG(_("E374: Missing ] in format string"));
+                return -1;
+              }
+            }
+          } else if (efmp < efm + len) {  // %*\D, %*\s etc.
+            efmp++;
+            *ptr++ = *efmp;
+          }
+          *ptr++ = '\\';
+          *ptr++ = '+';
+        } else {
+          // TODO(vim): scanf()-like: %*ud, %*3c, %*f, ... ?
+          snprintf((char *)errmsg, CMDBUFFSIZE + 1,
+                   _("E375: Unsupported %%%c in format string"), *efmp);
+          EMSG(errmsg);
+          return -1;
+        }
+      } else if (vim_strchr((char_u *)"%\\.^$~[", *efmp) != NULL) {
+        *ptr++ = *efmp;  // regexp magic characters
+      } else if (*efmp == '#') {
+        *ptr++ = '*';
+      } else if (*efmp == '>') {
+        fmt_ptr->conthere = true;
+      } else if (efmp == efm + 1) {             // analyse prefix
+        if (vim_strchr((char_u *)"+-", *efmp) != NULL) {
+          fmt_ptr->flags = *efmp++;
+        }
+        if (vim_strchr((char_u *)"DXAEWICZGOPQ", *efmp) != NULL) {
+          fmt_ptr->prefix = *efmp;
+        } else {
+          snprintf((char *)errmsg, CMDBUFFSIZE + 1,
+                   _("E376: Invalid %%%c in format string prefix"), *efmp);
+          EMSG(errmsg);
+          return -1;
+        }
+      } else {
+        snprintf((char *)errmsg, CMDBUFFSIZE + 1,
+                 _("E377: Invalid %%%c in format string"), *efmp);
+        EMSG(errmsg);
+        return -1;
+      }
+    } else {                    // copy normal character
+      if (*efmp == '\\' && efmp + 1 < efm + len) {
+        efmp++;
+      } else if (vim_strchr((char_u *)".*^$~[", *efmp) != NULL) {
+        *ptr++ = '\\';  // escape regexp atoms
+      }
+      if (*efmp) {
+        *ptr++ = *efmp;
+      }
+    }
+  }
+  *ptr++ = '$';
+  *ptr = NUL;
+
+  return 0;
+}
+
+static void free_efm_list(efm_T **efm_first)
+{
+  for (efm_T *efm_ptr = *efm_first; efm_ptr != NULL; efm_ptr = *efm_first) {
+    *efm_first = efm_ptr->next;
+    vim_regfree(efm_ptr->prog);
+    xfree(efm_ptr);
+  }
+}
+
+// Parse 'errorformat' option
+static efm_T * parse_efm_option(char_u *efm)
+{
+  efm_T *fmt_ptr = NULL;
+  efm_T *fmt_first = NULL;
+  efm_T *fmt_last = NULL;
+  int len;
+
+  size_t errmsglen = CMDBUFFSIZE + 1;
+  char_u *errmsg = xmalloc(errmsglen);
+
+  // Get some space to modify the format string into.
+  size_t i = (FMT_PATTERNS * 3) + (STRLEN(efm) << 2);
+  for (int round = FMT_PATTERNS - 1; round >= 0; ) {
+    i += STRLEN(fmt_pat[round--].pattern);
+  }
+  i += 2;   // "%f" can become two chars longer
+  char_u *fmtstr = xmalloc(i);
+
+  while (efm[0] != NUL) {
+    // Allocate a new eformat structure and put it at the end of the list
+    fmt_ptr = (efm_T *)xcalloc(1, sizeof(efm_T));
+    if (fmt_first == NULL) {        // first one
+      fmt_first = fmt_ptr;
+    } else {
+      fmt_last->next = fmt_ptr;
+    }
+    fmt_last = fmt_ptr;
+
+    // Isolate one part in the 'errorformat' option
+    for (len = 0; efm[len] != NUL && efm[len] != ','; len++) {
+      if (efm[len] == '\\' && efm[len + 1] != NUL) {
+        len++;
+      }
+    }
+
+    if (efm_to_regpat(efm, len, fmt_ptr, fmtstr, errmsg) == -1) {
+      goto parse_efm_error;
+    }
+    if ((fmt_ptr->prog = vim_regcomp(fmtstr, RE_MAGIC + RE_STRING)) == NULL) {
+      goto parse_efm_error;
+    }
+    // Advance to next part
+    efm = skip_to_option_part(efm + len);       // skip comma and spaces
+  }
+
+  if (fmt_first == NULL) {      // nothing found
+    EMSG(_("E378: 'errorformat' contains no pattern"));
+  }
+
+  goto parse_efm_end;
+
+parse_efm_error:
+  free_efm_list(&fmt_first);
+
+parse_efm_end:
+  xfree(fmtstr);
+  xfree(errmsg);
+
+  return fmt_first;
+}
+
+// Read the errorfile "efile" into memory, line by line, building the error
+// list.
+// Alternative: when "efile" is NULL read errors from buffer "buf".
+// Alternative: when "tv" is not NULL get errors from the string or list.
+// Always use 'errorformat' from "buf" if there is a local value.
+// Then "lnumfirst" and "lnumlast" specify the range of lines to use.
+// Set the title of the list to "qf_title".
+// Return -1 for error, number of errors for success.
+static int
+qf_init_ext(
     qf_info_T *qi,
     char_u *efile,
     buf_T *buf,
@@ -192,8 +451,14 @@ qf_init_ext (
 {
   char_u          *namebuf;
   char_u          *errmsg;
+  size_t          errmsglen;
   char_u          *pattern;
-  char_u          *fmtstr = NULL;
+  char_u          *growbuf = NULL;
+  size_t          growbuflen;
+  size_t          growbufsiz = 0;
+  char_u          *linebuf = NULL;
+  size_t          linelen = 0;
+  bool            discard;
   int col = 0;
   bool use_viscol = false;
   char_u type = 0;
@@ -201,49 +466,25 @@ qf_init_ext (
   long lnum = 0L;
   int enr = 0;
   FILE            *fd = NULL;
-  qfline_T        *qfprev = NULL;       /* init to make SASC shut up */
-  char_u          *efmp;
-  efm_T           *fmt_first = NULL;
-  efm_T           *fmt_last = NULL;
+  qfline_T        *old_last = NULL;
+  static efm_T    *fmt_first = NULL;
   efm_T           *fmt_ptr;
   efm_T           *fmt_start = NULL;
   char_u          *efm;
-  char_u          *ptr;
-  char_u          *srcptr;
-  int len;
+  static char_u   *last_efm = NULL;
+  size_t len;
   int i;
-  int round;
   int idx = 0;
-  bool multiline = false;
-  bool multiignore = false;
-  bool multiscan = false;
   int retval = -1;                      // default: return error flag
-  char_u *directory = NULL;
-  char_u *currfile = NULL;
   char_u *tail = NULL;
+  char_u *p_buf = NULL;
   char_u *p_str = NULL;
   listitem_T *p_li = NULL;
-  struct dir_stack_T *file_stack = NULL;
   regmatch_T regmatch;
-  static struct fmtpattern {
-    char_u convchar;
-    char    *pattern;
-  }               fmt_pat[FMT_PATTERNS] =
-  {
-    {'f', ".\\+"},                          /* only used when at end */
-    {'n', "\\d\\+"},
-    {'l', "\\d\\+"},
-    {'c', "\\d\\+"},
-    {'t', "."},
-    {'m', ".\\+"},
-    {'r', ".*"},
-    {'p', "[- 	.]*"},
-    {'v', "\\d\\+"},
-    {'s', ".\\+"}
-  };
 
   namebuf = xmalloc(CMDBUFFSIZE + 1);
-  errmsg = xmalloc(CMDBUFFSIZE + 1);
+  errmsglen = CMDBUFFSIZE + 1;
+  errmsg = xmalloc(errmsglen);
   pattern = xmalloc(CMDBUFFSIZE + 1);
 
   if (efile != NULL && (fd = mch_fopen((char *)efile, "r")) == NULL) {
@@ -251,14 +492,13 @@ qf_init_ext (
     goto qf_init_end;
   }
 
-  if (newlist || qi->qf_curlist == qi->qf_listcount)
-    /* make place for a new list */
+  if (newlist || qi->qf_curlist == qi->qf_listcount) {
+    // make place for a new list
     qf_new_list(qi, qf_title);
-  else if (qi->qf_lists[qi->qf_curlist].qf_count > 0)
-    /* Adding to existing list, find last entry. */
-    for (qfprev = qi->qf_lists[qi->qf_curlist].qf_start;
-         qfprev->qf_next != qfprev; qfprev = qfprev->qf_next)
-      ;
+  } else if (qi->qf_lists[qi->qf_curlist].qf_count > 0) {
+    // Adding to existing list, use last entry.
+    old_last = qi->qf_lists[qi->qf_curlist].qf_last;
+  }
 
   /*
    * Each part of the format string is copied and modified from errorformat to
@@ -269,172 +509,35 @@ qf_init_ext (
     efm = buf->b_p_efm;
   else
     efm = errorformat;
-  /*
-   * Get some space to modify the format string into.
-   */
-  size_t fmtstr_size = 3 * FMT_PATTERNS + 4 * STRLEN(efm);
-  for (round = FMT_PATTERNS; round > 0; ) {
-    fmtstr_size += STRLEN(fmt_pat[--round].pattern);
-  }
-#ifdef COLON_IN_FILENAME
-  fmtstr_size += 12;  // "%f" can become twelve chars longer
-#else
-  fmtstr_size += 2;   // "%f" can become two chars longer
-#endif
-  fmtstr = xmalloc(fmtstr_size);
 
-  while (efm[0] != NUL) {
-    /*
-     * Allocate a new eformat structure and put it at the end of the list
-     */
-    fmt_ptr = xcalloc(1, sizeof(efm_T));
-    if (fmt_first == NULL)          /* first one */
-      fmt_first = fmt_ptr;
-    else
-      fmt_last->next = fmt_ptr;
-    fmt_last = fmt_ptr;
-
-    /*
-     * Isolate one part in the 'errorformat' option
-     */
-    for (len = 0; efm[len] != NUL && efm[len] != ','; ++len)
-      if (efm[len] == '\\' && efm[len + 1] != NUL)
-        ++len;
+  // If we are not adding or adding to another list: clear the state.
+  if (newlist || qi->qf_curlist != qi->qf_dir_curlist) {
+    qi->qf_dir_curlist = qi->qf_curlist;
+    qf_clean_dir_stack(&qi->qf_dir_stack);
+    qi->qf_directory = NULL;
+    qf_clean_dir_stack(&qi->qf_file_stack);
+    qi->qf_currfile = NULL;
+    qi->qf_multiline = false;
+    qi->qf_multiignore = false;
+    qi->qf_multiscan = false;
+  }
 
-    /*
-     * Build regexp pattern from current 'errorformat' option
-     */
-    ptr = fmtstr;
-    *ptr++ = '^';
-    round = 0;
-    for (efmp = efm; efmp < efm + len; ++efmp) {
-      if (*efmp == '%') {
-        ++efmp;
-        for (idx = 0; idx < FMT_PATTERNS; ++idx)
-          if (fmt_pat[idx].convchar == *efmp)
-            break;
-        if (idx < FMT_PATTERNS) {
-          if (fmt_ptr->addr[idx]) {
-            sprintf((char *)errmsg,
-                _("E372: Too many %%%c in format string"), *efmp);
-            EMSG(errmsg);
-            goto error2;
-          }
-          if ((idx
-               && idx < 6
-               && vim_strchr((char_u *)"DXOPQ",
-                   fmt_ptr->prefix) != NULL)
-              || (idx == 6
-                  && vim_strchr((char_u *)"OPQ",
-                      fmt_ptr->prefix) == NULL)) {
-            sprintf((char *)errmsg,
-                _("E373: Unexpected %%%c in format string"), *efmp);
-            EMSG(errmsg);
-            goto error2;
-          }
-          fmt_ptr->addr[idx] = (char_u)++ round;
-          *ptr++ = '\\';
-          *ptr++ = '(';
-#ifdef BACKSLASH_IN_FILENAME
-          if (*efmp == 'f') {
-            /* Also match "c:" in the file name, even when
-             * checking for a colon next: "%f:".
-             * "\%(\a:\)\=" */
-            STRCPY(ptr, "\\%(\\a:\\)\\=");
-            ptr += 10;
-          }
-#endif
-          if (*efmp == 'f' && efmp[1] != NUL) {
-            if (efmp[1] != '\\' && efmp[1] != '%') {
-              /* A file name may contain spaces, but this isn't
-               * in "\f".  For "%f:%l:%m" there may be a ":" in
-               * the file name.  Use ".\{-1,}x" instead (x is
-               * the next character), the requirement that :999:
-               * follows should work. */
-              STRCPY(ptr, ".\\{-1,}");
-              ptr += 7;
-            } else {
-              /* File name followed by '\\' or '%': include as
-               * many file name chars as possible. */
-              STRCPY(ptr, "\\f\\+");
-              ptr += 4;
-            }
-          } else {
-            srcptr = (char_u *)fmt_pat[idx].pattern;
-            while ((*ptr = *srcptr++) != NUL)
-              ++ptr;
-          }
-          *ptr++ = '\\';
-          *ptr++ = ')';
-        } else if (*efmp == '*') {
-          if (*++efmp == '[' || *efmp == '\\') {
-            if ((*ptr++ = *efmp) == '[') {              /* %*[^a-z0-9] etc. */
-              if (efmp[1] == '^')
-                *ptr++ = *++efmp;
-              if (efmp < efm + len) {
-                *ptr++ = *++efmp;                           /* could be ']' */
-                while (efmp < efm + len
-                       && (*ptr++ = *++efmp) != ']')
-                  /* skip */;
-                if (efmp == efm + len) {
-                  EMSG(_("E374: Missing ] in format string"));
-                  goto error2;
-                }
-              }
-            } else if (efmp < efm + len)                /* %*\D, %*\s etc. */
-              *ptr++ = *++efmp;
-            *ptr++ = '\\';
-            *ptr++ = '+';
-          } else {
-            /* TODO: scanf()-like: %*ud, %*3c, %*f, ... ? */
-            sprintf((char *)errmsg,
-                _("E375: Unsupported %%%c in format string"), *efmp);
-            EMSG(errmsg);
-            goto error2;
-          }
-        } else if (vim_strchr((char_u *)"%\\.^$~[", *efmp) != NULL)
-          *ptr++ = *efmp;                       /* regexp magic characters */
-        else if (*efmp == '#')
-          *ptr++ = '*';
-        else if (*efmp == '>')
-          fmt_ptr->conthere = TRUE;
-        else if (efmp == efm + 1) {                     /* analyse prefix */
-          if (vim_strchr((char_u *)"+-", *efmp) != NULL)
-            fmt_ptr->flags = *efmp++;
-          if (vim_strchr((char_u *)"DXAEWICZGOPQ", *efmp) != NULL)
-            fmt_ptr->prefix = *efmp;
-          else {
-            sprintf((char *)errmsg,
-                _("E376: Invalid %%%c in format string prefix"), *efmp);
-            EMSG(errmsg);
-            goto error2;
-          }
-        } else {
-          sprintf((char *)errmsg,
-              _("E377: Invalid %%%c in format string"), *efmp);
-          EMSG(errmsg);
-          goto error2;
-        }
-      } else {                        /* copy normal character */
-        if (*efmp == '\\' && efmp + 1 < efm + len)
-          ++efmp;
-        else if (vim_strchr((char_u *)".*^$~[", *efmp) != NULL)
-          *ptr++ = '\\';                /* escape regexp atoms */
-        if (*efmp)
-          *ptr++ = *efmp;
-      }
+  // If the errorformat didn't change between calls, then reuse the previously
+  // parsed values.
+  if (last_efm == NULL || (STRCMP(last_efm, efm) != 0)) {
+    // free the previously parsed data
+    xfree(last_efm);
+    last_efm = NULL;
+    free_efm_list(&fmt_first);
+
+    // parse the current 'efm'
+    fmt_first = parse_efm_option(efm);
+    if (fmt_first != NULL) {
+      last_efm = vim_strsave(efm);
     }
-    *ptr++ = '$';
-    *ptr = NUL;
-    if ((fmt_ptr->prog = vim_regcomp(fmtstr, RE_MAGIC + RE_STRING)) == NULL)
-      goto error2;
-    /*
-     * Advance to next part
-     */
-    efm = skip_to_option_part(efm + len);       /* skip comma and spaces */
   }
-  if (fmt_first == NULL) {      /* nothing found */
-    EMSG(_("E378: 'errorformat' contains no pattern"));
+
+  if (fmt_first == NULL) {      // nothing found
     goto error2;
   }
 
@@ -466,36 +569,49 @@ qf_init_ext (
           /* Get the next line from the supplied string */
           char_u *p;
 
-          if (!*p_str)           /* Reached the end of the string */
+          if (*p_str == NUL) {  // Reached the end of the string
             break;
+          }
 
           p = vim_strchr(p_str, '\n');
-          if (p)
-            len = (int)(p - p_str + 1);
-          else
-            len = (int)STRLEN(p_str);
+          if (p != NULL) {
+            len = (size_t)(p - p_str) + 1;
+          } else {
+            len = STRLEN(p_str);
+          }
 
-          if (len > CMDBUFFSIZE - 2)
-            STRLCPY(IObuff, p_str, CMDBUFFSIZE - 1);
-          else
-            STRLCPY(IObuff, p_str, len + 1);
+          if (len > IOSIZE - 2) {
+            linebuf = qf_grow_linebuf(&growbuf, &growbufsiz, len, &linelen);
+          } else {
+            linebuf = IObuff;
+            linelen = len;
+          }
+          STRLCPY(linebuf, p_str, linelen + 1);
 
+          // Increment using len in order to discard the rest of the line if it
+          // exceeds LINE_MAXLEN.
           p_str += len;
         } else if (tv->v_type == VAR_LIST) {
           // Get the next line from the supplied list
-          while (p_li && (p_li->li_tv.v_type != VAR_STRING
-                          || p_li->li_tv.vval.v_string == NULL)) {
+          while (p_li != NULL
+                 && (p_li->li_tv.v_type != VAR_STRING
+                     || p_li->li_tv.vval.v_string == NULL)) {
             p_li = p_li->li_next;               // Skip non-string items
           }
 
-          if (!p_li)                            /* End of the list */
+          if (p_li == NULL) {                   // End of the list
             break;
+          }
 
-          len = (int)STRLEN(p_li->li_tv.vval.v_string);
-          if (len > CMDBUFFSIZE - 2)
-            len = CMDBUFFSIZE - 2;
+          len = STRLEN(p_li->li_tv.vval.v_string);
+          if (len > IOSIZE - 2) {
+            linebuf = qf_grow_linebuf(&growbuf, &growbufsiz, len, &linelen);
+          } else {
+            linebuf = IObuff;
+            linelen = len;
+          }
 
-          STRLCPY(IObuff, p_li->li_tv.vval.v_string, len + 1);
+          STRLCPY(linebuf, p_li->li_tv.vval.v_string, linelen + 1);
 
           p_li = p_li->li_next;                 /* next item */
         }
@@ -503,21 +619,94 @@ qf_init_ext (
         /* Get the next line from the supplied buffer */
         if (buflnum > lnumlast)
           break;
-        STRLCPY(IObuff, ml_get_buf(buf, buflnum++, FALSE),
-            CMDBUFFSIZE - 1);
+        p_buf = ml_get_buf(buf, buflnum++, false);
+        len = STRLEN(p_buf);
+        if (len > IOSIZE - 2) {
+            linebuf = qf_grow_linebuf(&growbuf, &growbufsiz, len, &linelen);
+        } else {
+          linebuf = IObuff;
+          linelen = len;
+        }
+        STRLCPY(linebuf, p_buf, linelen + 1);
       }
-    } else if (fgets((char *)IObuff, CMDBUFFSIZE - 2, fd) == NULL)
-      break;
+    } else {
+      if (fgets((char *)IObuff, IOSIZE, fd) == NULL) {
+        break;
+      }
+
+      discard = false;
+      linelen = STRLEN(IObuff);
+      if (linelen == IOSIZE - 1 && !(IObuff[linelen - 1] == '\n'
+#ifdef USE_CRNL
+                                     || IObuff[linelen - 1] == '\r'
+#endif
+                                     )) {  // NOLINT(whitespace/parens)
+        // The current line exceeds IObuff, continue reading using growbuf
+        // until EOL or LINE_MAXLEN bytes is read.
+        if (growbuf == NULL) {
+          growbufsiz = 2 * (IOSIZE - 1);
+          growbuf = xmalloc(growbufsiz);
+        }
+
+        // Copy the read part of the line, excluding null-terminator
+        memcpy(growbuf, IObuff, IOSIZE - 1);
+        growbuflen = linelen;
+
+        for (;;) {
+          if (fgets((char *)growbuf + growbuflen,
+                    (int)(growbufsiz - growbuflen), fd) == NULL) {
+            break;
+          }
+          linelen = STRLEN(growbuf + growbuflen);
+          growbuflen += linelen;
+          if (growbuf[growbuflen - 1] == '\n'
+#ifdef USE_CRNL
+              || growbuf[growbuflen - 1] == '\r'
+#endif
+              ) {
+            break;
+          }
+          if (growbufsiz == LINE_MAXLEN) {
+            discard = true;
+            break;
+          }
 
-    IObuff[CMDBUFFSIZE - 2] = NUL;      /* for very long lines */
-    remov