3 files changed, 166 insertions, 170 deletions

diff --git a/editors/awk.c b/editors/awk.c
index 71abca215..42f6ef866 100644
--- a/editors/awk.c
+++ b/editors/awk.c
@@ -696,6 +696,10 @@ static char nextchar(char **s)
         pps = *s;
         if (c == '\\')
                 c = bb_process_escape_sequence((const char**)s);
+        /* Example awk statement:
+         * s = "abc\"def"
+         * we must treat \" as "
+         */
         if (c == '\\' && *s == pps) { /* unrecognized \z? */
                 c = *(*s); /* yes, fetch z */
                 if (c)
@@ -704,6 +708,15 @@ static char nextchar(char **s)
         return c;
 }
 
+/* TODO: merge with strcpy_and_process_escape_sequences()?
+ */
+static void unescape_string_in_place(char *s1)
+{
+        char *s = s1;
+        while ((*s1 = nextchar(&s)) != '\0')
+                s1++;
+}
+
 static ALWAYS_INLINE int isalnum_(int c)
 {
         return (isalnum(c) || c == '_');
@@ -1799,6 +1812,18 @@ static void handle_special(var *v)
                 is_f0_split = FALSE;
 
         } else if (v == intvar[FS]) {
+                /*
+                 * The POSIX-2008 standard says that changing FS should have no effect on the
+                 * current input line, but only on the next one. The language is:
+                 *
+                 * > Before the first reference to a field in the record is evaluated, the record
+                 * > shall be split into fields, according to the rules in Regular Expressions,
+                 * > using the value of FS that was current at the time the record was read.
+                 *
+                 * So, split up current line before assignment to FS:
+                 */
+                split_f0();
+
                 mk_splitter(getvar_s(v), &fsplitter);
 
         } else if (v == intvar[RS]) {
@@ -2992,7 +3017,7 @@ static int awk_exit(int r)
  * otherwise return 0 */
 static int is_assignment(const char *expr)
 {
-        char *exprc, *val, *s, *s1;
+        char *exprc, *val;
 
         if (!isalnum_(*expr) || (val = strchr(expr, '=')) == NULL) {
                 return FALSE;
@@ -3002,10 +3027,7 @@ static int is_assignment(const char *expr)
         val = exprc + (val - expr);
         *val++ = '\0';
 
-        s = s1 = val;
-        while ((*s1 = nextchar(&s)) != '\0')
-                s1++;
-
+        unescape_string_in_place(val);
         setvar_u(newvar(exprc), val);
         free(exprc);
         return TRUE;
@@ -3118,8 +3140,10 @@ int awk_main(int argc, char **argv)
         opt = getopt32(argv, "F:v:f:W:", &opt_F, &list_v, &list_f, NULL);
         argv += optind;
         argc -= optind;
-        if (opt & 0x1)
-                setvar_s(intvar[FS], opt_F); // -F
+        if (opt & 0x1) { /* -F */
+                unescape_string_in_place(opt_F);
+                setvar_s(intvar[FS], opt_F);
+        }
         while (list_v) { /* -v */
                 if (!is_assignment(llist_pop(&list_v)))
                         bb_show_usage();
diff --git a/editors/sed.c b/editors/sed.c
index a2df93165..070af611a 100644
--- a/editors/sed.c
+++ b/editors/sed.c
@@ -53,7 +53,9 @@
  * Todo:
  * - Create a wrapper around regex to make libc's regex conform with sed
  *
- * Reference http://www.opengroup.org/onlinepubs/007904975/utilities/sed.html
+ * Reference
+ * http://www.opengroup.org/onlinepubs/007904975/utilities/sed.html
+ * http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html
  */
 
 //usage:#define sed_trivial_usage
@@ -63,7 +65,7 @@
 //usage:       "        -e CMD  Add CMD to sed commands to be executed"
 //usage:     "\n        -f FILE Add FILE contents to sed commands to be executed"
 //usage:     "\n        -i[SFX] Edit files in-place (otherwise sends to stdout)"
-//usage:     "\n                Optionally backs files up, appending SFX"
+//usage:     "\n                Optionally back files up, appending SFX"
 //usage:     "\n        -n      Suppress automatic printing of pattern space"
 //usage:     "\n        -r      Use extended regex syntax"
 //usage:     "\n"
@@ -492,8 +494,10 @@ static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
         }
         /* handle edit cmds: (a)ppend, (i)nsert, and (c)hange */
         else if (idx <= IDX_c) { /* a,i,c */
-                if ((sed_cmd->end_line || sed_cmd->end_match) && sed_cmd->cmd != 'c')
-                        bb_error_msg_and_die("only a beginning address can be specified for edit commands");
+                if (idx < IDX_c) { /* a,i */
+                        if (sed_cmd->end_line || sed_cmd->end_match)
+                                bb_error_msg_and_die("command '%c' uses only one address", sed_cmd->cmd);
+                }
                 for (;;) {
                         if (*cmdstr == '\n' || *cmdstr == '\\') {
                                 cmdstr++;
@@ -510,8 +514,10 @@ static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
         }
         /* handle file cmds: (r)ead */
         else if (idx <= IDX_w) { /* r,w */
-                if (sed_cmd->end_line || sed_cmd->end_match)
-                        bb_error_msg_and_die("command only uses one address");
+                if (idx < IDX_w) { /* r */
+                        if (sed_cmd->end_line || sed_cmd->end_match)
+                                bb_error_msg_and_die("command '%c' uses only one address", sed_cmd->cmd);
+                }
                 cmdstr += parse_file_cmd(/*sed_cmd,*/ cmdstr, &sed_cmd->string);
                 if (sed_cmd->cmd == 'w') {
                         sed_cmd->sw_file = xfopen_for_write(sed_cmd->string);
@@ -673,7 +679,7 @@ static void do_subst_w_backrefs(char *line, char *replace)
 
         /* go through the replacement string */
         for (i = 0; replace[i]; i++) {
-                /* if we find a backreference (\1, \2, etc.) print the backref'ed * text */
+                /* if we find a backreference (\1, \2, etc.) print the backref'ed text */
                 if (replace[i] == '\\') {
                         unsigned backref = replace[++i] - '0';
                         if (backref <= 9) {
@@ -707,8 +713,10 @@ static void do_subst_w_backrefs(char *line, char *replace)
 static int do_subst_command(sed_cmd_t *sed_cmd, char **line_p)
 {
         char *line = *line_p;
-        int altered = 0;
         unsigned match_count = 0;
+        bool altered = 0;
+        bool prev_match_empty = 1;
+        bool tried_at_eol = 0;
         regex_t *current_regex;
 
         current_regex = sed_cmd->sub_match;
@@ -735,50 +743,75 @@ static int do_subst_command(sed_cmd_t *sed_cmd, char **line_p)
 
         /* Now loop through, substituting for matches */
         do {
+                int start = G.regmatch[0].rm_so;
+                int end = G.regmatch[0].rm_eo;
                 int i;
 
-                /* Work around bug in glibc regexec, demonstrated by:
-                 * echo " a.b" | busybox sed 's [^ .]* x g'
-                 * The match_count check is so not to break
-                 * echo "hi" | busybox sed 's/^/!/g'
-                 */
-                if (!G.regmatch[0].rm_so && !G.regmatch[0].rm_eo && match_count) {
-                        pipe_putc(*line++);
-                        goto next;
-                }
-
                 match_count++;
 
                 /* If we aren't interested in this match, output old line to
-                   end of match and continue */
+                 * end of match and continue */
                 if (sed_cmd->which_match
                  && (sed_cmd->which_match != match_count)
                 ) {
-                        for (i = 0; i < G.regmatch[0].rm_eo; i++)
+                        for (i = 0; i < end; i++)
+                                pipe_putc(*line++);
+                        /* Null match? Print one more char */
+                        if (start == end && *line)
                                 pipe_putc(*line++);
                         goto next;
                 }
 
-                /* print everything before the match */
-                for (i = 0; i < G.regmatch[0].rm_so; i++)
+                /* Print everything before the match */
+                for (i = 0; i < start; i++)
                         pipe_putc(line[i]);
 
-                /* then print the substitution string */
-                do_subst_w_backrefs(line, sed_cmd->string);
+                /* Then print the substitution string,
+                 * unless we just matched empty string after non-empty one.
+                 * Example: string "cccd", pattern "c*", repl "R":
+                 * result is "RdR", not "RRdR": first match "ccc",
+                 * second is "" before "d", third is "" after "d".
+                 * Second match is NOT replaced!
+                 */
+                if (prev_match_empty || start != 0 || start != end) {
+                        //dbg("%d %d %d", prev_match_empty, start, end);
+                        dbg("inserting replacement at %d in '%s'", start, line);
+                        do_subst_w_backrefs(line, sed_cmd->string);
+                        /* Flag that something has changed */
+                        altered = 1;
+                } else {
+                        dbg("NOT inserting replacement at %d in '%s'", start, line);
+                }
+
+                /* If matched string is empty (f.e. "c*" pattern),
+                 * copy verbatim one char after it before attempting more matches
+                 */
+                prev_match_empty = (start == end);
+                if (prev_match_empty) {
+                        if (!line[end]) {
+                                tried_at_eol = 1;
+                        } else {
+                                pipe_putc(line[end]);
+                                end++;
+                        }
+                }
 
-                /* advance past the match */
-                line += G.regmatch[0].rm_eo;
-                /* flag that something has changed */
-                altered++;
+                /* Advance past the match */
+                dbg("line += %d", end);
+                line += end;
 
                 /* if we're not doing this globally, get out now */
                 if (sed_cmd->which_match != 0)
                         break;
  next:
-                if (*line == '\0')
-                        break;
+                /* Exit if we are at EOL and already tried matching at it */
+                if (*line == '\0') {
+                        if (tried_at_eol)
+                                break;
+                        tried_at_eol = 1;
+                }
 
-//maybe (G.regmatch[0].rm_eo ? REG_NOTBOL : 0) instead of unconditional REG_NOTBOL?
+//maybe (end ? REG_NOTBOL : 0) instead of unconditional REG_NOTBOL?
         } while (regexec(current_regex, line, 10, G.regmatch, REG_NOTBOL) != REG_NOMATCH);
 
         /* Copy rest of string into output pipeline */
@@ -1127,7 +1160,7 @@ static void process_files(void)
                 case 's':
                         if (!do_subst_command(sed_cmd, &pattern_space))
                                 break;
-                        dbg("do_subst_command succeeeded:'%s'", pattern_space);
+                        dbg("do_subst_command succeeded:'%s'", pattern_space);
                         substituted |= 1;
 
                         /* handle p option */
diff --git a/editors/vi.c b/editors/vi.c
index 6fae221ac..821583ec1 100644
--- a/editors/vi.c
+++ b/editors/vi.c
@@ -136,14 +136,6 @@
 //config:         cursor position using "ESC [ 6 n" escape sequence, then read stdin.
 //config:
 //config:         This is not clean but helps a lot on serial lines and such.
-//config:
-//config:config FEATURE_VI_OPTIMIZE_CURSOR
-//config:       bool "Optimize cursor movement"
-//config:       default y
-//config:       depends on VI
-//config:       help
-//config:         This will make the cursor movement faster, but requires more memory
-//config:         and it makes the applet a tiny bit larger.
 
 //applet:IF_VI(APPLET(vi, BB_DIR_BIN, BB_SUID_DROP))
 
@@ -154,12 +146,12 @@
 //usage:#define vi_full_usage "\n\n"
 //usage:       "Edit FILE\n"
 //usage:        IF_FEATURE_VI_COLON(
-//usage:     "\n        -c      Initial command to run ($EXINIT also available)"
+//usage:     "\n        -c CMD  Initial command to run ($EXINIT also available)"
 //usage:        )
 //usage:        IF_FEATURE_VI_READONLY(
 //usage:     "\n        -R      Read-only"
 //usage:        )
-//usage:     "\n        -H      Short help regarding available features"
+//usage:     "\n        -H      List available features"
 
 #include "libbb.h"
 /* Should be after libbb.h: on some systems regex.h needs sys/types.h: */
@@ -202,20 +194,29 @@ enum {
         MAX_SCR_ROWS = CONFIG_FEATURE_VI_MAX_LEN,
 };
 
-/* vt102 typical ESC sequence */
-/* terminal standout start/normal ESC sequence */
-#define SOs "\033[7m"
-#define SOn "\033[0m"
-/* terminal bell sequence */
-#define bell "\007"
-/* Clear-end-of-line and Clear-end-of-screen ESC sequence */
-#define Ceol "\033[K"
-#define Ceos "\033[J"
-/* Cursor motion arbitrary destination ESC sequence */
-#define CMrc "\033[%u;%uH"
-/* Cursor motion up and down ESC sequence */
-#define CMup "\033[A"
-#define CMdown "\n"
+/* VT102 ESC sequences.
+ * See "Xterm Control Sequences"
+ * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+ */
+/* Inverse/Normal text */
+#define ESC_BOLD_TEXT "\033[7m"
+#define ESC_NORM_TEXT "\033[0m"
+/* Bell */
+#define ESC_BELL "\007"
+/* Clear-to-end-of-line */
+#define ESC_CLEAR2EOL "\033[K"
+/* Clear-to-end-of-screen.
+ * (We use default param here.
+ * Full sequence is "ESC [ <num> J",
+ * <num> is 0/1/2 = "erase below/above/all".)
+ */
+#define ESC_CLEAR2EOS "\033[J"
+/* Cursor to given coordinate (1,1: top left) */
+#define ESC_SET_CURSOR_POS "\033[%u;%uH"
+//UNUSED
+///* Cursor up and down */
+//#define ESC_CURSOR_UP "\033[A"
+//#define ESC_CURSOR_DOWN "\n"
 
 #if ENABLE_FEATURE_VI_DOT_CMD || ENABLE_FEATURE_VI_YANKMARK
 // cmds modifying text[]
@@ -303,9 +304,6 @@ struct globals {
         int lmc_len;             // length of last_modifying_cmd
         char *ioq, *ioq_start;   // pointer to string for get_one_char to "read"
 #endif
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-        int last_row;            // where the cursor was last moved to
-#endif
 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
         int my_pid;
 #endif
@@ -389,7 +387,6 @@ struct globals {
 #define lmc_len                 (G.lmc_len            )
 #define ioq                     (G.ioq                )
 #define ioq_start               (G.ioq_start          )
-#define last_row                (G.last_row           )
 #define my_pid                  (G.my_pid             )
 #define last_search_pattern     (G.last_search_pattern)
 
@@ -470,10 +467,7 @@ static int file_size(const char *);   // what is the byte size of "fn"
 // file_insert might reallocate text[]!
 static int file_insert(const char *, char *, int);
 static int file_write(char *, char *, char *);
-#if !ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-#define place_cursor(a, b, optimize) place_cursor(a, b)
-#endif
-static void place_cursor(int, int, int);
+static void place_cursor(int, int);
 static void screen_erase(void);
 static void clear_to_eol(void);
 static void clear_to_eos(void);
@@ -558,7 +552,8 @@ int vi_main(int argc, char **argv)
         }
 #endif
 
-        vi_setops = VI_AUTOINDENT | VI_SHOWMATCH | VI_IGNORECASE;
+        // autoindent is not default in vim 7.3
+        vi_setops = /*VI_AUTOINDENT |*/ VI_SHOWMATCH | VI_IGNORECASE;
         //  1-  process $HOME/.exrc file (not inplemented yet)
         //  2-  process EXINIT variable from environment
         //  3-  process command line args
@@ -584,7 +579,7 @@ int vi_main(int argc, char **argv)
 #if ENABLE_FEATURE_VI_COLON
                 case 'c':               // cmd line vi command
                         if (*optarg)
-                                initial_cmds[initial_cmds[0] != 0] = xstrndup(optarg, MAX_INPUT_LEN);
+                                initial_cmds[initial_cmds[0] != NULL] = xstrndup(optarg, MAX_INPUT_LEN);
                         break;
 #endif
                 case 'H':
@@ -599,15 +594,19 @@ int vi_main(int argc, char **argv)
         // The argv array can be used by the ":next"  and ":rewind" commands
         argv += optind;
         argc -= optind;
-        save_argc = argc;
-        optind = 0;
 
         //----- This is the main file handling loop --------------
+        save_argc = argc;
+        optind = 0;
+        // "Save cursor, use alternate screen buffer, clear screen"
+        write1("\033[?1049h");
         while (1) {
                 edit_file(argv[optind]); /* param might be NULL */
                 if (++optind >= argc)
                         break;
         }
+        // "Use normal screen buffer, restore cursor"
+        write1("\033[?1049l");
         //-----------------------------------------------------------
 
         return 0;
@@ -1191,7 +1190,7 @@ static void colon(char *buf)
                 char *argp;
 #endif
                 i = 0;                  // offset into args
-                // only blank is regarded as args delmiter. What about tab '\t' ?
+                // only blank is regarded as args delimiter. What about tab '\t'?
                 if (!args[0] || strcasecmp(args, "all") == 0) {
                         // print out values of all options
 #if ENABLE_FEATURE_VI_SETOPTS
@@ -2176,7 +2175,7 @@ static void show_help(void)
         "\n\tPattern searches with / and ?"
 #endif
 #if ENABLE_FEATURE_VI_DOT_CMD
-        "\n\tLast command repeat with \'.\'"
+        "\n\tLast command repeat with ."
 #endif
 #if ENABLE_FEATURE_VI_YANKMARK
         "\n\tLine marking with 'x"
@@ -2187,7 +2186,7 @@ static void show_help(void)
         //redundant: usage text says this too: "\n\tReadonly with -R command line arg"
 #endif
 #if ENABLE_FEATURE_VI_SET
-        "\n\tSome colon mode commands with \':\'"
+        "\n\tSome colon mode commands with :"
 #endif
 #if ENABLE_FEATURE_VI_SETOPTS
         "\n\tSettable options with \":set\""
@@ -2601,107 +2600,56 @@ static int file_write(char *fn, char *first, char *last)
 //  23,0    ...     23,79   <- status line
 
 //----- Move the cursor to row x col (count from 0, not 1) -------
-static void place_cursor(int row, int col, int optimize)
+static void place_cursor(int row, int col)
 {
-        char cm1[sizeof(CMrc) + sizeof(int)*3 * 2];
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-        enum {
-                SZ_UP = sizeof(CMup),
-                SZ_DN = sizeof(CMdown),
-                SEQ_SIZE = SZ_UP > SZ_DN ? SZ_UP : SZ_DN,
-        };
-        char cm2[SEQ_SIZE * 5 + 32]; // bigger than worst case size
-#endif
-        char *cm;
+        char cm1[sizeof(ESC_SET_CURSOR_POS) + sizeof(int)*3 * 2];
 
         if (row < 0) row = 0;
         if (row >= rows) row = rows - 1;
         if (col < 0) col = 0;
         if (col >= columns) col = columns - 1;
 
-        //----- 1.  Try the standard terminal ESC sequence
-        sprintf(cm1, CMrc, row + 1, col + 1);
-        cm = cm1;
-
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-        if (optimize && col < 16) {
-                char *screenp;
-                int Rrow = last_row;
-                int diff = Rrow - row;
-
-                if (diff < -5 || diff > 5)
-                        goto skip;
-
-                //----- find the minimum # of chars to move cursor -------------
-                //----- 2.  Try moving with discreet chars (Newline, [back]space, ...)
-                cm2[0] = '\0';
-
-                // move to the correct row
-                while (row < Rrow) {
-                        // the cursor has to move up
-                        strcat(cm2, CMup);
-                        Rrow--;
-                }
-                while (row > Rrow) {
-                        // the cursor has to move down
-                        strcat(cm2, CMdown);
-                        Rrow++;
-                }
-
-                // now move to the correct column
-                strcat(cm2, "\r");                      // start at col 0
-                // just send out orignal source char to get to correct place
-                screenp = &screen[row * columns];       // start of screen line
-                strncat(cm2, screenp, col);
-
-                // pick the shortest cursor motion to send out
-                if (strlen(cm2) < strlen(cm)) {
-                        cm = cm2;
-                }
- skip: ;
-        }
-        last_row = row;
-#endif /* FEATURE_VI_OPTIMIZE_CURSOR */
-        write1(cm);
+        sprintf(cm1, ESC_SET_CURSOR_POS, row + 1, col + 1);
+        write1(cm1);
 }
 
 //----- Erase from cursor to end of line -----------------------
 static void clear_to_eol(void)
 {
-        write1(Ceol);   // Erase from cursor to end of line
+        write1(ESC_CLEAR2EOL);
 }
 
 static void go_bottom_and_clear_to_eol(void)
 {
-        place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
-        clear_to_eol(); // erase to end of line
+        place_cursor(rows - 1, 0);
+        clear_to_eol();
 }
 
 //----- Erase from cursor to end of screen -----------------------
 static void clear_to_eos(void)
 {
-        write1(Ceos);   // Erase from cursor to end of screen
+        write1(ESC_CLEAR2EOS);
 }
 
 //----- Start standout mode ------------------------------------
-static void standout_start(void) // send "start reverse video" sequence
+static void standout_start(void)
 {
-        write1(SOs);     // Start reverse video mode
+        write1(ESC_BOLD_TEXT);
 }
 
 //----- End standout mode --------------------------------------
-static void standout_end(void) // send "end reverse video" sequence
+static void standout_end(void)
 {
-        write1(SOn);     // End reverse video mode
+        write1(ESC_NORM_TEXT);
 }
 
 //----- Flash the screen  --------------------------------------
 static void flash(int h)
 {
-        standout_start();       // send "start reverse video" sequence
+        standout_start();
         redraw(TRUE);
         mysleep(h);
-        standout_end();         // send "end reverse video" sequence
+        standout_end();
         redraw(TRUE);
 }
 
@@ -2712,7 +2660,7 @@ static void Indicate_Error(void)
                 return;                 // generate a random command
 #endif
         if (!err_method) {
-                write1(bell);   // send out a bell character
+                write1(ESC_BELL);
         } else {
                 flash(10);
         }
@@ -2758,7 +2706,7 @@ static void show_status_line(void)
                         }
                         have_status_msg = 0;
                 }
-                place_cursor(crow, ccol, FALSE);        // put cursor back in correct place
+                place_cursor(crow, ccol);  // put cursor back in correct place
         }
         fflush_all();
 }
@@ -2770,12 +2718,12 @@ static void status_line_bold(const char *format, ...)
         va_list args;
 
         va_start(args, format);
-        strcpy(status_buffer, SOs);     // Terminal standout mode on
-        vsprintf(status_buffer + sizeof(SOs)-1, format, args);
-        strcat(status_buffer, SOn);     // Terminal standout mode off
+        strcpy(status_buffer, ESC_BOLD_TEXT);
+        vsprintf(status_buffer + sizeof(ESC_BOLD_TEXT)-1, format, args);
+        strcat(status_buffer, ESC_NORM_TEXT);
         va_end(args);
 
-        have_status_msg = 1 + sizeof(SOs) + sizeof(SOn) - 2;
+        have_status_msg = 1 + sizeof(ESC_BOLD_TEXT) + sizeof(ESC_NORM_TEXT) - 2;
 }
 
 // format status buffer
@@ -2807,8 +2755,8 @@ static void print_literal(char *buf, const char *s)
                 c = *s;
                 c_is_no_print = (c & 0x80) && !Isprint(c);
                 if (c_is_no_print) {
-                        strcpy(d, SOn);
-                        d += sizeof(SOn)-1;
+                        strcpy(d, ESC_NORM_TEXT);
+                        d += sizeof(ESC_NORM_TEXT)-1;
                         c = '.';
                 }
                 if (c < ' ' || c == 0x7f) {
@@ -2820,8 +2768,8 @@ static void print_literal(char *buf, const char *s)
                 *d++ = c;
                 *d = '\0';
                 if (c_is_no_print) {
-                        strcpy(d, SOs);
-                        d += sizeof(SOs)-1;
+                        strcpy(d, ESC_BOLD_TEXT);
+                        d += sizeof(ESC_BOLD_TEXT)-1;
                 }
                 if (*s == '\n') {
                         *d++ = '$';
@@ -2903,8 +2851,8 @@ static int format_edit_status(void)
 //----- Force refresh of all Lines -----------------------------
 static void redraw(int full_screen)
 {
-        place_cursor(0, 0, FALSE);      // put cursor in correct place
-        clear_to_eos();         // tell terminal to erase display
+        place_cursor(0, 0);
+        clear_to_eos();
         screen_erase();         // erase the internal screen buffer
         last_status_cksum = 0;  // force status update
         refresh(full_screen);   // this will redraw the entire display
@@ -3044,22 +2992,13 @@ static void refresh(int full_screen)
                 if (changed) {
                         // copy changed part of buffer to virtual screen
                         memcpy(sp+cs, out_buf+cs, ce-cs+1);
-
-                        // move cursor to column of first change
-                        //if (offset != old_offset) {
-                        //      // place_cursor is still too stupid
-                        //      // to handle offsets correctly
-                        //      place_cursor(li, cs, FALSE);
-                        //} else {
-                                place_cursor(li, cs, TRUE);
-                        //}
-
+                        place_cursor(li, cs);
                         // write line out to terminal
                         fwrite(&sp[cs], ce - cs + 1, 1, stdout);
                 }
         }
 
-        place_cursor(crow, ccol, TRUE);
+        place_cursor(crow, ccol);
 
         old_offset = offset;
 #undef old_offset
@@ -3229,9 +3168,9 @@ static void do_cmd(int c)
                 break;
         case 12:                        // ctrl-L  force redraw whole screen
         case 18:                        // ctrl-R  force redraw
-                place_cursor(0, 0, FALSE);      // put cursor in correct place
-                clear_to_eos(); // tel terminal to erase display
-                mysleep(10);
+                place_cursor(0, 0);
+                clear_to_eos();
+                //mysleep(10); // why???
                 screen_erase(); // erase the internal screen buffer
                 last_status_cksum = 0;  // force status update
                 refresh(TRUE);  // this will redraw the entire display
@@ -4150,7 +4089,7 @@ static void crash_test()
 
         if (msg[0]) {
                 printf("\n\n%d: \'%c\' %s\n\n\n%s[Hit return to continue]%s",
-                        totalcmds, last_input_char, msg, SOs, SOn);
+                        totalcmds, last_input_char, msg, ESC_BOLD_TEXT, ESC_NORM_TEXT);
                 fflush_all();
                 while (safe_read(STDIN_FILENO, d, 1) > 0) {
                         if (d[0] == '\n' || d[0] == '\r')