Merge branch 'busybox' into mergemerge

7 files changed, 422 insertions, 208 deletions

diff --git a/coreutils/cut.c b/coreutils/cut.c
index f7b501a46..d81f36bcd 100644
--- a/coreutils/cut.c
+++ b/coreutils/cut.c
@@ -27,21 +27,34 @@
 //kbuild:lib-$(CONFIG_CUT) += cut.o
 
 //usage:#define cut_trivial_usage
-//usage:       "[OPTIONS] [FILE]..."
+//usage:       "{-b|c LIST | -f"IF_FEATURE_CUT_REGEX("|F")" LIST [-d SEP] [-s]} [-D] [-O SEP] [FILE]..."
+//  --output-delimiter SEP is too long to fit into 80 char-wide help ----------------^^^^^^^^
 //usage:#define cut_full_usage "\n\n"
 //usage:       "Print selected fields from FILEs to stdout\n"
 //usage:     "\n        -b LIST Output only bytes from LIST"
 //usage:     "\n        -c LIST Output only characters from LIST"
-//usage:     "\n        -d SEP  Field delimiter for input (default -f TAB, -F run of whitespace)"
-//usage:     "\n        -O SEP  Field delimeter for output (default = -d for -f, one space for -F)"
-//usage:     "\n        -D      Don't sort/collate sections or match -fF lines without delimeter"
+//usage:     IF_FEATURE_CUT_REGEX(
+//usage:     "\n        -d SEP  Input field delimiter (default -f TAB, -F run of whitespace)"
+//usage:     ) IF_NOT_FEATURE_CUT_REGEX(
+//usage:     "\n        -d SEP  Input field delimiter (default TAB)"
+//usage:     )
 //usage:     "\n        -f LIST Print only these fields (-d is single char)"
 //usage:     IF_FEATURE_CUT_REGEX(
 //usage:     "\n        -F LIST Print only these fields (-d is regex)"
 //usage:     )
-//usage:     "\n        -s      Output only lines containing delimiter"
+//usage:     "\n        -s      Drop lines with no delimiter (else print them in full)"
+//usage:     "\n        -D      Don't sort ranges; line without delimiters has one field"
+//usage:     IF_LONG_OPTS(
+//usage:     "\n        --output-delimiter SEP  Output field delimeter"
+//usage:     ) IF_NOT_LONG_OPTS(
+//usage:     IF_FEATURE_CUT_REGEX(
+//usage:     "\n        -O SEP  Output field delimeter (default = -d for -f, one space for -F)"
+//usage:     ) IF_NOT_FEATURE_CUT_REGEX(
+//usage:     "\n        -O SEP  Output field delimeter (default = -d)"
+//usage:     )
+//usage:     )
 //usage:     "\n        -n      Ignored"
-//(manpage:-n   with -b: don't split multibyte characters)
+//(manpage:-n with -b: don't split multibyte characters)
 //usage:
 //usage:#define cut_example_usage
 //usage:       "$ echo \"Hello world\" | cut -f 1 -d ' '\n"
@@ -53,11 +66,6 @@
 
 #if ENABLE_FEATURE_CUT_REGEX
 #include "xregex.h"
-#else
-#define regex_t int
-typedef struct { int rm_eo, rm_so; } regmatch_t;
-#define xregcomp(x, ...) *(x) = 0
-#define regexec(...)     0
 #endif
 
 /* This is a NOEXEC applet. Be very careful! */
@@ -65,265 +73,346 @@ typedef struct { int rm_eo, rm_so; } regmatch_t;
 
 /* option vars */
 #define OPT_STR "b:c:f:d:O:sD"IF_FEATURE_CUT_REGEX("F:")"n"
