3 files changed, 43 insertions, 63 deletions

diff --git a/editors/awk.c b/editors/awk.c
index 0b573a065..77784dfc1 100644
--- a/editors/awk.c
+++ b/editors/awk.c
@@ -190,7 +190,7 @@ typedef struct tsplitter_s {
 
 /* combined token classes */
 #define TC_BINOP   (TC_BINOPX | TC_COMMA | TC_PIPE | TC_IN)
-#define TC_UNARYOP (TC_UOPPRE | TC_UOPPOST)
+//#define       TC_UNARYOP (TC_UOPPRE | TC_UOPPOST)
 #define TC_OPERAND (TC_VARIABLE | TC_ARRAY | TC_FUNCTION \
                    | TC_BUILTIN | TC_GETLINE | TC_SEQSTART | TC_STRING | TC_NUMBER)
 
@@ -2015,8 +2015,8 @@ static int fmt_num(char *b, int size, const char *format, double n, int int_as_i
         char c;
         const char *s = format;
 
-        if (int_as_int && n == (int)n) {
-                r = snprintf(b, size, "%d", (int)n);
+        if (int_as_int && n == (long long)n) {
+                r = snprintf(b, size, "%lld", (long long)n);
         } else {
                 do { c = *s; } while (c && *++s);
                 if (strchr("diouxX", c)) {
@@ -2662,7 +2662,7 @@ static var *evaluate(node *op, var *res)
                         const char *sv_progname;
 
                         /* The body might be empty, still has to eval the args */
-                        if (!op->r.n->info)
+                        if (!op->r.n->info && !op->r.f->body.first)
                                 syntax_error(EMSG_UNDEF_FUNC);
 
                         vbeg = v = nvalloc(op->r.f->nargs + 1);
@@ -2733,7 +2733,7 @@ static var *evaluate(node *op, var *res)
 
                         switch (opn) {
                         case F_in:
-                                R_d = (int)L_d;
+                                R_d = (long long)L_d;
                                 break;
 
                         case F_rn:
@@ -2931,7 +2931,7 @@ static var *evaluate(node *op, var *res)
                         case '%':
                                 if (R_d == 0)
                                         syntax_error(EMSG_DIV_BY_ZERO);
-                                L_d -= (int)(L_d / R_d) * R_d;
+                                L_d -= (long long)(L_d / R_d) * R_d;
                                 break;
                         }
                         debug_printf_eval("BINARY/REPLACE result:%f\n", L_d);
diff --git a/editors/sed.c b/editors/sed.c
index f8ca5d351..3a0d917aa 100644
--- a/editors/sed.c
+++ b/editors/sed.c
@@ -330,7 +330,7 @@ static int get_address(const char *my_str, int *linenum, regex_t ** regex)
                 next = index_of_next_unescaped_regexp_delim(delimiter, ++pos);
                 temp = copy_parsing_escapes(pos, next);
                 *regex = xzalloc(sizeof(regex_t));
-                xregcomp(*regex, temp, G.regex_type|REG_NEWLINE);
+                xregcomp(*regex, temp, G.regex_type);
                 free(temp);
                 /* Move position to next character after last delimiter */
                 pos += (next+1);
@@ -649,6 +649,12 @@ static void add_cmd(const char *cmdstr)
                 sed_cmd->cmd = *cmdstr++;
                 cmdstr = parse_cmd_args(sed_cmd, cmdstr);
 
+                /* cmdstr now points past args.
+                 * GNU sed requires a separator, if there are more commands,
+                 * else it complains "char N: extra characters after command".
+                 * Example: "sed 'p;d'". We also allow "sed 'pd'".
+                 */
+
                 /* Add the command to the command array */
                 *G.sed_cmd_tail = sed_cmd;
                 G.sed_cmd_tail = &sed_cmd->next;
@@ -1371,7 +1377,7 @@ static void process_files(void)
 /* It is possible to have a command line argument with embedded
  * newlines.  This counts as multiple command lines.
  * However, newline can be escaped: 's/e/z\<newline>z/'
- * We check for this.
+ * add_cmd() handles this.
  */
 
 static void add_cmd_block(char *cmdstr)
@@ -1381,22 +1387,8 @@ static void add_cmd_block(char *cmdstr)
         cmdstr = sv = xstrdup(cmdstr);
         do {
                 eol = strchr(cmdstr, '\n');
- next:
-                if (eol) {
-                        /* Count preceding slashes */
-                        int slashes = 0;
-                        char *sl = eol;
-
-                        while (sl != cmdstr && *--sl == '\\')
-                                slashes++;
-                        /* Odd number of preceding slashes - newline is escaped */
-                        if (slashes & 1) {
-                                overlapping_strcpy(eol - 1, eol);
-                                eol = strchr(eol, '\n');
-                                goto next;
-                        }
+                if (eol)
                         *eol = '\0';
-                }
                 add_cmd(cmdstr);
                 cmdstr = eol + 1;
         } while (eol);
diff --git a/editors/vi.c b/editors/vi.c
index d6c8c0dd8..ab49b3f7d 100644
--- a/editors/vi.c
+++ b/editors/vi.c
@@ -1707,65 +1707,53 @@ static char *new_screen(int ro, int co)
 // search for pattern starting at p
 static char *char_search(char *p, const char *pat, int dir, int range)
 {
-        char *q;
         struct re_pattern_buffer preg;
+        const char *err;
+        char *q;
         int i;
         int size;
 
         re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
-        preg.translate = 0;
-        preg.fastmap = 0;
-        preg.buffer = 0;
-        preg.allocated = 0;
+        if (ignorecase)
+                re_syntax_options = RE_SYNTAX_POSIX_EXTENDED | RE_ICASE;
+
+        memset(&preg, 0, sizeof(preg));
+        err = re_compile_pattern(pat, strlen(pat), &preg);
+        if (err != NULL) {
+                status_line_bold("bad search pattern '%s': %s", pat, err);
+                return p;
+        }
 
         // assume a LIMITED forward search
-        q = next_line(p);
-        q = end_line(q);
         q = end - 1;
-        if (dir == BACK) {
-                q = prev_line(p);
+        if (dir == BACK)
                 q = text;
-        }
-        // count the number of chars to search over, forward or backward
-        size = q - p;
-        if (size < 0)
-                size = p - q;
         // RANGE could be negative if we are searching backwards
         range = q - p;
-
-        q = (char *)re_compile_pattern(pat, strlen(pat), (struct re_pattern_buffer *)&preg);
-        if (q != 0) {
-                // The pattern was not compiled
-                status_line_bold("bad search pattern: '%s': %s", pat, q);
-                i = 0;                  // return p if pattern not compiled
-                goto cs1;
-        }
-
         q = p;
+        size = range;
         if (range < 0) {
+                size = -size;
                 q = p - size;
                 if (q < text)
                         q = text;
         }
         // search for the compiled pattern, preg, in p[]
-        // range < 0-  search backward
-        // range > 0-  search forward
+        // range < 0: search backward
+        // range > 0: search forward
         // 0 < start < size
-        // re_search() < 0  not found or error
-        // re_search() > 0  index of found pattern
-        //            struct pattern    char     int    int    int     struct reg
-        // re_search (*pattern_buffer,  *string, size,  start, range,  *regs)
-        i = re_search(&preg, q, size, 0, range, 0);
-        if (i == -1) {
-                p = 0;
-                i = 0;                  // return NULL if pattern not found
-        }
- cs1:
-        if (dir == FORWARD) {
+        // re_search() < 0: not found or error
+        // re_search() >= 0: index of found pattern
+        //           struct pattern   char     int   int    int    struct reg
+        // re_search(*pattern_buffer, *string, size, start, range, *regs)
+        i = re_search(&preg, q, size, /*start:*/ 0, range, /*struct re_registers*:*/ NULL);
+        regfree(&preg);
+        if (i < 0)
+                return NULL;
+        if (dir == FORWARD)
                 p = p + i;
-        } else {
+        else
                 p = p - i;
-        }
         return p;
 }
 
@@ -1790,7 +1778,7 @@ static char *char_search(char *p, const char *pat, int dir, int range)
 
         len = strlen(pat);
         if (dir == FORWARD) {
-                stop = end - 1; // assume range is p - end-1
+                stop = end - 1; // assume range is p..end-1
                 if (range == LIMITED)
                         stop = next_line(p);    // range is to next line
                 for (start = p; start < stop; start++) {
@@ -1799,7 +1787,7 @@ static char *char_search(char *p, const char *pat, int dir, int range)
                         }
                 }
         } else if (dir == BACK) {
-                stop = text;    // assume range is text - p
+                stop = text;    // assume range is text..p
                 if (range == LIMITED)
                         stop = prev_line(p);    // range is to prev line
                 for (start = p - len; start >= stop; start--) {