Fix calculation of space needed for parsed words in tab completion.

Yesterday in commit d854118c8, I had a serious brain fade leading me to
underestimate the number of words that the tab-completion logic could
divide a line into.  On input such as "(((((", each character will get
seen as a separate word, which means we do indeed sometimes need more
space for the words than for the original line.  Fix that.

diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index 1a7d184af9ffb06c4378a542174ed57c61e0e68e..df678d5ce3629b299a0fe965d56e0d70701a2648 100644 (file)
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -3652,41 +3652,39 @@ get_previous_words(int point, char **buffer, int *nwords)
 {
    char      **previous_words;
    char       *buf;
-   int         buflen;
+   char       *outptr;
    int         words_found = 0;
    int         i;
 
    /*
-    * Construct a writable buffer including both preceding and current lines
-    * of the query, up to "point" which is where the currently completable
-    * word begins.  Because our definition of "word" is such that a non-word
-    * character must end each word, we can use this buffer to return the word
-    * data as-is, by placing a '\0' after each word.
+    * If we have anything in tab_completion_query_buf, paste it together with
+    * rl_line_buffer to construct the full query.  Otherwise we can just use
+    * rl_line_buffer as the input string.
     */
-   buflen = point + 1;
-   if (tab_completion_query_buf)
-       buflen += tab_completion_query_buf->len + 1;
-   *buffer = buf = pg_malloc(buflen);
-   i = 0;
-   if (tab_completion_query_buf)
-   {
-       memcpy(buf, tab_completion_query_buf->data,
-              tab_completion_query_buf->len);
-       i += tab_completion_query_buf->len;
+   if (tab_completion_query_buf && tab_completion_query_buf->len > 0)
+   {
+       i = tab_completion_query_buf->len;
+       buf = pg_malloc(point + i + 2);
+       memcpy(buf, tab_completion_query_buf->data, i);
        buf[i++] = '\n';
+       memcpy(buf + i, rl_line_buffer, point);
+       i += point;
+       buf[i] = '\0';
+       /* Readjust point to reference appropriate offset in buf */
+       point = i;
    }
-   memcpy(buf + i, rl_line_buffer, point);
-   i += point;
-   buf[i] = '\0';
-
-   /* Readjust point to reference appropriate offset in buf */
-   point = i;
+   else
+       buf = rl_line_buffer;
 
    /*
-    * Allocate array of word start points.  There can be at most length/2 + 1
-    * words in the buffer.
+    * Allocate an array of string pointers and a buffer to hold the strings
+    * themselves.  The worst case is that the line contains only
+    * non-whitespace WORD_BREAKS characters, making each one a separate word.
+    * This is usually much more space than we need, but it's cheaper than
+    * doing a separate malloc() for each word.
     */
-   previous_words = (char **) pg_malloc((point / 2 + 1) * sizeof(char *));
+   previous_words = (char **) pg_malloc(point * sizeof(char *));
+   *buffer = outptr = (char *) pg_malloc(point * 2);
 
    /*
     * First we look for a non-word char before the current point.  (This is
@@ -3752,14 +3750,20 @@ get_previous_words(int point, char **buffer, int *nwords)
        }
 
        /* Return the word located at start to end inclusive */
-       previous_words[words_found] = &buf[start];
-       buf[end + 1] = '\0';
-       words_found++;
+       previous_words[words_found++] = outptr;
+       i = end - start + 1;
+       memcpy(outptr, &buf[start], i);
+       outptr += i;
+       *outptr++ = '\0';
 
        /* Continue searching */
        point = start - 1;
    }
 
+   /* Release parsing input workspace, if we made one above */
+   if (buf != rl_line_buffer)
+       free(buf);
+
    *nwords = words_found;
    return previous_words;
 }