WIP: Apply delimiter to read built-in

Author: magicant

input.c

@@ -110,6 +110,14 @@ inputresult_T input_file(struct xwcsbuf_T *buf, void *inputinfo)
  *   INPUT_ERROR if an error occurred before reading any characters */
 inputresult_T read_input(
         xwcsbuf_T *buf, struct input_file_info_T *info, bool trap)
+{
+    return read_input_delimited(buf, info, trap, L'\n');
+}
+
+/* Like `read_input', but reads input until a delimiter character is found. */
+inputresult_T read_input_delimited(
+        xwcsbuf_T *buf, struct input_file_info_T *info, bool trap,
+        wchar_t delimiter)
 {
     if (info->bufsize == 1 && is_seekable_file(info->fd))
         return optimized_read_input(buf, info, trap);
@@ -170,7 +178,7 @@ inputresult_T read_input(
             default:
                 info->bufpos += convcount;
                 buf->contents[++buf->length] = L'\0';
-                if (buf->contents[buf->length - 1] == L'\n')
+                if (buf->contents[buf->length - 1] == delimiter)
                     goto end;
                 break;
         }

input.h

@@ -59,6 +59,10 @@ struct input_file_info_T;
 extern inputresult_T read_input(
         struct xwcsbuf_T *buf, struct input_file_info_T *info, _Bool trap)
     __attribute__((nonnull));
+extern inputresult_T read_input_delimited(
+        struct xwcsbuf_T *buf, struct input_file_info_T *info, _Bool trap,
+        wchar_t delimiter)
+    __attribute__((nonnull));
 
 /* The type of input functions.
  * An input function reads input and appends it to buffer `buf'.

variable.c

@@ -1608,12 +1608,13 @@ static bool read_with_prompt(
 static struct promptset_T promptset_for_read(
         bool firstline, const struct reading_option_T *ro)
     __attribute__((nonnull,warn_unused_result));
-static wchar_t *read_one_line_with_prompt(
-        struct promptset_T prompt, bool lineedit)
-    __attribute__((malloc,warn_unused_result));
-static wchar_t *read_one_line(void)
-    __attribute__((malloc,warn_unused_result));
-static bool unescape_line(const wchar_t *line, xwcsbuf_T *buf, xstrbuf_T *cc)
+static xwcsbuf_T read_one_line_with_prompt(
+        struct promptset_T prompt, wchar_t delimiter, bool lineedit)
+    __attribute__((warn_unused_result));
+static xwcsbuf_T read_one_line(wchar_t delimiter)
+    __attribute__((warn_unused_result));
+static bool unescape_line(
+        const xwcsbuf_T *line, xwcsbuf_T *buf, xstrbuf_T *cc, wchar_t delimiter)
     __attribute__((nonnull));
 static void assign_array(const wchar_t *name, const plist_T *ranges, size_t i)
     __attribute__((nonnull));
@@ -2843,30 +2844,37 @@ int read_builtin(int argc, void **argv)
 bool read_with_prompt(
         xwcsbuf_T *buf, xstrbuf_T *cc, const struct reading_option_T *ro)
 {
+    if (wcslen(ro->delimiter) > 1) {
+        xerror(0, Ngt("multi-character delimiter is not supported"));
+        return false;
+    }
+    wchar_t delimiter = ro->delimiter[0];
+
     bool firstline = true;
     bool completed = false;
     bool use_prompt = is_interactive_now && isatty(STDIN_FILENO);
 
     while (!completed) {
-        wchar_t *line;
+        xwcsbuf_T line;
         if (use_prompt) {
             struct promptset_T prompt = promptset_for_read(firstline, ro);
-            line = read_one_line_with_prompt(prompt, ro->lineedit);
+            line = read_one_line_with_prompt(prompt, delimiter, ro->lineedit);
             free_prompt(prompt);
         } else {
-            line = read_one_line();
+            line = read_one_line(delimiter);
         }
-        if (line == NULL)
+        if (line.contents == NULL)
             return false;
 
         if (ro->raw) {
-            wb_cat(buf, line);
-            sb_ccat_repeat(cc, CC_SOFT_EXPANSION, wcslen(line));
+            wb_cat(buf, line.contents);
+            sb_ccat_repeat(cc, CC_SOFT_EXPANSION, line.length);
             completed = true;
         } else {
-            completed = unescape_line(line, buf, cc);
+            completed =
+                line.length == 0 || unescape_line(&line, buf, cc, delimiter);
         }
-        free(line);
+        wb_destroy(&line);
 
         firstline = false;
     }
@@ -2892,23 +2900,28 @@ struct promptset_T promptset_for_read(
 
 /* Reads one line from the standard input with the specified prompt.
  * If `lineedit' is true, use line-editing if possible.
- * The result is returned as a newly-malloced wide string. The result is null
- * iff an error occurs. */
-wchar_t *read_one_line_with_prompt(struct promptset_T prompt, bool lineedit)
+ * The result is returned as a wide string buffer. The buffer contents are NULL
+ * if an error occurs. */
+xwcsbuf_T read_one_line_with_prompt(
+        struct promptset_T prompt, wchar_t delimiter, bool lineedit)
 {
-    wchar_t *line;
+    xwcsbuf_T buf;
 
     if (lineedit) {
 #if YASH_ENABLE_LINEEDIT
-        if (shopt_lineedit != SHOPT_NOLINEEDIT) {
+        if (delimiter == L'\n' && shopt_lineedit != SHOPT_NOLINEEDIT) {
+            wchar_t *line;
             switch (le_readline(prompt, false, &line)) {
                 case INPUT_OK:
-                    return line;
+                    wb_initwith(&buf, line);
+                    return buf;
                 case INPUT_EOF:
-                    return xwcsdup(L"");
+                    wb_init(&buf);
+                    return buf;
                 case INPUT_INTERRUPTED:
                     set_interrupted();
-                    return NULL;
+                    buf.contents = NULL;
+                    return buf;
                 case INPUT_ERROR:
                     break;
             }
@@ -2919,58 +2932,58 @@ wchar_t *read_one_line_with_prompt(struct promptset_T prompt, bool lineedit)
     print_prompt(prompt.main);
     print_prompt(prompt.styler);
 
-    line = read_one_line();
+    buf = read_one_line(delimiter);
 
     print_prompt(PROMPT_RESET);
 
-    return line;
+    return buf;
 }
 
 /* Reads one line from the standard input without printing any prompt or using
  * line-editing.
  * The result is returned as a newly-malloced wide string. The result is null
  * iff an error occurs. */
-wchar_t *read_one_line(void)
+xwcsbuf_T read_one_line(wchar_t delimiter)
 {
     xwcsbuf_T buf;
     wb_init(&buf);
-    if (read_input(&buf, stdin_input_file_info, false) != INPUT_ERROR)
-        return wb_towcs(&buf);
-    wb_destroy(&buf);
-    return NULL;
+
+    inputresult_T result =
+        read_input_delimited(&buf, stdin_input_file_info, false, delimiter);
+
+    if (result == INPUT_ERROR) {
+        wb_destroy(&buf);
+        buf.contents = NULL;
+    }
+    return buf;
 }
 
 /* Parses a string that may contain backslash escapes.
  * Unescaped `line' is appended to `buf' with a corresponding charcategory_T
  * string appended to `cc'.
- * The result is false iff `line' ends with a line continuation.
- * The line continuation is not appended to `buf'. */
-bool unescape_line(const wchar_t *line, xwcsbuf_T *buf, xstrbuf_T *cc)
-{
-    for (;;) {
-        bool splitchar;
-
-        switch (*line) {
-            case L'\0':
-                return true;
-            case L'\\':
-                line++;
-                switch (*line) {
-                    case L'\0':
-                        return true;
-                    case L'\n':
-                        return false;
-                }
-                splitchar = false;
-                break;
-            default:
-                splitchar = true;
+ * The result is false iff the read built-in should read the next line, that is,
+ * the line does not end with an unescaped delimiter.
+ * Line continuations are skipped and not appended to `buf' or `cc'. */
+bool unescape_line(
+        const xwcsbuf_T *line, xwcsbuf_T *buf, xstrbuf_T *cc, wchar_t delimiter)
+{
+    for (size_t i = 0; i < line->length; i++) {
+        if (line->contents[i] == L'\\') {
+            i++;
+            if (i == line->length)
                 break;
+            if (line->contents[i] == L'\n')
+                continue;
+            wb_wccat(buf, line->contents[i]);
+            sb_ccat(cc, CC_SOFT_EXPANSION | CC_QUOTED);
+        } else {
+            wb_wccat(buf, line->contents[i]);
+            sb_ccat(cc, CC_SOFT_EXPANSION);
+            if (line->contents[i] == delimiter)
+                return true;
         }
-        wb_wccat(buf, *line);
-        sb_ccat(cc, CC_SOFT_EXPANSION | (splitchar ? 0 : CC_QUOTED));
-        line++;
     }
+    return false;
 }
 
 /* Assigns a result of field-splitting contained in `ranges' to an array named