-#define CUT_OPT_BYTE_FLGS     (1 << 0)
-#define CUT_OPT_CHAR_FLGS     (1 << 1)
-#define CUT_OPT_FIELDS_FLGS   (1 << 2)
-#define CUT_OPT_DELIM_FLGS    (1 << 3)
-#define CUT_OPT_ODELIM_FLGS   (1 << 4)
-#define CUT_OPT_SUPPRESS_FLGS (1 << 5)
-#define CUT_OPT_NOSORT_FLGS   (1 << 6)
-#define CUT_OPT_REGEX_FLGS    ((1 << 7) * ENABLE_FEATURE_CUT_REGEX)
-
-struct cut_list {
-        int startpos;
-        int endpos;
+#define OPT_BYTE     (1 << 0)
+#define OPT_CHAR     (1 << 1)
+#define OPT_FIELDS   (1 << 2)
+#define OPT_DELIM    (1 << 3)
+#define OPT_ODELIM   (1 << 4)
+#define OPT_SUPPRESS (1 << 5)
+#define OPT_NOSORT   (1 << 6)
+#define OPT_REGEX    ((1 << 7) * ENABLE_FEATURE_CUT_REGEX)
+
+#define opt_REGEX (option_mask32 & OPT_REGEX)
+
+struct cut_range {
+        unsigned startpos;
+        unsigned endpos;
 };
 
 static int cmpfunc(const void *a, const void *b)
 {
-        return (((struct cut_list *) a)->startpos -
-                        ((struct cut_list *) b)->startpos);
+        const struct cut_range *aa = a;
+        const struct cut_range *bb = b;
+        return aa->startpos - bb->startpos;
 }
 
+#define END_OF_LIST(list_elem)     ((list_elem).startpos == UINT_MAX)
+#define NOT_END_OF_LIST(list_elem) ((list_elem).startpos != UINT_MAX)
+
 static void cut_file(FILE *file, const char *delim, const char *odelim,
-                const struct cut_list *cut_lists, unsigned nlists)
+                const struct cut_range *cut_list)
 {
         char *line;
         unsigned linenum = 0;   /* keep these zero-based to be consistent */
-        regex_t reg;
-        int spos, shoe = option_mask32 & CUT_OPT_REGEX_FLGS;
-
-        if (shoe) xregcomp(&reg, delim, REG_EXTENDED);
+        int first_print = 1;
 
         /* go through every line in the file */
         while ((line = xmalloc_fgetline(file)) != NULL) {
 
                 /* set up a list so we can keep track of what's been printed */
-                int linelen = strlen(line);
-                char *printed = xzalloc(linelen + 1);
-                char *orig_line = line;
+                unsigned linelen = strlen(line);
                 unsigned cl_pos = 0;
 
-                /* cut based on chars/bytes XXX: only works when sizeof(char) == byte */
-                if (option_mask32 & (CUT_OPT_CHAR_FLGS | CUT_OPT_BYTE_FLGS)) {
+                /* Cut based on chars/bytes XXX: only works when sizeof(char) == byte */
+                if (option_mask32 & (OPT_CHAR | OPT_BYTE)) {
+                        char *printed = xzalloc(linelen + 1);
+                        int need_odelim = 0;
+
                         /* print the chars specified in each cut list */
-                        for (; cl_pos < nlists; cl_pos++) {
-                                for (spos = cut_lists[cl_pos].startpos; spos < linelen;) {
+                        for (; NOT_END_OF_LIST(cut_list[cl_pos]); cl_pos++) {
+                                unsigned spos = cut_list[cl_pos].startpos;
+                                while (spos < linelen) {
                                         if (!printed[spos]) {
                                                 printed[spos] = 'X';
+                                                if (need_odelim && spos != 0 && !printed[spos-1]) {
+                                                        need_odelim = 0;
+                                                        fputs_stdout(odelim);
+                                                }
                                                 putchar(line[spos]);
                                         }
-                                        if (++spos > cut_lists[cl_pos].endpos) {
+                                        spos++;
+                                        if (spos > cut_list[cl_pos].endpos) {
+                                                /* will print OSEP (if not empty) */
+                                                need_odelim = (odelim && odelim[0]);
                                                 break;
                                         }
                                 }
                         }
-                } else if (*delim == '\n') {    /* cut by lines */
-                        spos = cut_lists[cl_pos].startpos;
+                        free(printed);
+                /* Cut by lines */
+                } else if (!opt_REGEX && *delim == '\n') {
+                        unsigned spos = cut_list[cl_pos].startpos;
 
-                        /* get out if we have no more lists to process or if the lines
+                        linenum++;
+                        /* get out if we have no more ranges to process or if the lines
                          * are lower than what we're interested in */
-                        if (((int)linenum < spos) || (cl_pos >= nlists))
+                        if (linenum <= spos || END_OF_LIST(cut_list[cl_pos]))
                                 goto next_line;
 
                         /* if the line we're looking for is lower than the one we were
                          * passed, it means we displayed it already, so move on */
-                        while (spos < (int)linenum) {
-                                spos++;
+                        while (++spos < linenum) {
                                 /* go to the next list if we're at the end of this one */
-                                if (spos > cut_lists[cl_pos].endpos) {
+                                if (spos > cut_list[cl_pos].endpos) {
                                         cl_pos++;
-                                        /* get out if there's no more lists to process */
-                                        if (cl_pos >= nlists)
+                                        /* get out if there's no more ranges to process */
+                                        if (END_OF_LIST(cut_list[cl_pos]))
                                                 goto next_line;
-                                        spos = cut_lists[cl_pos].startpos;
+                                        spos = cut_list[cl_pos].startpos;
                                         /* get out if the current line is lower than the one
                                          * we just became interested in */
-                                        if ((int)linenum < spos)
+                                        if (linenum <= spos)
                                                 goto next_line;
                                 }
                         }
 
                         /* If we made it here, it means we've found the line we're
                          * looking for, so print it */
-                        puts(line);
+                        if (first_print) {
+                                first_print = 0;
+                                fputs_stdout(line);
+                        } else
+                                printf("%s%s", odelim, line);
                         goto next_line;
-                } else {                /* cut by fields */
-                        unsigned uu = 0, start = 0, end = 0, out = 0;
-                        int dcount = 0;
+                /* Cut by fields */
+                } else {
+                        unsigned next = 0, start = 0, end = 0;
+                        unsigned dcount = 0; /* we saw Nth delimiter (0 - didn't see any yet) */
+
+                        /* Blank line? Check -s (later check for -s does not catch empty lines) */
+                        if (linelen == 0) {
+                                if (option_mask32 & OPT_SUPPRESS)
+                                        goto next_line;
+                        }
+
+                        if (!odelim)
+                                odelim = "\t";
+                        first_print = 1;
 
-#if ENABLE_PLATFORM_MINGW32
-                        /* An empty line can't contain a delimiter */
-                        if (linelen == 0 && (option_mask32 & CUT_OPT_SUPPRESS_FLGS))
-                                goto next_line;
-#endif
                         /* Loop through bytes, finding next delimiter */
                         for (;;) {
                                 /* End of current range? */
-                                if (end == linelen || dcount > cut_lists[cl_pos].endpos) {
-                                        if (++cl_pos >= nlists) break;
-                                        if (option_mask32 & CUT_OPT_NOSORT_FLGS)
-                                                start = dcount = uu = 0;
-                                        end = 0;
+                                if (end == linelen || dcount > cut_list[cl_pos].endpos) {
+ end_of_range:
+                                        cl_pos++;
+                                        if (END_OF_LIST(cut_list[cl_pos]))
+                                                break;
+                                        if (option_mask32 & OPT_NOSORT)
+                                                start = dcount = next = 0;
+                                        end = 0; /* (why?) */
+                                        //bb_error_msg("End of current range");
                                 }
                                 /* End of current line? */
-                                if (uu == linelen) {
-                                        /* If we've seen no delimiters, check -s */
-                                        if (!cl_pos && !dcount && !shoe) {
-                                                if (option_mask32 & CUT_OPT_SUPPRESS_FLGS)
+                                if (next == linelen) {
+                                        end = linelen; /* print up to end */
+                                        /* If we've seen no delimiters, and no -D, check -s */
+                                        if (!(option_mask32 & OPT_NOSORT) && cl_pos == 0 && dcount == 0) {
+                                                if (option_mask32 & OPT_SUPPRESS)
                                                         goto next_line;
-                                        } else if (dcount < cut_lists[cl_pos].startpos)
-                                                start = linelen;
-                                        end = linelen;
+                                                /* else: will print entire line */
+                                        } else if (dcount < cut_list[cl_pos].startpos) {
+                                                /* echo 1.2 | cut -d. -f1,3: prints "1", not "1." */
+                                                //break;
+                                                /* ^^^ this fails a case with -D:
+                                                 * echo 1 2 | cut -DF 1,3,2:
+                                                 * do not end line processing when didn't find field#3
+                                                 */
+                                                //if (option_mask32 & OPT_NOSORT) - no, just do it always
+                                                goto end_of_range;
+                                        }
+                                        //bb_error_msg("End of current line: s:%d e:%d", start, end);
                                 } else {
                                         /* Find next delimiter */
-                                        if (shoe) {
-                                                regmatch_t rr = {-1, -1};
-
-                                                if (!regexec(&reg, line+uu, 1, &rr, REG_NOTBOL|REG_NOTEOL)) {
-                                                        end = uu + rr.rm_so;
-                                                        uu += rr.rm_eo;
-                                                } else {
-                                                        uu = linelen;
+#if ENABLE_FEATURE_CUT_REGEX
+                                        if (opt_REGEX) {
+                                                regmatch_t rr;
+                                                regex_t *reg = (void*) delim;
+
+                                                if (regexec(reg, line + next, 1, &rr, REG_NOTBOL|REG_NOTEOL) != 0) {
+                                                        /* not found, go to "end of line" logic */
+                                                        next = linelen;
                                                         continue;
                                                 }
-                                        } else if (line[end = uu++] != *delim)
-                                                continue;
-
-                                        /* Got delimiter. Loop if not yet within range. */
-                                        if (dcount++ < cut_lists[cl_pos].startpos) {
-                                                start = uu;
+                                                end = next + rr.rm_so;
+                                                next += (rr.rm_eo ? rr.rm_eo : 1);
+                                                /* ^^^ advancing by at least 1 prevents infinite loops */
+                                                /* testcase: echo "no at sign" | cut -d'@*' -F 1- */
+                                        } else
+#endif
+                                        {
+                                                end = next++;
+                                                if (line[end] != *delim)
+                                                        continue;
+                                        }
+                                        /* Got delimiter */
+                                        dcount++;
+                                        if (dcount <= cut_list[cl_pos].startpos) {
+                                                /* Not yet within range - loop */
+                                                start = next;
                                                 continue;
                                         }
+                                        /* -F N-M preserves intermediate delimiters: */
+                                        //printf "1 2  3  4  5  6  7\n" | toybox cut -O: -F2,4-6,7
+                                        //2:4  5  6:7
+                                        if (opt_REGEX && dcount <= cut_list[cl_pos].endpos)
+                                                continue;
+// NB: toybox does the above for -f too, but it's a compatibility bug:
+//printf "1 2 3 4 5 6 7 8\n" | toybox cut -d' ' -O: -f2,4-6,7
+//2:4 5 6:7  // WRONG!
+//printf "1 2 3 4 5 6 7 8\n" | cut -d' ' --output-delimiter=: -f2,4-6,7
+//2:4:5:6:7  // GNU coreutils 9.1
                                 }
-                                if (end != start || !shoe)
-                                        printf("%s%.*s", out++ ? odelim : "", end-start, line + start);
-                                start = uu;
-                                if (!dcount)
-                                        break;
-                        }
+#if ENABLE_FEATURE_CUT_REGEX
+                                if (end != start || !opt_REGEX)
+#endif
+                                {
+                                        if (first_print) {
+                                                first_print = 0;
+                                                printf("%.*s", end - start, line + start);
+                                        } else
+                                                printf("%s%.*s", odelim, end - start, line + start);
+                                }
+                                start = next;
+                                //if (dcount == 0)
+                                //      break; - why?
+                        } /* byte loop */
                 }
                 /* if we printed anything, finish with newline */
                 putchar('\n');
  next_line:
-                linenum++;
-                free(printed);
-                free(orig_line);
-        }
+                free(line);
+        } /* while (got line) */
+
+        /* For -d$'\n' --output-delimiter=^, the overall output is still terminated with \n, not ^ */
+        if (!opt_REGEX && *delim == '\n' && !first_print)
+                putchar('\n');
 }
 
 int cut_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int cut_main(int argc UNUSED_PARAM, char **argv)
 {
-        /* growable array holding a series of lists */
-        struct cut_list *cut_lists = NULL;
-        unsigned nlists = 0;    /* number of elements in above list */
-        char *sopt, *ltok;
+        /* growable array holding a series of ranges */
+        struct cut_range *cut_list = NULL;
+        unsigned nranges = 0;   /* number of elements in above list */
+        char *LIST, *ltok;
         const char *delim = NULL;
         const char *odelim = NULL;
         unsigned opt;
+#if ENABLE_FEATURE_CUT_REGEX
+        regex_t reg;
+#endif
+#if ENABLE_LONG_OPTS
+        static const char cut_longopts[] ALIGN1 =
+                "output-delimiter\0" Required_argument "O"
+                ;
+#endif
 
 #define ARG "bcf"IF_FEATURE_CUT_REGEX("F")
-        opt = getopt32(argv, "^"
+#if ENABLE_LONG_OPTS
+        opt = getopt32long
+#else
+        opt = getopt32
+#endif
+                (argv, "^"
                         OPT_STR  // = "b:c:f:d:O:sD"IF_FEATURE_CUT_REGEX("F:")"n"
-                        "\0" "b--"ARG":c--"ARG":f--"ARG IF_FEATURE_CUT_REGEX("F--"ARG),
-                        &sopt, &sopt, &sopt, &delim, &odelim IF_FEATURE_CUT_REGEX(, &sopt)
-        );
-        if (!delim || !*delim)
-                delim = (opt & CUT_OPT_REGEX_FLGS) ? "[[:space:]]+" : "\t";
-        if (!odelim) odelim = (opt & CUT_OPT_REGEX_FLGS) ? " " : delim;
+                        "\0" "b:c:f:" IF_FEATURE_CUT_REGEX("F:") /* one of -bcfF is required */
+                        "b--"ARG":c--"ARG":f--"ARG IF_FEATURE_CUT_REGEX(":F--"ARG), /* they are mutually exclusive */
+                IF_LONG_OPTS(cut_longopts,)
+                        &LIST, &LIST, &LIST, &delim, &odelim IF_FEATURE_CUT_REGEX(, &LIST)
+                );
+        if (!odelim)
+                odelim = (opt & OPT_REGEX) ? " " : delim;
+        if (!delim)
+                delim = (opt & OPT_REGEX) ? "[[:space:]]+" : "\t";
 
 //      argc -= optind;
         argv += optind;
-        if (!(opt & (CUT_OPT_BYTE_FLGS | CUT_OPT_CHAR_FLGS | CUT_OPT_FIELDS_FLGS | CUT_OPT_REGEX_FLGS)))
-                bb_simple_error_msg_and_die("expected a list of bytes, characters, or fields");
-
-        /*  non-field (char or byte) cutting has some special handling */
-        if (!(opt & (CUT_OPT_FIELDS_FLGS|CUT_OPT_REGEX_FLGS))) {
-                static const char _op_on_field[] ALIGN1 = " only when operating on fields";
-
-                if (opt & CUT_OPT_SUPPRESS_FLGS) {
-                        bb_error_msg_and_die
-                                ("suppressing non-delimited lines makes sense%s", _op_on_field);
-                }
-                if (opt & CUT_OPT_DELIM_FLGS) {
-                        bb_error_msg_and_die
-                                ("a delimiter may be specified%s", _op_on_field);
-                }
+        //if (!(opt & (OPT_BYTE | OPT_CHAR | OPT_FIELDS | OPT_REGEX)))
+        //      bb_simple_error_msg_and_die("expected a list of bytes, characters, or fields");
+        //^^^ handled by getopt32
+
+        /* non-field (char or byte) cutting has some special handling */
+        if (!(opt & (OPT_FIELDS|OPT_REGEX))) {
+                static const char requires_f[] ALIGN1 = " requires -f"
+                                        IF_FEATURE_CUT_REGEX(" or -F");
+                if (opt & OPT_SUPPRESS)
+                        bb_error_msg_and_die("-s%s", requires_f);
+                if (opt & OPT_DELIM)
+                        bb_error_msg_and_die("-d DELIM%s", requires_f);
         }
 
         /*
          * parse list and put values into startpos and endpos.
-         * valid list formats: N, N-, N-M, -M
-         * more than one list can be separated by commas
+         * valid range formats: N, N-, N-M, -M
+         * more than one range can be separated by commas
          */
-        {
+        /* take apart the ranges, one by one (separated with commas) */
+        while ((ltok = strsep(&LIST, ",")) != NULL) {
                 char *ntok;
-                int s = 0, e = 0;
-
-                /* take apart the lists, one by one (they are separated with commas) */
-                while ((ltok = strsep(&sopt, ",")) != NULL) {
+                int s, e;
+
+                /* it's actually legal to pass an empty list */
+                //if (!ltok[0])
+                //      continue;
+                //^^^ testcase?
+
+                /* get the start pos */
+                ntok = strsep(&ltok, "-");
+                if (!ntok[0]) {
+                        if (!ltok) /* testcase: -f '' */
+                                bb_show_usage();
+                        if (!ltok[0]) /* testcase: -f - */
+                                bb_show_usage();
+                        s = 0; /* "-M" means "1-M" */
+                } else {
+                        /* "N" or "N-[M]" */
+                        /* arrays are zero based, while the user expects
+                         * the first field/char on the line to be char #1 */
+                        s = xatoi_positive(ntok) - 1;
+                }
 
-                        /* it's actually legal to pass an empty list */
-                        if (!ltok[0])
-                                continue;
+                /* get the end pos */
+                if (!ltok) {
+                        e = s; /* "N" means "N-N" */
+                } else if (!ltok[0]) {
+                        /* "N-" means "until the end of the line" */
+                        e = INT_MAX;
+                } else {
+                        /* again, arrays are zero based, fields are 1 based */
+                        e = xatoi_positive(ltok) - 1;
+                }
 
-                        /* get the start pos */
-                        ntok = strsep(&ltok, "-");
-                        if (!ntok[0]) {
-                                s = 0;
-                        } else {
-                                s = xatoi_positive(ntok);
-                                /* account for the fact that arrays are zero based, while
-                                 * the user expects the first char on the line to be char #1 */
-#if !ENABLE_PLATFORM_MINGW32
-                                if (s != 0)
-                                        s--;
-#else
-                                s--;
-#endif
-                        }
+                if (s < 0 || e < s)
+                        bb_error_msg_and_die("invalid range %s-%s", ntok, ltok ?: ntok);
 
-                        /* get the end pos */
-                        if (ltok == NULL) {
-                                e = s;
-                        } else if (!ltok[0]) {
-                                e = INT_MAX;
-                        } else {
-                                e = xatoi_positive(ltok);
-                                /* if the user specified no end position,
-                                 * that means "til the end of the line" */
-#if !ENABLE_PLATFORM_MINGW32
-                                if (!*ltok)
-                                        e = INT_MAX;
-                                else if (e < s)
-                                        bb_error_msg_and_die("%d<%d", e, s);
-#endif
-                                e--;    /* again, arrays are zero based, lines are 1 based */
-                        }
-#if ENABLE_PLATFORM_MINGW32
-                        if (s < 0 || e < s)
-                                bb_error_msg_and_die("invalid range %s-%s", ntok, ltok ?: ntok);
-#endif
+                /* add the new range */
+                cut_list = xrealloc_vector(cut_list, 4, nranges);
+                /* NB: s is always >= 0 */
+                cut_list[nranges].startpos = s;
+                cut_list[nranges].endpos = e;
+                nranges++;
+        }
+        cut_list[nranges].startpos = UINT_MAX; /* end indicator */
 
-                        /* add the new list */
-                        cut_lists = xrealloc_vector(cut_lists, 4, nlists);
-                        /* NB: startpos is always >= 0 */
-                        cut_lists[nlists].startpos = s;
-                        cut_lists[nlists].endpos = e;
-                        nlists++;
-                }
+        /* make sure we got some cut positions out of all that */
+        //if (nranges == 0)
+        //      bb_simple_error_msg_and_die("missing list of positions");
+        //^^^ this is impossible since one of -bcfF is required,
+        // they populate LIST with non-NULL string and when it is parsed,
+        // cut_list[] gets at least one element.
 
-                /* make sure we got some cut positions out of all that */
-                if (nlists == 0)
-                        bb_simple_error_msg_and_die("missing list of positions");
+        /* now that the lists are parsed, we need to sort them to make life
+         * easier on us when it comes time to print the chars / fields / lines
+         */
+        if (!(opt & OPT_NOSORT))
+                qsort(cut_list, nranges, sizeof(cut_list[0]), cmpfunc);
 
-                /* now that the lists are parsed, we need to sort them to make life
-                 * easier on us when it comes time to print the chars / fields / lines
-                 */
-                if (!(opt & CUT_OPT_NOSORT_FLGS))
-                        qsort(cut_lists, nlists, sizeof(cut_lists[0]), cmpfunc);
+#if ENABLE_FEATURE_CUT_REGEX
+        if (opt & OPT_REGEX) {
+                xregcomp(&reg, delim, REG_EXTENDED);
+                delim = (void*) &reg;
         }
+#endif
 
         {
                 exitcode_t retval = EXIT_SUCCESS;
@@ -337,12 +426,12 @@ int cut_main(int argc UNUSED_PARAM, char **argv)
                                 retval = EXIT_FAILURE;
                                 continue;
                         }
-                        cut_file(file, delim, odelim, cut_lists, nlists);
+                        cut_file(file, delim, odelim, cut_list);
                         fclose_if_not_stdin(file);
                 } while (*++argv);
 
                 if (ENABLE_FEATURE_CLEAN_UP)
-                        free(cut_lists);
+                        free(cut_list);
                 fflush_stdout_and_exit(retval);
         }
 }
diff --git a/libbb/dump.c b/libbb/dump.c
index ffc46f6a7..aa57eca8c 100644
--- a/libbb/dump.c
+++ b/libbb/dump.c
@@ -204,9 +204,11 @@ static NOINLINE void rewrite(priv_dumper_t *dumper, FS *fs)
                                 if (!e)
                                         goto DO_BAD_CONV_CHAR;
                                 pr->flags = F_INT;
-                                if (e > int_convs + 1) /* not d or i? */
-                                        pr->flags = F_UINT;
                                 byte_count_str = "\010\004\002\001";
+                                if (e > int_convs + 1) { /* not d or i? */
+                                        pr->flags = F_UINT;
+                                        byte_count_str++;
+                                }
                                 goto DO_BYTE_COUNT;
                         } else
                         if (strchr(int_convs, *p1)) { /* %d etc */
diff --git a/libbb/getopt32.c b/libbb/getopt32.c
index 56040e150..76d29d5eb 100644
--- a/libbb/getopt32.c
+++ b/libbb/getopt32.c
@@ -93,7 +93,7 @@ getopt32(char **argv, const char *applet_opts, ...)
 
  "!"    If the first character in the applet_opts string is a '!',
         report bad options, missing required options,
-        inconsistent options with all-ones return value (instead of abort.
+        inconsistent options with all-ones return value instead of aborting.
 
  "+"    If the first character in the applet_opts string is a plus,
         then option processing will stop as soon as a non-option is
@@ -265,7 +265,7 @@ Special characters:
         for "long options only" cases, such as tar --exclude=PATTERN,
         wget --header=HDR cases.
 
- "a?b"  A "?" between an option and a group of options means that
+ "a?bc" A "?" between an option and a group of options means that
         at least one of them is required to occur if the first option
         occurs in preceding command line arguments.
 
@@ -348,9 +348,6 @@ vgetopt32(char **argv, const char *applet_opts, const char *applet_long_options,
         unsigned trigger;
         int min_arg = 0;
         int max_arg = -1;
-        int spec_flgs = 0;
-
-#define SHOW_USAGE_IF_ERROR     1
 
         on_off = complementary;
         memset(on_off, 0, sizeof(complementary));
@@ -449,9 +446,7 @@ vgetopt32(char **argv, const char *applet_opts, const char *applet_long_options,
                         continue;
                 c = s[1];
                 if (*s == '?') {
-                        if (c < '0' || c > '9') {
-                                spec_flgs |= SHOW_USAGE_IF_ERROR;
-                        } else {
+                        if (c >= '0' && c <= '9') {
                                 max_arg = c - '0';
                                 s++;
                         }
@@ -465,8 +460,10 @@ vgetopt32(char **argv, const char *applet_opts, const char *applet_long_options,
                         continue;
                 }
                 if (*s == '=') {
-                        min_arg = max_arg = c - '0';
-                        s++;
+                        if (c >= '0' && c <= '9') {
+                                min_arg = max_arg = c - '0';
+                                s++;
+                        }
                         continue;
                 }
                 for (on_off = complementary; on_off->opt_char; on_off++)
diff --git a/runit/chpst.c b/runit/chpst.c
index 2be1a5775..4e3d613b7 100644
--- a/runit/chpst.c
+++ b/runit/chpst.c
@@ -466,7 +466,8 @@ int chpst_main(int argc UNUSED_PARAM, char **argv)
         /* nice should be done before xsetuid */
         if (opt & OPT_n) {
                 errno = 0;
-                if (nice(xatoi(nicestr)) == -1)
+                nice(xatoi(nicestr));
+                if (errno)
                         bb_simple_perror_msg_and_die("nice");
         }
 
diff --git a/shell/hush.c b/shell/hush.c
index 04dda0734..4a97293cc 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -10361,6 +10361,9 @@ int hush_main(int argc, char **argv)
                 _exit(0);
         }
         G.argv0_for_re_execing = argv[0];
+        if (G.argv0_for_re_execing[0] == '-')
+                /* reexeced hush should never be a login shell */
+                G.argv0_for_re_execing++;
 #endif
 #if ENABLE_HUSH_TRAP
 # if ENABLE_HUSH_FUNCTIONS
diff --git a/testsuite/cut.tests b/testsuite/cut.tests
index a31f41f7f..21cfea809 100755
--- a/testsuite/cut.tests
+++ b/testsuite/cut.tests
@@ -23,14 +23,30 @@ the quick brown fox jumps over the lazy dog
 
 testing "cut -b a,a,a" "cut -b 3,3,3 input" "e\np\ne\n" "$abc" ""
 
-testing "cut -b overlaps" "cut -b 1-3,2-5,7-9,9-10 input" \
-  "one:to:th\nalphabeta\nthe qick \n" "$abc" ""
-testing "-b encapsulated" "cut -b 3-8,4-6 input" "e:two:\npha:be\ne quic\n" \
-  "$abc" ""
-# --output-delimiter not implemnted (yet?)
-#testing "cut -bO overlaps" \
-#  "cut --output-delimiter ' ' -b 1-3,2-5,7-9,9-10 input" \
-#  "one:t o:th\nalpha beta\nthe q ick \n" "$abc" ""
+testing "cut -b overlaps" \
+        "cut -b 1-3,2-5,7-9,9-10 input" \
+        "\
+one:to:th
+alphabeta
+the qick \n" \
+        "$abc" ""
+testing "-b encapsulated" \
+        "cut -b 3-8,4-6 input" \
+        "\
+e:two:
+pha:be
+e quic\n" \
+        "$abc" ""
+optional LONG_OPTS
+testing "cut -b --output-delimiter overlaps" \
+        "cut --output-delimiter='^' -b 1-3,2-5,7-9,9-10 input" \
+        "\
+one:t^o:th
+alpha^beta
+the q^ick \n" \
+        "$abc" ""
+SKIP=
+
 testing "cut high-low error" "cut -b 8-3 input 2>/dev/null || echo err" "err\n" \
   "$abc" ""
 
@@ -68,10 +84,27 @@ testing "cut with -d -f( ) -s" "cut -d' ' -f3 -s input && echo yes" "yes\n" "$in
 testing "cut with -d -f(a) -s" "cut -da -f3 -s input" "n\nsium:Jim\n\ncion:Ed\n" "$input" ""
 testing "cut with -d -f(a) -s -n" "cut -da -f3 -s -n input" "n\nsium:Jim\n\ncion:Ed\n" "$input" ""
 
+input="\
+
+foo bar baz
+
+bing bong boop
+
+"
+testing "cut with -d -s omits blank lines" "cut -d' ' -f2 -s input" "bar\nbong\n" "$input" ""
+
 # substitute for awk
 optional FEATURE_CUT_REGEX
-testing "cut -DF" "cut -DF 2,7,5" \
-  "said and your\nare\nis demand. supply\nforecast :\nyou you better,\n\nEm: Took hate\n" "" \
+testing "cut -DF unordered" "cut -DF 2,7,5" \
+        "\
+said and your
+are
+is demand. supply
+forecast :
+you you better,
+
+Em: Took hate
+" "" \
 "Bother, said Pooh. It's your husband, and he has a gun.
 Cheerios are donut seeds.
 Talk is cheap because supply exceeds demand.
@@ -79,9 +112,92 @@ Weather forecast for tonight : dark.
 Apple: you can buy better, but you can't pay more.
 Subcalifragilisticexpialidocious.
 Auntie Em: Hate you, hate Kansas. Took the dog. Dorothy."
+
+# No delimiter found: print entire line regardless of -F RANGES
+testing "cut -F1" "cut -d: -F1" \
+        "the_only_field\n" "" \
+        "the_only_field\n"
+testing "cut -F2" "cut -d: -F2" \
+        "the_only_field\n" "" \
+        "the_only_field\n"
+# No delimiter found and -s: skip entire line
+testing "cut -sF1" "cut -d: -sF1" \
+        "" "" \
+        "the_only_field\n"
+#^^^ the above is probably mishandled by toybox, it prints the line
+testing "cut -sF2" "cut -d: -sF2" \
+        "" "" \
+        "the_only_field\n"
+# -D disables special handling of lines with no delimiters, the line is treated as the 1st field
+testing "cut -DF1" "cut -d: -DF1" \
+        "the_only_field\n" "" \
+        "the_only_field\n"
+testing "cut -DF2" "cut -d: -DF2" \
+        "\n" "" \
+        "the_only_field\n"
+
+optional FEATURE_CUT_REGEX LONG_OPTS
+testing "cut -F preserves intermediate delimiters" \
+        "cut --output-delimiter=: -F2,4-6,7" \
+        "2:4            5  6:7\n" \
+        "" "1 2  3  4\t\t5  6  7 8\n"
+SKIP=
+
+optional LONG_OPTS
+testing "cut -f does not preserve intermediate delimiters" \
+        "cut --output-delimiter=: -d' ' -f2,4-6,7" \
+        "2:4:5:6:7\n" \
+        "" "1 2 3 4 5 6 7 8\n"
+SKIP=
+
+testing "cut empty field" "cut -d ':' -f 1-3" \
+        "a::b\n" \
+        "" "a::b\n"
+testing "cut empty field 2" "cut -d ':' -f 3-5" \
+        "b::c\n" \
+        "" "a::b::c:d\n"
+testing "cut non-existing field" "cut -d ':' -f1,3" \
+        "1\n" \
+        "" "1:\n"
+
+# cut -d$'\n' has a special meaning: "select input lines".
+# I didn't find any documentation for this feature.
+testing "cut -dNEWLINE" \
+        "cut -d'
+' -f4,2,6-8" \
+        "2\n4\n6\n7\n" \
+        "" "1\n2\n3\n4\n5\n6\n7"
+
+optional LONG_OPTS
+testing "cut -dNEWLINE --output-delimiter" \
+        "cut -d'
+' --output-delimiter=@@ -f4,2,6-8" \
+        "2@@4@@6@@7\n" \
+        "" "1\n2\n3\n4\n5\n6\n7"
+
+testing "cut -dNEWLINE --output-delimiter 2" \
+        "cut -d'
+' --output-delimiter=@@ -f4,2,6-8" \
+        "2@@4@@6@@7\n" \
+        "" "1\n2\n3\n4\n5\n6\n7\n"
+
+testing "cut -dNEWLINE --output-delimiter EMPTY_INPUT" \
+        "cut -d'
+' --output-delimiter=@@ -f4,2,6-8" \
+        "" \
+        "" ""
 SKIP=
 
-testing "cut empty field" "cut -d ':' -f 1-3" "a::b\n" "" "a::b\n"
-testing "cut empty field 2" "cut -d ':' -f 3-5" "b::c\n" "" "a::b::c:d\n"
+# This seems to work as if delimiter is never found.
+# We test here that -d '' does *not* operate as if there was no -d
+# and delimiter has defaulted to TAB:
+testing "cut -d EMPTY" \
+        "cut -d '' -f2-" \
+        "1 2\t3 4 5\n" \
+        "" "1 2\t3 4 5\n"
+testing "cut -d EMPTY -s" \
+        "cut -d '' -f2- -s" \
+        "" \
+        "" "1 2\t3 4 5\n"
 
 exit $FAILCOUNT
diff --git a/testsuite/hexdump.tests b/testsuite/hexdump.tests
index be0379cfc..517ec508b 100755
--- a/testsuite/hexdump.tests
+++ b/testsuite/hexdump.tests
@@ -82,4 +82,10 @@ testing "hexdump -e /2 %d" \
 "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"\
 "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"\
 
+testing "hexdump -n4 -e '\"%u\"'" \
+        "hexdump -n4 -e '\"%u\"'" \
+        "12345678" \
+        "" \
+        "\x4e\x61\xbc\x00AAAA"
+
 exit $FAILCOUNT