* add :help command
* :map macros
* if mark[] values were line numbers rather than pointers
- * it would be easier to change the mark when add/delete lines
+ * it would be easier to change the mark when add/delete lines
* More intelligence in refresh()
* ":r !cmd" and "!cmd" to filter text through an external command
* A true "undo" facility
//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))
//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: */
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[]
smallint cmd_mode; // 0=command 1=insert 2=replace
int file_modified; // buffer contents changed (counter, not flag!)
int last_file_modified; // = -1;
- int fn_start; // index of first cmd line file name
int save_argc; // how many file names on cmd line
int cmdcnt; // repetition count
unsigned rows, columns; // the terminal screen is this size
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
#define cmd_mode (G.cmd_mode )
#define file_modified (G.file_modified )
#define last_file_modified (G.last_file_modified )
-#define fn_start (G.fn_start )
#define save_argc (G.save_argc )
#define cmdcnt (G.cmdcnt )
#define rows (G.rows )
#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)
// 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);
static void show_status_line(void); // put a message on the bottom line
static void status_line(const char *, ...); // print to status buf
static void status_line_bold(const char *, ...);
+static void status_line_bold_errno(const char *fn);
static void not_implemented(const char *); // display "Not implemented" message
static int format_edit_status(void); // format file status on status line
static void redraw(int); // force a full screen refresh
}
#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
#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':
}
// The argv array can be used by the ":next" and ":rewind" commands
- // save optind.
- fn_start = optind; // remember first file name for :next and :rew
- save_argc = argc;
+ argv += optind;
+ argc -= optind;
//----- 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;
} else if (strncmp(cmd, "edit", i) == 0) { // Edit a file
// don't edit, if the current file has been modified
if (file_modified && !useforce) {
- status_line_bold("No write since last change (:edit! overrides)");
+ status_line_bold("No write since last change (:%s! overrides)", cmd);
goto ret;
}
if (args[0]) {
goto ret;
#if ENABLE_FEATURE_VI_YANKMARK
- if (Ureg >= 0 && Ureg < 28 && reg[Ureg] != 0) {
+ if (Ureg >= 0 && Ureg < 28) {
free(reg[Ureg]); // free orig line reg- for 'U'
- reg[Ureg]= 0;
+ reg[Ureg] = NULL;
}
- if (YDreg >= 0 && YDreg < 28 && reg[YDreg] != 0) {
+ if (YDreg >= 0 && YDreg < 28) {
free(reg[YDreg]); // free default yank/delete register
- reg[YDreg]= 0;
+ reg[YDreg] = NULL;
}
#endif
// how many lines in text[]?
li = count_lines(text, end - 1);
- status_line("\"%s\"%s"
+ status_line("'%s'%s"
IF_FEATURE_VI_READONLY("%s")
" %dL, %dC", current_filename,
(file_size(fn) < 0 ? " [New file]" : ""),
Hit_Return();
} else if (strncmp(cmd, "quit", i) == 0 // quit
|| strncmp(cmd, "next", i) == 0 // edit next file
+ || strncmp(cmd, "prev", i) == 0 // edit previous file
) {
int n;
if (useforce) {
- // force end of argv list
if (*cmd == 'q') {
+ // force end of argv list
optind = save_argc;
}
editing = 0;
}
// don't exit if the file been modified
if (file_modified) {
- status_line_bold("No write since last change (:%s! overrides)",
- (*cmd == 'q' ? "quit" : "next"));
+ status_line_bold("No write since last change (:%s! overrides)", cmd);
goto ret;
}
// are there other file to edit
status_line_bold("No more files to edit");
goto ret;
}
+ if (*cmd == 'p') {
+ // are there previous files to edit
+ if (optind < 1) {
+ status_line_bold("No previous files to edit");
+ goto ret;
+ }
+ optind -= 2;
+ }
editing = 0;
} else if (strncmp(cmd, "read", i) == 0) { // read file into text[]
fn = args;
goto ret; // nothing was inserted
// how many lines in text[]?
li = count_lines(q, q + ch - 1);
- status_line("\"%s\""
+ status_line("'%s'"
IF_FEATURE_VI_READONLY("%s")
" %dL, %dC", fn,
IF_FEATURE_VI_READONLY((readonly_mode ? " [Readonly]" : ""),)
}
} else if (strncmp(cmd, "rewind", i) == 0) { // rewind cmd line args
if (file_modified && !useforce) {
- status_line_bold("No write since last change (:rewind! overrides)");
+ status_line_bold("No write since last change (:%s! overrides)", cmd);
} else {
// reset the filenames to edit
- optind = fn_start - 1;
+ optind = -1; /* start from 0th file */
editing = 0;
}
#if ENABLE_FEATURE_VI_SET
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
#endif /* FEATURE_VI_SET */
#if ENABLE_FEATURE_VI_SEARCH
} else if (cmd[0] == 's') { // substitute a pattern with a replacement pattern
- char *ls, *F, *R;
- int gflag;
+ char *F, *R, *flags;
+ size_t len_F, len_R;
+ int gflag; // global replace flag
// F points to the "find" pattern
// R points to the "replace" pattern
- // replace the cmd line delimiters "/" with NULLs
- gflag = 0; // global replace flag
+ // replace the cmd line delimiters "/" with NULs
c = orig_buf[1]; // what is the delimiter
F = orig_buf + 2; // start of "find"
R = strchr(F, c); // middle delimiter
if (!R)
goto colon_s_fail;
+ len_F = R - F;
*R++ = '\0'; // terminate "find"
- buf1 = strchr(R, c);
- if (!buf1)
+ flags = strchr(R, c);
+ if (!flags)
goto colon_s_fail;
- *buf1++ = '\0'; // terminate "replace"
- if (*buf1 == 'g') { // :s/foo/bar/g
- buf1++;
- gflag++; // turn on gflag
- }
+ len_R = flags - R;
+ *flags++ = '\0'; // terminate "replace"
+ gflag = *flags;
+
q = begin_line(q);
if (b < 0) { // maybe :s/foo/bar/
- q = begin_line(dot); // start with cur line
- b = count_lines(text, q); // cur line number
+ q = begin_line(dot); // start with cur line
+ b = count_lines(text, q); // cur line number
}
if (e < 0)
e = b; // maybe :.s/foo/bar/
+
for (i = b; i <= e; i++) { // so, :20,23 s \0 find \0 replace \0
- ls = q; // orig line start
+ char *ls = q; // orig line start
+ char *found;
vc4:
- buf1 = char_search(q, F, FORWARD, LIMITED); // search cur line only for "find"
- if (buf1) {
+ found = char_search(q, F, FORWARD, LIMITED); // search cur line only for "find"
+ if (found) {
uintptr_t bias;
// we found the "find" pattern - delete it
- text_hole_delete(buf1, buf1 + strlen(F) - 1);
+ text_hole_delete(found, found + len_F - 1);
// inset the "replace" patern
- bias = string_insert(buf1, R); // insert the string
- buf1 += bias;
+ bias = string_insert(found, R); // insert the string
+ found += bias;
ls += bias;
/*q += bias; - recalculated anyway */
// check for "global" :s/foo/bar/g
- if (gflag == 1) {
- if ((buf1 + strlen(R)) < end_line(ls)) {
- q = buf1 + strlen(R);
+ if (gflag == 'g') {
+ if ((found + len_R) < end_line(ls)) {
+ q = found + len_R;
goto vc4; // don't let q move past cur line
}
}
}
#if ENABLE_FEATURE_VI_READONLY
if (readonly_mode && !useforce) {
- status_line_bold("\"%s\" File is read only", fn);
+ status_line_bold("'%s' is read only", fn);
goto ret;
}
#endif
}
if (l < 0) {
if (l == -1)
- status_line_bold("\"%s\" %s", fn, strerror(errno));
+ status_line_bold_errno(fn);
} else {
- status_line("\"%s\" %dL, %dC", fn, li, l);
+ status_line("'%s' %dL, %dC", fn, li, l);
if (q == text && r == end - 1 && l == ch) {
file_modified = 0;
last_file_modified = -1;
// 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;
}
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++) {
}
}
} 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--) {
dot_end(); // find NL
q = dot;
} else {
- // nothing -- this causes any other values of c to
- // represent the one-character range under the
- // cursor. this is correct for ' ' and 'l', but
- // perhaps no others.
- //
+ // nothing -- this causes any other values of c to
+ // represent the one-character range under the
+ // cursor. this is correct for ' ' and 'l', but
+ // perhaps no others.
+ //
}
if (q < p) {
t = q;
dot += bias;
end += bias;
p += bias;
+#if ENABLE_FEATURE_VI_YANKMARK
+ {
+ int i;
+ for (i = 0; i < ARRAY_SIZE(mark); i++)
+ if (mark[i])
+ mark[i] += bias;
+ }
+#endif
text = new_text;
}
memmove(p + size, p, end - size - p);
"\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"
//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\""
{
tcgetattr(0, &term_orig);
term_vi = term_orig;
- term_vi.c_lflag &= (~ICANON & ~ECHO); // leave ISIG ON- allow intr's
+ term_vi.c_lflag &= (~ICANON & ~ECHO); // leave ISIG on - allow intr's
term_vi.c_iflag &= (~IXON & ~ICRNL);
term_vi.c_oflag &= (~ONLCR);
term_vi.c_cc[VMIN] = 1;
/* Validate file */
if (stat(fn, &statbuf) < 0) {
- status_line_bold("\"%s\" %s", fn, strerror(errno));
+ status_line_bold_errno(fn);
goto fi0;
}
if (!S_ISREG(statbuf.st_mode)) {
// This is not a regular file
- status_line_bold("\"%s\" Not a regular file", fn);
+ status_line_bold("'%s' is not a regular file", fn);
goto fi0;
}
if (p < text || p > end) {
// read file to buffer
fd = open(fn, O_RDONLY);
if (fd < 0) {
- status_line_bold("\"%s\" %s", fn, strerror(errno));
+ status_line_bold_errno(fn);
goto fi0;
}
- size = statbuf.st_size;
+ size = (statbuf.st_size < INT_MAX ? (int)statbuf.st_size : INT_MAX);
p += text_hole_make(p, size);
cnt = safe_read(fd, p, size);
if (cnt < 0) {
- status_line_bold("\"%s\" %s", fn, strerror(errno));
+ status_line_bold_errno(fn);
p = text_hole_delete(p, p + size - 1); // un-do buffer insert
} else if (cnt < size) {
// There was a partial read, shrink unused space text[]
- p = text_hole_delete(p + cnt, p + (size - cnt) - 1); // un-do buffer insert
- status_line_bold("can't read all of file \"%s\"", fn);
+ p = text_hole_delete(p + cnt, p + size - 1); // un-do buffer insert
+ status_line_bold("can't read '%s'", fn);
}
if (cnt >= size)
file_modified++;
// 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);
}
return; // generate a random command
#endif
if (!err_method) {
- write1(bell); // send out a bell character
+ write1(ESC_BELL);
} else {
flash(10);
}
}
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();
}
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;
+}
+
+static void status_line_bold_errno(const char *fn)
+{
+ status_line_bold("'%s' %s", fn, strerror(errno));
}
// format status buffer
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) {
*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++ = '$';
//----- 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
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
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
end_cmd_q(); // stop adding to q
break;
case 'U': // U- Undo; replace current line with original version
- if (reg[Ureg] != 0) {
+ if (reg[Ureg] != NULL) {
p = begin_line(dot);
q = end_line(dot);
p = text_hole_delete(p, q); // delete cur line
case KEYCODE_END: // Cursor Key End
for (;;) {
dot = end_line(dot);
- if (--cmdcnt > 0)
+ if (--cmdcnt <= 0)
break;
dot_next();
}
|| strncmp(p, "q!", cnt) == 0 // delete lines
) {
if (file_modified && p[1] != '!') {
- status_line_bold("No write since last change (:quit! overrides)");
+ status_line_bold("No write since last change (:%s! overrides)", p);
} else {
editing = 0;
}
} else {
file_modified = 0;
last_file_modified = -1;
- status_line("\"%s\" %dL, %dC", current_filename, count_lines(text, end - 1), cnt);
+ status_line("'%s' %dL, %dC", current_filename, count_lines(text, end - 1), cnt);
if (p[0] == 'x' || p[1] == 'q' || p[1] == 'n'
|| p[0] == 'X' || p[1] == 'Q' || p[1] == 'N'
) {
}
if (file_modified) {
if (ENABLE_FEATURE_VI_READONLY && readonly_mode) {
- status_line_bold("\"%s\" File is read only", current_filename);
+ status_line_bold("'%s' is read only", current_filename);
break;
}
cnt = file_write(current_filename, text, end - 1);
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')