editors/vi.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * tiny vi.c: A small 'vi' clone
   4  * Copyright (C) 2000, 2001 Sterling Huxley <sterling@europa.com>
   5  *
   6  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   7  */
   8 /*
   9  * Things To Do:
  10  *      EXINIT
  11  *      $HOME/.exrc  and  ./.exrc
  12  *      add magic to search     /foo.*bar
  13  *      add :help command
  14  *      :map macros
  15  *      if mark[] values were line numbers rather than pointers
  16  *      it would be easier to change the mark when add/delete lines
  17  *      More intelligence in refresh()
  18  *      ":r !cmd"  and  "!cmd"  to filter text through an external command
  19  *      An "ex" line oriented mode- maybe using "cmdedit"
  20  */
  21 //config:config VI
  22 //config:       bool "vi (23 kb)"
  23 //config:       default y
  24 //config:       help
  25 //config:       'vi' is a text editor. More specifically, it is the One True
  26 //config:       text editor <grin>. It does, however, have a rather steep
  27 //config:       learning curve. If you are not already comfortable with 'vi'
  28 //config:       you may wish to use something else.
  29 //config:
  30 //config:config FEATURE_VI_MAX_LEN
  31 //config:       int "Maximum screen width"
  32 //config:       range 256 16384
  33 //config:       default 4096
  34 //config:       depends on VI
  35 //config:       help
  36 //config:       Contrary to what you may think, this is not eating much.
  37 //config:       Make it smaller than 4k only if you are very limited on memory.
  38 //config:
  39 //config:config FEATURE_VI_8BIT
  40 //config:       bool "Allow to display 8-bit chars (otherwise shows dots)"
  41 //config:       default n
  42 //config:       depends on VI
  43 //config:       help
  44 //config:       If your terminal can display characters with high bit set,
  45 //config:       you may want to enable this. Note: vi is not Unicode-capable.
  46 //config:       If your terminal combines several 8-bit bytes into one character
  47 //config:       (as in Unicode mode), this will not work properly.
  48 //config:
  49 //config:config FEATURE_VI_COLON
  50 //config:       bool "Enable \":\" colon commands (no \"ex\" mode)"
  51 //config:       default y
  52 //config:       depends on VI
  53 //config:       help
  54 //config:       Enable a limited set of colon commands. This does not
  55 //config:       provide an "ex" mode.
  56 //config:
  57 //config:config FEATURE_VI_YANKMARK
  58 //config:       bool "Enable yank/put commands and mark cmds"
  59 //config:       default y
  60 //config:       depends on VI
  61 //config:       help
  62 //config:       This enables you to use yank and put, as well as mark.
  63 //config:
  64 //config:config FEATURE_VI_SEARCH
  65 //config:       bool "Enable search and replace cmds"
  66 //config:       default y
  67 //config:       depends on VI
  68 //config:       help
  69 //config:       Select this if you wish to be able to do search and replace.
  70 //config:
  71 //config:config FEATURE_VI_REGEX_SEARCH
  72 //config:       bool "Enable regex in search and replace"
  73 //config:       default n   # Uses GNU regex, which may be unavailable. FIXME
  74 //config:       depends on FEATURE_VI_SEARCH
  75 //config:       help
  76 //config:       Use extended regex search.
  77 //config:
  78 //config:config FEATURE_VI_USE_SIGNALS
  79 //config:       bool "Catch signals"
  80 //config:       default y
  81 //config:       depends on VI
  82 //config:       help
  83 //config:       Selecting this option will make vi signal aware. This will support
  84 //config:       SIGWINCH to deal with Window Changes, catch ^Z and ^C and alarms.
  85 //config:
  86 //config:config FEATURE_VI_DOT_CMD
  87 //config:       bool "Remember previous cmd and \".\" cmd"
  88 //config:       default y
  89 //config:       depends on VI
  90 //config:       help
  91 //config:       Make vi remember the last command and be able to repeat it.
  92 //config:
  93 //config:config FEATURE_VI_READONLY
  94 //config:       bool "Enable -R option and \"view\" mode"
  95 //config:       default y
  96 //config:       depends on VI
  97 //config:       help
  98 //config:       Enable the read-only command line option, which allows the user to
  99 //config:       open a file in read-only mode.
 100 //config:
 101 //config:config FEATURE_VI_SETOPTS
 102 //config:       bool "Enable settable options, ai ic showmatch"
 103 //config:       default y
 104 //config:       depends on VI
 105 //config:       help
 106 //config:       Enable the editor to set some (ai, ic, showmatch) options.
 107 //config:
 108 //config:config FEATURE_VI_SET
 109 //config:       bool "Support :set"
 110 //config:       default y
 111 //config:       depends on VI
 112 //config:
 113 //config:config FEATURE_VI_WIN_RESIZE
 114 //config:       bool "Handle window resize"
 115 //config:       default y
 116 //config:       depends on VI
 117 //config:       help
 118 //config:       Behave nicely with terminals that get resized.
 119 //config:
 120 //config:config FEATURE_VI_ASK_TERMINAL
 121 //config:       bool "Use 'tell me cursor position' ESC sequence to measure window"
 122 //config:       default y
 123 //config:       depends on VI
 124 //config:       help
 125 //config:       If terminal size can't be retrieved and $LINES/$COLUMNS are not set,
 126 //config:       this option makes vi perform a last-ditch effort to find it:
 127 //config:       position cursor to 999,999 and ask terminal to report real
 128 //config:       cursor position using "ESC [ 6 n" escape sequence, then read stdin.
 129 //config:       This is not clean but helps a lot on serial lines and such.
 130 //config:
 131 //config:config FEATURE_VI_UNDO
 132 //config:       bool "Support undo command \"u\""
 133 //config:       default y
 134 //config:       depends on VI
 135 //config:       help
 136 //config:       Support the 'u' command to undo insertion, deletion, and replacement
 137 //config:       of text.
 138 //config:
 139 //config:config FEATURE_VI_UNDO_QUEUE
 140 //config:       bool "Enable undo operation queuing"
 141 //config:       default y
 142 //config:       depends on FEATURE_VI_UNDO
 143 //config:       help
 144 //config:       The vi undo functions can use an intermediate queue to greatly lower
 145 //config:       malloc() calls and overhead. When the maximum size of this queue is
 146 //config:       reached, the contents of the queue are committed to the undo stack.
 147 //config:       This increases the size of the undo code and allows some undo
 148 //config:       operations (especially un-typing/backspacing) to be far more useful.
 149 //config:
 150 //config:config FEATURE_VI_UNDO_QUEUE_MAX
 151 //config:       int "Maximum undo character queue size"
 152 //config:       default 256
 153 //config:       range 32 65536
 154 //config:       depends on FEATURE_VI_UNDO_QUEUE
 155 //config:       help
 156 //config:       This option sets the number of bytes used at runtime for the queue.
 157 //config:       Smaller values will create more undo objects and reduce the amount
 158 //config:       of typed or backspaced characters that are grouped into one undo
 159 //config:       operation; larger values increase the potential size of each undo
 160 //config:       and will generally malloc() larger objects and less frequently.
 161 //config:       Unless you want more (or less) frequent "undo points" while typing,
 162 //config:       you should probably leave this unchanged.
 163
 164 //applet:IF_VI(APPLET(vi, BB_DIR_BIN, BB_SUID_DROP))
 165
 166 //kbuild:lib-$(CONFIG_VI) += vi.o
 167
 168 //usage:#define vi_trivial_usage
 169 //usage:       "[OPTIONS] [FILE]..."
 170 //usage:#define vi_full_usage "\n\n"
 171 //usage:       "Edit FILE\n"
 172 //usage:        IF_FEATURE_VI_COLON(
 173 //usage:     "\n        -c CMD  Initial command to run ($EXINIT also available)"
 174 //usage:        )
 175 //usage:        IF_FEATURE_VI_READONLY(
 176 //usage:     "\n        -R      Read-only"
 177 //usage:        )
 178 //usage:     "\n        -H      List available features"
 179
 180 #include "libbb.h"
 181 /* Should be after libbb.h: on some systems regex.h needs sys/types.h: */
 182 #if ENABLE_FEATURE_VI_REGEX_SEARCH
 183 # include <regex.h>
 184 #endif
 185
 186 /* the CRASHME code is unmaintained, and doesn't currently build */
 187 #define ENABLE_FEATURE_VI_CRASHME 0
 188
 189
 190 #if ENABLE_LOCALE_SUPPORT
 191
 192 #if ENABLE_FEATURE_VI_8BIT
 193 //FIXME: this does not work properly for Unicode anyway
 194 # define Isprint(c) (isprint)(c)
 195 #else
 196 # define Isprint(c) isprint_asciionly(c)
 197 #endif
 198
 199 #else
 200
 201 /* 0x9b is Meta-ESC */
 202 #if ENABLE_FEATURE_VI_8BIT
 203 # define Isprint(c) ((unsigned char)(c) >= ' ' && (c) != 0x7f && (unsigned char)(c) != 0x9b)
 204 #else
 205 # define Isprint(c) ((unsigned char)(c) >= ' ' && (unsigned char)(c) < 0x7f)
 206 #endif
 207
 208 #endif
 209
 210
 211 enum {
 212         MAX_TABSTOP = 32, // sanity limit
 213         // User input len. Need not be extra big.
 214         // Lines in file being edited *can* be bigger than this.
 215         MAX_INPUT_LEN = 128,
 216         // Sanity limits. We have only one buffer of this size.
 217         MAX_SCR_COLS = CONFIG_FEATURE_VI_MAX_LEN,
 218         MAX_SCR_ROWS = CONFIG_FEATURE_VI_MAX_LEN,
 219 };
 220
 221 /* VT102 ESC sequences.
 222  * See "Xterm Control Sequences"
 223  * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
 224  */
 225 #define ESC "\033"
 226 /* Inverse/Normal text */
 227 #define ESC_BOLD_TEXT ESC"[7m"
 228 #define ESC_NORM_TEXT ESC"[m"
 229 /* Bell */
 230 #define ESC_BELL "\007"
 231 /* Clear-to-end-of-line */
 232 #define ESC_CLEAR2EOL ESC"[K"
 233 /* Clear-to-end-of-screen.
 234  * (We use default param here.
 235  * Full sequence is "ESC [ <num> J",
 236  * <num> is 0/1/2 = "erase below/above/all".)
 237  */
 238 #define ESC_CLEAR2EOS          ESC"[J"
 239 /* Cursor to given coordinate (1,1: top left) */
 240 #define ESC_SET_CURSOR_POS     ESC"[%u;%uH"
 241 #define ESC_SET_CURSOR_TOPLEFT ESC"[H"
 242 //UNUSED
 243 ///* Cursor up and down */
 244 //#define ESC_CURSOR_UP   ESC"[A"
 245 //#define ESC_CURSOR_DOWN "\n"
 246
 247 #if ENABLE_FEATURE_VI_DOT_CMD || ENABLE_FEATURE_VI_YANKMARK
 248 // cmds modifying text[]
 249 // vda: removed "aAiIs" as they switch us into insert mode
 250 // and remembering input for replay after them makes no sense
 251 static const char modifying_cmds[] ALIGN1 = "cCdDJoOpPrRxX<>~";
 252 #endif
 253
 254 enum {
 255         YANKONLY = FALSE,
 256         YANKDEL = TRUE,
 257         FORWARD = 1,    // code depends on "1"  for array index
 258         BACK = -1,      // code depends on "-1" for array index
 259         LIMITED = 0,    // char_search() only current line
 260         FULL = 1,       // char_search() to the end/beginning of entire text
 261
 262         S_BEFORE_WS = 1,        // used in skip_thing() for moving "dot"
 263         S_TO_WS = 2,            // used in skip_thing() for moving "dot"
 264         S_OVER_WS = 3,          // used in skip_thing() for moving "dot"
 265         S_END_PUNCT = 4,        // used in skip_thing() for moving "dot"
 266         S_END_ALNUM = 5,        // used in skip_thing() for moving "dot"
 267 };
 268
 269
 270 /* vi.c expects chars to be unsigned. */
 271 /* busybox build system provides that, but it's better */
 272 /* to audit and fix the source */
 273
 274 struct globals {
 275         /* many references - keep near the top of globals */
 276         char *text, *end;       // pointers to the user data in memory
 277         char *dot;              // where all the action takes place
 278         int text_size;          // size of the allocated buffer
 279
 280         /* the rest */
 281         smallint vi_setops;
 282 #define VI_AUTOINDENT 1
 283 #define VI_SHOWMATCH  2
 284 #define VI_IGNORECASE 4
 285 #define VI_ERR_METHOD 8
 286 #define autoindent (vi_setops & VI_AUTOINDENT)
 287 #define showmatch  (vi_setops & VI_SHOWMATCH )
 288 #define ignorecase (vi_setops & VI_IGNORECASE)
 289 /* indicate error with beep or flash */
 290 #define err_method (vi_setops & VI_ERR_METHOD)
 291
 292 #if ENABLE_FEATURE_VI_READONLY
 293         smallint readonly_mode;
 294 #define SET_READONLY_FILE(flags)        ((flags) |= 0x01)
 295 #define SET_READONLY_MODE(flags)        ((flags) |= 0x02)
 296 #define UNSET_READONLY_FILE(flags)      ((flags) &= 0xfe)
 297 #else
 298 #define SET_READONLY_FILE(flags)        ((void)0)
 299 #define SET_READONLY_MODE(flags)        ((void)0)
 300 #define UNSET_READONLY_FILE(flags)      ((void)0)
 301 #endif
 302
 303         smallint editing;        // >0 while we are editing a file
 304                                  // [code audit says "can be 0, 1 or 2 only"]
 305         smallint cmd_mode;       // 0=command  1=insert 2=replace
 306         int modified_count;      // buffer contents changed if !0
 307         int last_modified_count; // = -1;
 308         int save_argc;           // how many file names on cmd line
 309         int cmdcnt;              // repetition count
 310         unsigned rows, columns;  // the terminal screen is this size
 311 #if ENABLE_FEATURE_VI_ASK_TERMINAL
 312         int get_rowcol_error;
 313 #endif
 314         int crow, ccol;          // cursor is on Crow x Ccol
 315         int offset;              // chars scrolled off the screen to the left
 316         int have_status_msg;     // is default edit status needed?
 317                                  // [don't make smallint!]
 318         int last_status_cksum;   // hash of current status line
 319         char *current_filename;
 320         char *screenbegin;       // index into text[], of top line on the screen
 321         char *screen;            // pointer to the virtual screen buffer
 322         int screensize;          //            and its size
 323         int tabstop;
 324         int last_forward_char;   // last char searched for with 'f' (int because of Unicode)
 325         char erase_char;         // the users erase character
 326         char last_input_char;    // last char read from user
 327
 328 #if ENABLE_FEATURE_VI_DOT_CMD
 329         smallint adding2q;       // are we currently adding user input to q
 330         int lmc_len;             // length of last_modifying_cmd
 331         char *ioq, *ioq_start;   // pointer to string for get_one_char to "read"
 332 #endif
 333 #if ENABLE_FEATURE_VI_SEARCH
 334         char *last_search_pattern; // last pattern from a '/' or '?' search
 335 #endif
 336
 337         /* former statics */
 338 #if ENABLE_FEATURE_VI_YANKMARK
 339         char *edit_file__cur_line;
 340 #endif
 341         int refresh__old_offset;
 342         int format_edit_status__tot;
 343
 344         /* a few references only */
 345 #if ENABLE_FEATURE_VI_YANKMARK
 346         smalluint YDreg;//,Ureg;// default delete register and orig line for "U"
 347 #define Ureg 27
 348         char *reg[28];          // named register a-z, "D", and "U" 0-25,26,27
 349         char *mark[28];         // user marks points somewhere in text[]-  a-z and previous context ''
 350         char *context_start, *context_end;
 351 #endif
 352 #if ENABLE_FEATURE_VI_USE_SIGNALS
 353         sigjmp_buf restart;     // int_handler() jumps to location remembered here
 354 #endif
 355         struct termios term_orig; // remember what the cooked mode was
 356 #if ENABLE_FEATURE_VI_COLON
 357         char *initial_cmds[3];  // currently 2 entries, NULL terminated
 358 #endif
 359         // Should be just enough to hold a key sequence,
 360         // but CRASHME mode uses it as generated command buffer too
 361 #if ENABLE_FEATURE_VI_CRASHME
 362         char readbuffer[128];
 363 #else
 364         char readbuffer[KEYCODE_BUFFER_SIZE];
 365 #endif
 366 #define STATUS_BUFFER_LEN  200
 367         char status_buffer[STATUS_BUFFER_LEN]; // messages to the user
 368 #if ENABLE_FEATURE_VI_DOT_CMD
 369         char last_modifying_cmd[MAX_INPUT_LEN]; // last modifying cmd for "."
 370 #endif
 371         char get_input_line__buf[MAX_INPUT_LEN]; /* former static */
 372
 373         char scr_out_buf[MAX_SCR_COLS + MAX_TABSTOP * 2];
 374 #if ENABLE_FEATURE_VI_UNDO
 375 // undo_push() operations
 376 #define UNDO_INS         0
 377 #define UNDO_DEL         1
 378 #define UNDO_INS_CHAIN   2
 379 #define UNDO_DEL_CHAIN   3
 380 // UNDO_*_QUEUED must be equal to UNDO_xxx ORed with UNDO_QUEUED_FLAG
 381 #define UNDO_QUEUED_FLAG 4
 382 #define UNDO_INS_QUEUED  4
 383 #define UNDO_DEL_QUEUED  5
 384 #define UNDO_USE_SPOS   32
 385 #define UNDO_EMPTY      64
 386 // Pass-through flags for functions that can be undone
 387 #define NO_UNDO          0
 388 #define ALLOW_UNDO       1
 389 #define ALLOW_UNDO_CHAIN 2
 390 # if ENABLE_FEATURE_VI_UNDO_QUEUE
 391 #define ALLOW_UNDO_QUEUED 3
 392         char undo_queue_state;
 393         int undo_q;
 394         char *undo_queue_spos;  // Start position of queued operation
 395         char undo_queue[CONFIG_FEATURE_VI_UNDO_QUEUE_MAX];
 396 # else
 397 // If undo queuing disabled, don't invoke the missing queue logic
 398 #define ALLOW_UNDO_QUEUED 1
 399 # endif
 400
 401         struct undo_object {
 402                 struct undo_object *prev;       // Linking back avoids list traversal (LIFO)
 403                 int start;              // Offset where the data should be restored/deleted
 404                 int length;             // total data size
 405                 uint8_t u_type;         // 0=deleted, 1=inserted, 2=swapped
 406                 char undo_text[1];      // text that was deleted (if deletion)
 407         } *undo_stack_tail;
 408 #endif /* ENABLE_FEATURE_VI_UNDO */
 409 };
 410 #define G (*ptr_to_globals)
 411 #define text           (G.text          )
 412 #define text_size      (G.text_size     )
 413 #define end            (G.end           )
 414 #define dot            (G.dot           )
 415 #define reg            (G.reg           )
 416
 417 #define vi_setops               (G.vi_setops          )
 418 #define editing                 (G.editing            )
 419 #define cmd_mode                (G.cmd_mode           )
 420 #define modified_count          (G.modified_count     )
 421 #define last_modified_count     (G.last_modified_count)
 422 #define save_argc               (G.save_argc          )
 423 #define cmdcnt                  (G.cmdcnt             )
 424 #define rows                    (G.rows               )
 425 #define columns                 (G.columns            )
 426 #define crow                    (G.crow               )
 427 #define ccol                    (G.ccol               )
 428 #define offset                  (G.offset             )
 429 #define status_buffer           (G.status_buffer      )
 430 #define have_status_msg         (G.have_status_msg    )
 431 #define last_status_cksum       (G.last_status_cksum  )
 432 #define current_filename        (G.current_filename   )
 433 #define screen                  (G.screen             )
 434 #define screensize              (G.screensize         )
 435 #define screenbegin             (G.screenbegin        )
 436 #define tabstop                 (G.tabstop            )
 437 #define last_forward_char       (G.last_forward_char  )
 438 #define erase_char              (G.erase_char         )
 439 #define last_input_char         (G.last_input_char    )
 440 #if ENABLE_FEATURE_VI_READONLY
 441 #define readonly_mode           (G.readonly_mode      )
 442 #else
 443 #define readonly_mode           0
 444 #endif
 445 #define adding2q                (G.adding2q           )
 446 #define lmc_len                 (G.lmc_len            )
 447 #define ioq                     (G.ioq                )
 448 #define ioq_start               (G.ioq_start          )
 449 #define last_search_pattern     (G.last_search_pattern)
 450
 451 #define edit_file__cur_line     (G.edit_file__cur_line)
 452 #define refresh__old_offset     (G.refresh__old_offset)
 453 #define format_edit_status__tot (G.format_edit_status__tot)
 454
 455 #define YDreg          (G.YDreg         )
 456 //#define Ureg           (G.Ureg          )
 457 #define mark           (G.mark          )
 458 #define context_start  (G.context_start )
 459 #define context_end    (G.context_end   )
 460 #define restart        (G.restart       )
 461 #define term_orig      (G.term_orig     )
 462 #define initial_cmds   (G.initial_cmds  )
 463 #define readbuffer     (G.readbuffer    )
 464 #define scr_out_buf    (G.scr_out_buf   )
 465 #define last_modifying_cmd  (G.last_modifying_cmd )
 466 #define get_input_line__buf (G.get_input_line__buf)
 467
 468 #if ENABLE_FEATURE_VI_UNDO
 469 #define undo_stack_tail  (G.undo_stack_tail )
 470 # if ENABLE_FEATURE_VI_UNDO_QUEUE
 471 #define undo_queue_state (G.undo_queue_state)
 472 #define undo_q           (G.undo_q          )
 473 #define undo_queue       (G.undo_queue      )
 474 #define undo_queue_spos  (G.undo_queue_spos )
 475 # endif
 476 #endif
 477
 478 #define INIT_G() do { \
 479         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 480         last_modified_count = -1; \
 481         /* "" but has space for 2 chars: */ \
 482         IF_FEATURE_VI_SEARCH(last_search_pattern = xzalloc(2);) \
 483 } while (0)
 484
 485 #if ENABLE_FEATURE_VI_CRASHME
 486 static int crashme = 0;
 487 #endif
 488
 489 static void show_status_line(void);     // put a message on the bottom line
 490 static void status_line_bold(const char *, ...);
 491
 492 static void show_help(void)
 493 {
 494         puts("These features are available:"
 495 #if ENABLE_FEATURE_VI_SEARCH
 496         "\n\tPattern searches with / and ?"
 497 #endif
 498 #if ENABLE_FEATURE_VI_DOT_CMD
 499         "\n\tLast command repeat with ."
 500 #endif
 501 #if ENABLE_FEATURE_VI_YANKMARK
 502         "\n\tLine marking with 'x"
 503         "\n\tNamed buffers with \"x"
 504 #endif
 505 #if ENABLE_FEATURE_VI_READONLY
 506         //not implemented: "\n\tReadonly if vi is called as \"view\""
 507         //redundant: usage text says this too: "\n\tReadonly with -R command line arg"
 508 #endif
 509 #if ENABLE_FEATURE_VI_SET
 510         "\n\tSome colon mode commands with :"
 511 #endif
 512 #if ENABLE_FEATURE_VI_SETOPTS
 513         "\n\tSettable options with \":set\""
 514 #endif
 515 #if ENABLE_FEATURE_VI_USE_SIGNALS
 516         "\n\tSignal catching- ^C"
 517         "\n\tJob suspend and resume with ^Z"
 518 #endif
 519 #if ENABLE_FEATURE_VI_WIN_RESIZE
 520         "\n\tAdapt to window re-sizes"
 521 #endif
 522         );
 523 }
 524
 525 static void write1(const char *out)
 526 {
 527         fputs(out, stdout);
 528 }
 529
 530 #if ENABLE_FEATURE_VI_WIN_RESIZE
 531 static int query_screen_dimensions(void)
 532 {
 533         int err = get_terminal_width_height(STDIN_FILENO, &columns, &rows);
 534         if (rows > MAX_SCR_ROWS)
 535                 rows = MAX_SCR_ROWS;
 536         if (columns > MAX_SCR_COLS)
 537                 columns = MAX_SCR_COLS;
 538         return err;
 539 }
 540 #else
 541 static ALWAYS_INLINE int query_screen_dimensions(void)
 542 {
 543         return 0;
 544 }
 545 #endif
 546
 547 // sleep for 'h' 1/100 seconds, return 1/0 if stdin is (ready for read)/(not ready)
 548 static int mysleep(int hund)
 549 {
 550         struct pollfd pfd[1];
 551
 552         if (hund != 0)
 553                 fflush_all();
 554
 555         pfd[0].fd = STDIN_FILENO;
 556         pfd[0].events = POLLIN;
 557         return safe_poll(pfd, 1, hund*10) > 0;
 558 }
 559
 560 //----- Set terminal attributes --------------------------------
 561 static void rawmode(void)
 562 {
 563         // no TERMIOS_CLEAR_ISIG: leave ISIG on - allow signals
 564         set_termios_to_raw(STDIN_FILENO, &term_orig, TERMIOS_RAW_CRNL);
 565         erase_char = term_orig.c_cc[VERASE];
 566 }
 567
 568 static void cookmode(void)
 569 {
 570         fflush_all();
 571         tcsetattr_stdin_TCSANOW(&term_orig);
 572 }
 573
 574 //----- Terminal Drawing ---------------------------------------
 575 // The terminal is made up of 'rows' line of 'columns' columns.
 576 // classically this would be 24 x 80.
 577 //  screen coordinates
 578 //  0,0     ...     0,79
 579 //  1,0     ...     1,79
 580 //  .       ...     .
 581 //  .       ...     .
 582 //  22,0    ...     22,79
 583 //  23,0    ...     23,79   <- status line
 584
 585 //----- Move the cursor to row x col (count from 0, not 1) -------
 586 static void place_cursor(int row, int col)
 587 {
 588         char cm1[sizeof(ESC_SET_CURSOR_POS) + sizeof(int)*3 * 2];
 589
 590         if (row < 0) row = 0;
 591         if (row >= rows) row = rows - 1;
 592         if (col < 0) col = 0;
 593         if (col >= columns) col = columns - 1;
 594
 595         sprintf(cm1, ESC_SET_CURSOR_POS, row + 1, col + 1);
 596         write1(cm1);
 597 }
 598
 599 //----- Erase from cursor to end of line -----------------------
 600 static void clear_to_eol(void)
 601 {
 602         write1(ESC_CLEAR2EOL);
 603 }
 604
 605 static void go_bottom_and_clear_to_eol(void)
 606 {
 607         place_cursor(rows - 1, 0);
 608         clear_to_eol();
 609 }
 610
 611 //----- Start standout mode ------------------------------------
 612 static void standout_start(void)
 613 {
 614         write1(ESC_BOLD_TEXT);
 615 }
 616
 617 //----- End standout mode --------------------------------------
 618 static void standout_end(void)
 619 {
 620         write1(ESC_NORM_TEXT);
 621 }
 622
 623 //----- Text Movement Routines ---------------------------------
 624 static char *begin_line(char *p) // return pointer to first char cur line
 625 {
 626         if (p > text) {
 627                 p = memrchr(text, '\n', p - text);
 628                 if (!p)
 629                         return text;
 630                 return p + 1;
 631         }
 632         return p;
 633 }
 634
 635 static char *end_line(char *p) // return pointer to NL of cur line
 636 {
 637         if (p < end - 1) {
 638                 p = memchr(p, '\n', end - p - 1);
 639                 if (!p)
 640                         return end - 1;
 641         }
 642         return p;
 643 }
 644
 645 static char *dollar_line(char *p) // return pointer to just before NL line
 646 {
 647         p = end_line(p);
 648         // Try to stay off of the Newline
 649         if (*p == '\n' && (p - begin_line(p)) > 0)
 650                 p--;
 651         return p;
 652 }
 653
 654 static char *prev_line(char *p) // return pointer first char prev line
 655 {
 656         p = begin_line(p);      // goto beginning of cur line
 657         if (p > text && p[-1] == '\n')
 658                 p--;                    // step to prev line
 659         p = begin_line(p);      // goto beginning of prev line
 660         return p;
 661 }
 662
 663 static char *next_line(char *p) // return pointer first char next line
 664 {
 665         p = end_line(p);
 666         if (p < end - 1 && *p == '\n')
 667                 p++;                    // step to next line
 668         return p;
 669 }
 670
 671 //----- Text Information Routines ------------------------------
 672 static char *end_screen(void)
 673 {
 674         char *q;
 675         int cnt;
 676
 677         // find new bottom line
 678         q = screenbegin;
 679         for (cnt = 0; cnt < rows - 2; cnt++)
 680                 q = next_line(q);
 681         q = end_line(q);
 682         return q;
 683 }
 684
 685 // count line from start to stop
 686 static int count_lines(char *start, char *stop)
 687 {
 688         char *q;
 689         int cnt;
 690
 691         if (stop < start) { // start and stop are backwards- reverse them
 692                 q = start;
 693                 start = stop;
 694                 stop = q;
 695         }
 696         cnt = 0;
 697         stop = end_line(stop);
 698         while (start <= stop && start <= end - 1) {
 699                 start = end_line(start);
 700                 if (*start == '\n')
 701                         cnt++;
 702                 start++;
 703         }
 704         return cnt;
 705 }
 706
 707 static char *find_line(int li)  // find beginning of line #li
 708 {
 709         char *q;
 710
 711         for (q = text; li > 1; li--) {
 712                 q = next_line(q);
 713         }
 714         return q;
 715 }
 716
 717 static int next_tabstop(int col)
 718 {
 719         return col + ((tabstop - 1) - (col % tabstop));
 720 }
 721
 722 //----- Erase the Screen[] memory ------------------------------
 723 static void screen_erase(void)
 724 {
 725         memset(screen, ' ', screensize);        // clear new screen
 726 }
 727
 728 //----- Synchronize the cursor to Dot --------------------------
 729 static NOINLINE void sync_cursor(char *d, int *row, int *col)
 730 {
 731         char *beg_cur;  // begin and end of "d" line
 732         char *tp;
 733         int cnt, ro, co;
 734
 735         beg_cur = begin_line(d);        // first char of cur line
 736
 737         if (beg_cur < screenbegin) {
 738                 // "d" is before top line on screen
 739                 // how many lines do we have to move
 740                 cnt = count_lines(beg_cur, screenbegin);
 741  sc1:
 742                 screenbegin = beg_cur;
 743                 if (cnt > (rows - 1) / 2) {
 744                         // we moved too many lines. put "dot" in middle of screen
 745                         for (cnt = 0; cnt < (rows - 1) / 2; cnt++) {
 746                                 screenbegin = prev_line(screenbegin);
 747                         }
 748                 }
 749         } else {
 750                 char *end_scr;  // begin and end of screen
 751                 end_scr = end_screen(); // last char of screen
 752                 if (beg_cur > end_scr) {
 753                         // "d" is after bottom line on screen
 754                         // how many lines do we have to move
 755                         cnt = count_lines(end_scr, beg_cur);
 756                         if (cnt > (rows - 1) / 2)
 757                                 goto sc1;       // too many lines
 758                         for (ro = 0; ro < cnt - 1; ro++) {
 759                                 // move screen begin the same amount
 760                                 screenbegin = next_line(screenbegin);
 761                                 // now, move the end of screen
 762                                 end_scr = next_line(end_scr);
 763                                 end_scr = end_line(end_scr);
 764                         }
 765                 }
 766         }
 767         // "d" is on screen- find out which row
 768         tp = screenbegin;
 769         for (ro = 0; ro < rows - 1; ro++) {     // drive "ro" to correct row
 770                 if (tp == beg_cur)
 771                         break;
 772                 tp = next_line(tp);
 773         }
 774
 775         // find out what col "d" is on
 776         co = 0;
 777         while (tp < d) { // drive "co" to correct column
 778                 if (*tp == '\n') //vda || *tp == '\0')
 779                         break;
 780                 if (*tp == '\t') {
 781                         // handle tabs like real vi
 782                         if (d == tp && cmd_mode) {
 783                                 break;
 784                         }
 785                         co = next_tabstop(co);
 786                 } else if ((unsigned char)*tp < ' ' || *tp == 0x7f) {
 787                         co++; // display as ^X, use 2 columns
 788                 }
 789                 co++;
 790                 tp++;
 791         }
 792
 793         // "co" is the column where "dot" is.
 794         // The screen has "columns" columns.
 795         // The currently displayed columns are  0+offset -- columns+ofset
 796         // |-------------------------------------------------------------|
 797         //               ^ ^                                ^
 798         //        offset | |------- columns ----------------|
 799         //
 800         // If "co" is already in this range then we do not have to adjust offset
 801         //      but, we do have to subtract the "offset" bias from "co".
 802         // If "co" is outside this range then we have to change "offset".
 803         // If the first char of a line is a tab the cursor will try to stay
 804         //  in column 7, but we have to set offset to 0.
 805
 806         if (co < 0 + offset) {
 807                 offset = co;
 808         }
 809         if (co >= columns + offset) {
 810                 offset = co - columns + 1;
 811         }
 812         // if the first char of the line is a tab, and "dot" is sitting on it
 813         //  force offset to 0.
 814         if (d == beg_cur && *d == '\t') {
 815                 offset = 0;
 816         }
 817         co -= offset;
 818
 819         *row = ro;
 820         *col = co;
 821 }
 822
 823 //----- Format a text[] line into a buffer ---------------------
 824 static char* format_line(char *src /*, int li*/)
 825 {
 826         unsigned char c;
 827         int co;
 828         int ofs = offset;
 829         char *dest = scr_out_buf; // [MAX_SCR_COLS + MAX_TABSTOP * 2]
 830
 831         c = '~'; // char in col 0 in non-existent lines is '~'
 832         co = 0;
 833         while (co < columns + tabstop) {
 834                 // have we gone past the end?
 835                 if (src < end) {
 836                         c = *src++;
 837                         if (c == '\n')
 838                                 break;
 839                         if ((c & 0x80) && !Isprint(c)) {
 840                                 c = '.';
 841                         }
 842                         if (c < ' ' || c == 0x7f) {
 843                                 if (c == '\t') {
 844                                         c = ' ';
 845                                         //      co %    8     !=     7
 846                                         while ((co % tabstop) != (tabstop - 1)) {
 847                                                 dest[co++] = c;
 848                                         }
 849                                 } else {
 850                                         dest[co++] = '^';
 851                                         if (c == 0x7f)
 852                                                 c = '?';
 853                                         else
 854                                                 c += '@'; // Ctrl-X -> 'X'
 855                                 }
 856                         }
 857                 }
 858                 dest[co++] = c;
 859                 // discard scrolled-off-to-the-left portion,
 860                 // in tabstop-sized pieces
 861                 if (ofs >= tabstop && co >= tabstop) {
 862                         memmove(dest, dest + tabstop, co);
 863                         co -= tabstop;
 864                         ofs -= tabstop;
 865                 }
 866                 if (src >= end)
 867                         break;
 868         }
 869         // check "short line, gigantic offset" case
 870         if (co < ofs)
 871                 ofs = co;
 872         // discard last scrolled off part
 873         co -= ofs;
 874         dest += ofs;
 875         // fill the rest with spaces
 876         if (co < columns)
 877                 memset(&dest[co], ' ', columns - co);
 878         return dest;
 879 }
 880
 881 //----- Refresh the changed screen lines -----------------------
 882 // Copy the source line from text[] into the buffer and note
 883 // if the current screenline is different from the new buffer.
 884 // If they differ then that line needs redrawing on the terminal.
 885 //
 886 static void refresh(int full_screen)
 887 {
 888 #define old_offset refresh__old_offset
 889
 890         int li, changed;
 891         char *tp, *sp;          // pointer into text[] and screen[]
 892
 893         if (ENABLE_FEATURE_VI_WIN_RESIZE IF_FEATURE_VI_ASK_TERMINAL(&& !G.get_rowcol_error) ) {
 894                 unsigned c = columns, r = rows;
 895                 query_screen_dimensions();
 896 #if ENABLE_FEATURE_VI_USE_SIGNALS
 897                 full_screen |= (c - columns) | (r - rows);
 898 #else
 899                 if (c != columns || r != rows) {
 900                         full_screen = TRUE;
 901                         // update screen memory since SIGWINCH won't have done it
 902                         new_screen(rows, columns);
 903                 }
 904 #endif
 905         }
 906         sync_cursor(dot, &crow, &ccol); // where cursor will be (on "dot")
 907         tp = screenbegin;       // index into text[] of top line
 908
 909         // compare text[] to screen[] and mark screen[] lines that need updating
 910         for (li = 0; li < rows - 1; li++) {
 911                 int cs, ce;                             // column start & end
 912                 char *out_buf;
 913                 // format current text line
 914                 out_buf = format_line(tp /*, li*/);
 915
 916                 // skip to the end of the current text[] line
 917                 if (tp < end) {
 918                         char *t = memchr(tp, '\n', end - tp);
 919                         if (!t) t = end - 1;
 920                         tp = t + 1;
 921                 }
 922
 923                 // see if there are any changes between virtual screen and out_buf
 924                 changed = FALSE;        // assume no change
 925                 cs = 0;
 926                 ce = columns - 1;
 927                 sp = &screen[li * columns];     // start of screen line
 928                 if (full_screen) {
 929                         // force re-draw of every single column from 0 - columns-1
 930                         goto re0;
 931                 }
 932                 // compare newly formatted buffer with virtual screen
 933                 // look forward for first difference between buf and screen
 934                 for (; cs <= ce; cs++) {
 935                         if (out_buf[cs] != sp[cs]) {
 936                                 changed = TRUE; // mark for redraw
 937                                 break;
 938                         }
 939                 }
 940
 941                 // look backward for last difference between out_buf and screen
 942                 for (; ce >= cs; ce--) {
 943                         if (out_buf[ce] != sp[ce]) {
 944                                 changed = TRUE; // mark for redraw
 945                                 break;
 946                         }
 947                 }
 948                 // now, cs is index of first diff, and ce is index of last diff
 949
 950                 // if horz offset has changed, force a redraw
 951                 if (offset != old_offset) {
 952  re0:
 953                         changed = TRUE;
 954                 }
 955
 956                 // make a sanity check of columns indexes
 957                 if (cs < 0) cs = 0;
 958                 if (ce > columns - 1) ce = columns - 1;
 959                 if (cs > ce) { cs = 0; ce = columns - 1; }
 960                 // is there a change between virtual screen and out_buf
 961                 if (changed) {
 962                         // copy changed part of buffer to virtual screen
 963                         memcpy(sp+cs, out_buf+cs, ce-cs+1);
 964                         place_cursor(li, cs);
 965                         // write line out to terminal
 966                         fwrite(&sp[cs], ce - cs + 1, 1, stdout);
 967                 }
 968         }
 969
 970         place_cursor(crow, ccol);
 971
 972         old_offset = offset;
 973 #undef old_offset
 974 }
 975
 976 //----- Force refresh of all Lines -----------------------------
 977 static void redraw(int full_screen)
 978 {
 979         // cursor to top,left; clear to the end of screen
 980         write1(ESC_SET_CURSOR_TOPLEFT ESC_CLEAR2EOS);
 981         screen_erase();         // erase the internal screen buffer
 982         last_status_cksum = 0;  // force status update
 983         refresh(full_screen);   // this will redraw the entire display
 984         show_status_line();
 985 }
 986
 987 //----- Flash the screen  --------------------------------------
 988 static void flash(int h)
 989 {
 990         standout_start();
 991         redraw(TRUE);
 992         mysleep(h);
 993         standout_end();
 994         redraw(TRUE);
 995 }
 996
 997 static void indicate_error(void)
 998 {
 999 #if ENABLE_FEATURE_VI_CRASHME
1000         if (crashme > 0)
1001                 return;
1002 #endif
1003         if (!err_method) {
1004                 write1(ESC_BELL);
1005         } else {
1006                 flash(10);
1007         }
1008 }
1009
1010 //----- IO Routines --------------------------------------------
1011 static int readit(void) // read (maybe cursor) key from stdin
1012 {
1013         int c;
1014
1015         fflush_all();
1016
1017         // Wait for input. TIMEOUT = -1 makes read_key wait even
1018         // on nonblocking stdin.
1019         // Note: read_key sets errno to 0 on success.
1020  again:
1021         c = read_key(STDIN_FILENO, readbuffer, /*timeout:*/ -1);
1022         if (c == -1) { // EOF/error
1023                 if (errno == EAGAIN) // paranoia
1024                         goto again;
1025                 go_bottom_and_clear_to_eol();
1026                 cookmode(); // terminal to "cooked"
1027                 bb_error_msg_and_die("can't read user input");
1028         }
1029         return c;
1030 }
1031
1032 static int get_one_char(void)
1033 {
1034         int c;
1035
1036 #if ENABLE_FEATURE_VI_DOT_CMD
1037         if (!adding2q) {
1038                 // we are not adding to the q.
1039                 // but, we may be reading from a q
1040                 if (ioq == 0) {
1041                         // there is no current q, read from STDIN
1042                         c = readit();   // get the users input
1043                 } else {
1044                         // there is a queue to get chars from first
1045                         // careful with correct sign expansion!
1046                         c = (unsigned char)*ioq++;
1047                         if (c == '\0') {
1048                                 // the end of the q, read from STDIN
1049                                 free(ioq_start);
1050                                 ioq_start = ioq = 0;
1051                                 c = readit();   // get the users input
1052                         }
1053                 }
1054         } else {
1055                 // adding STDIN chars to q
1056                 c = readit();   // get the users input
1057                 if (lmc_len >= MAX_INPUT_LEN - 1) {
1058                         status_line_bold("last_modifying_cmd overrun");
1059                 } else {
1060                         // add new char to q
1061                         last_modifying_cmd[lmc_len++] = c;
1062                 }
1063         }
1064 #else
1065         c = readit();           // get the users input
1066 #endif /* FEATURE_VI_DOT_CMD */
1067         return c;
1068 }
1069
1070 // Get input line (uses "status line" area)
1071 static char *get_input_line(const char *prompt)
1072 {
1073         // char [MAX_INPUT_LEN]
1074 #define buf get_input_line__buf
1075
1076         int c;
1077         int i;
1078
1079         strcpy(buf, prompt);
1080         last_status_cksum = 0;  // force status update
1081         go_bottom_and_clear_to_eol();
1082         write1(prompt);      // write out the :, /, or ? prompt
1083
1084         i = strlen(buf);
1085         while (i < MAX_INPUT_LEN) {
1086                 c = get_one_char();
1087                 if (c == '\n' || c == '\r' || c == 27)
1088                         break;          // this is end of input
1089                 if (c == erase_char || c == 8 || c == 127) {
1090                         // user wants to erase prev char
1091                         buf[--i] = '\0';
1092                         write1("\b \b"); // erase char on screen
1093                         if (i <= 0) // user backs up before b-o-l, exit
1094                                 break;
1095                 } else if (c > 0 && c < 256) { // exclude Unicode
1096                         // (TODO: need to handle Unicode)
1097                         buf[i] = c;
1098                         buf[++i] = '\0';
1099                         bb_putchar(c);
1100                 }
1101         }
1102         refresh(FALSE);
1103         return buf;
1104 #undef buf
1105 }
1106
1107 static void Hit_Return(void)
1108 {
1109         int c;
1110
1111         standout_start();
1112         write1("[Hit return to continue]");
1113         standout_end();
1114         while ((c = get_one_char()) != '\n' && c != '\r')
1115                 continue;
1116         redraw(TRUE);           // force redraw all
1117 }
1118
1119 //----- Draw the status line at bottom of the screen -------------
1120 // show file status on status line
1121 static int format_edit_status(void)
1122 {
1123         static const char cmd_mode_indicator[] ALIGN1 = "-IR-";
1124
1125 #define tot format_edit_status__tot
1126
1127         int cur, percent, ret, trunc_at;
1128
1129         // modified_count is now a counter rather than a flag.  this
1130         // helps reduce the amount of line counting we need to do.
1131         // (this will cause a mis-reporting of modified status
1132         // once every MAXINT editing operations.)
1133
1134         // it would be nice to do a similar optimization here -- if
1135         // we haven't done a motion that could have changed which line
1136         // we're on, then we shouldn't have to do this count_lines()
1137         cur = count_lines(text, dot);
1138
1139         // count_lines() is expensive.
1140         // Call it only if something was changed since last time
1141         // we were here:
1142         if (modified_count != last_modified_count) {
1143                 tot = cur + count_lines(dot, end - 1) - 1;
1144                 last_modified_count = modified_count;
1145         }
1146
1147         //    current line         percent
1148         //   -------------    ~~ ----------
1149         //    total lines            100
1150         if (tot > 0) {
1151                 percent = (100 * cur) / tot;
1152         } else {
1153                 cur = tot = 0;
1154                 percent = 100;
1155         }
1156
1157         trunc_at = columns < STATUS_BUFFER_LEN-1 ?
1158                 columns : STATUS_BUFFER_LEN-1;
1159
1160         ret = snprintf(status_buffer, trunc_at+1,
1161 #if ENABLE_FEATURE_VI_READONLY
1162                 "%c %s%s%s %d/%d %d%%",
1163 #else
1164                 "%c %s%s %d/%d %d%%",
1165 #endif
1166                 cmd_mode_indicator[cmd_mode & 3],
1167                 (current_filename != NULL ? current_filename : "No file"),
1168 #if ENABLE_FEATURE_VI_READONLY
1169                 (readonly_mode ? " [Readonly]" : ""),
1170 #endif
1171                 (modified_count ? " [Modified]" : ""),
1172                 cur, tot, percent);
1173
1174         if (ret >= 0 && ret < trunc_at)
1175                 return ret;  // it all fit
1176
1177         return trunc_at;  // had to truncate
1178 #undef tot
1179 }
1180
1181 static int bufsum(char *buf, int count)
1182 {
1183         int sum = 0;
1184         char *e = buf + count;
1185         while (buf < e)
1186                 sum += (unsigned char) *buf++;
1187         return sum;
1188 }
1189
1190 static void show_status_line(void)
1191 {
1192         int cnt = 0, cksum = 0;
1193
1194         // either we already have an error or status message, or we
1195         // create one.
1196         if (!have_status_msg) {
1197                 cnt = format_edit_status();
1198                 cksum = bufsum(status_buffer, cnt);
1199         }
1200         if (have_status_msg || ((cnt > 0 && last_status_cksum != cksum))) {
1201                 last_status_cksum = cksum;              // remember if we have seen this line
1202                 go_bottom_and_clear_to_eol();
1203                 write1(status_buffer);
1204                 if (have_status_msg) {
1205                         if (((int)strlen(status_buffer) - (have_status_msg - 1)) >
1206                                         (columns - 1) ) {
1207                                 have_status_msg = 0;
1208                                 Hit_Return();
1209                         }
1210                         have_status_msg = 0;
1211                 }
1212                 place_cursor(crow, ccol);  // put cursor back in correct place
1213         }
1214         fflush_all();
1215 }
1216
1217 //----- format the status buffer, the bottom line of screen ------
1218 static void status_line(const char *format, ...)
1219 {
1220         va_list args;
1221
1222         va_start(args, format);
1223         vsnprintf(status_buffer, STATUS_BUFFER_LEN, format, args);
1224         va_end(args);
1225
1226         have_status_msg = 1;
1227 }
1228 static void status_line_bold(const char *format, ...)
1229 {
1230         va_list args;
1231
1232         va_start(args, format);
1233         strcpy(status_buffer, ESC_BOLD_TEXT);
1234         vsnprintf(status_buffer + (sizeof(ESC_BOLD_TEXT)-1),
1235                 STATUS_BUFFER_LEN - sizeof(ESC_BOLD_TEXT) - sizeof(ESC_NORM_TEXT),
1236                 format, args
1237         );
1238         strcat(status_buffer, ESC_NORM_TEXT);
1239         va_end(args);
1240
1241         have_status_msg = 1 + (sizeof(ESC_BOLD_TEXT)-1) + (sizeof(ESC_NORM_TEXT)-1);
1242 }
1243 static void status_line_bold_errno(const char *fn)
1244 {
1245         status_line_bold("'%s' "STRERROR_FMT, fn STRERROR_ERRNO);
1246 }
1247
1248 // copy s to buf, convert unprintable
1249 static void print_literal(char *buf, const char *s)
1250 {
1251         char *d;
1252         unsigned char c;
1253
1254         buf[0] = '\0';
1255         if (!s[0])
1256                 s = "(NULL)";
1257
1258         d = buf;
1259         for (; *s; s++) {
1260                 int c_is_no_print;
1261
1262                 c = *s;
1263                 c_is_no_print = (c & 0x80) && !Isprint(c);
1264                 if (c_is_no_print) {
1265                         strcpy(d, ESC_NORM_TEXT);
1266                         d += sizeof(ESC_NORM_TEXT)-1;
1267                         c = '.';
1268                 }
1269                 if (c < ' ' || c == 0x7f) {
1270                         *d++ = '^';
1271                         c |= '@'; // 0x40
1272                         if (c == 0x7f)
1273                                 c = '?';
1274                 }
1275                 *d++ = c;
1276                 *d = '\0';
1277                 if (c_is_no_print) {
1278                         strcpy(d, ESC_BOLD_TEXT);
1279                         d += sizeof(ESC_BOLD_TEXT)-1;
1280                 }
1281                 if (*s == '\n') {
1282                         *d++ = '$';
1283                         *d = '\0';
1284                 }
1285                 if (d - buf > MAX_INPUT_LEN - 10) // paranoia
1286                         break;
1287         }
1288 }
1289 static void not_implemented(const char *s)
1290 {
1291         char buf[MAX_INPUT_LEN];
1292         print_literal(buf, s);
1293         status_line_bold("'%s' is not implemented", buf);
1294 }
1295
1296 //----- Block insert/delete, undo ops --------------------------
1297 #if ENABLE_FEATURE_VI_YANKMARK
1298 static char *text_yank(char *p, char *q, int dest)      // copy text into a register
1299 {
1300         int cnt = q - p;
1301         if (cnt < 0) {          // they are backwards- reverse them
1302                 p = q;
1303                 cnt = -cnt;
1304         }
1305         free(reg[dest]);        //  if already a yank register, free it
1306         reg[dest] = xstrndup(p, cnt + 1);
1307         return p;
1308 }
1309
1310 static char what_reg(void)
1311 {
1312         char c;
1313
1314         c = 'D';                        // default to D-reg
1315         if (0 <= YDreg && YDreg <= 25)
1316                 c = 'a' + (char) YDreg;
1317         if (YDreg == 26)
1318                 c = 'D';
1319         if (YDreg == 27)
1320                 c = 'U';
1321         return c;
1322 }
1323
1324 static void check_context(char cmd)
1325 {
1326         // A context is defined to be "modifying text"
1327         // Any modifying command establishes a new context.
1328
1329         if (dot < context_start || dot > context_end) {
1330                 if (strchr(modifying_cmds, cmd) != NULL) {
1331                         // we are trying to modify text[]- make this the current context
1332                         mark[27] = mark[26];    // move cur to prev
1333                         mark[26] = dot; // move local to cur
1334                         context_start = prev_line(prev_line(dot));
1335                         context_end = next_line(next_line(dot));
1336                         //loiter= start_loiter= now;
1337                 }
1338         }
1339 }
1340
1341 static char *swap_context(char *p) // goto new context for '' command make this the current context
1342 {
1343         char *tmp;
1344
1345         // the current context is in mark[26]
1346         // the previous context is in mark[27]
1347         // only swap context if other context is valid
1348         if (text <= mark[27] && mark[27] <= end - 1) {
1349                 tmp = mark[27];
1350                 mark[27] = p;
1351                 mark[26] = p = tmp;
1352                 context_start = prev_line(prev_line(prev_line(p)));
1353                 context_end = next_line(next_line(next_line(p)));
1354         }
1355         return p;
1356 }
1357 #endif /* FEATURE_VI_YANKMARK */
1358
1359 #if ENABLE_FEATURE_VI_UNDO
1360 static void undo_push(char *, unsigned, unsigned char);
1361 #endif
1362
1363 // open a hole in text[]
1364 // might reallocate text[]! use p += text_hole_make(p, ...),
1365 // and be careful to not use pointers into potentially freed text[]!
1366 static uintptr_t text_hole_make(char *p, int size)      // at "p", make a 'size' byte hole
1367 {
1368         uintptr_t bias = 0;
1369
1370         if (size <= 0)
1371                 return bias;
1372         end += size;            // adjust the new END
1373         if (end >= (text + text_size)) {
1374                 char *new_text;
1375                 text_size += end - (text + text_size) + 10240;
1376                 new_text = xrealloc(text, text_size);
1377                 bias = (new_text - text);
1378                 screenbegin += bias;
1379                 dot         += bias;
1380                 end         += bias;
1381                 p           += bias;
1382 #if ENABLE_FEATURE_VI_YANKMARK
1383                 {
1384                         int i;
1385                         for (i = 0; i < ARRAY_SIZE(mark); i++)
1386                                 if (mark[i])
1387                                         mark[i] += bias;
1388                 }
1389 #endif
1390                 text = new_text;
1391         }
1392         memmove(p + size, p, end - size - p);
1393         memset(p, ' ', size);   // clear new hole
1394         return bias;
1395 }
1396
1397 // close a hole in text[] - delete "p" through "q", inclusive
1398 // "undo" value indicates if this operation should be undo-able
1399 #if !ENABLE_FEATURE_VI_UNDO
1400 #define text_hole_delete(a,b,c) text_hole_delete(a,b)
1401 #endif
1402 static char *text_hole_delete(char *p, char *q, int undo)
1403 {
1404         char *src, *dest;
1405         int cnt, hole_size;
1406
1407         // move forwards, from beginning
1408         // assume p <= q
1409         src = q + 1;
1410         dest = p;
1411         if (q < p) {            // they are backward- swap them
1412                 src = p + 1;
1413                 dest = q;
1414         }
1415         hole_size = q - p + 1;
1416         cnt = end - src;
1417 #if ENABLE_FEATURE_VI_UNDO
1418         switch (undo) {
1419                 case NO_UNDO:
1420                         break;
1421                 case ALLOW_UNDO:
1422                         undo_push(p, hole_size, UNDO_DEL);
1423                         break;
1424                 case ALLOW_UNDO_CHAIN:
1425                         undo_push(p, hole_size, UNDO_DEL_CHAIN);
1426                         break;
1427 # if ENABLE_FEATURE_VI_UNDO_QUEUE
1428                 case ALLOW_UNDO_QUEUED:
1429                         undo_push(p, hole_size, UNDO_DEL_QUEUED);
1430                         break;
1431 # endif
1432         }
1433         modified_count--;
1434 #endif
1435         if (src < text || src > end)
1436                 goto thd0;
1437         if (dest < text || dest >= end)
1438                 goto thd0;
1439         modified_count++;
1440         if (src >= end)
1441                 goto thd_atend; // just delete the end of the buffer
1442         memmove(dest, src, cnt);
1443  thd_atend:
1444         end = end - hole_size;  // adjust the new END
1445         if (dest >= end)
1446                 dest = end - 1; // make sure dest in below end-1
1447         if (end <= text)
1448                 dest = end = text;      // keep pointers valid
1449  thd0:
1450         return dest;
1451 }
1452
1453 #if ENABLE_FEATURE_VI_UNDO
1454
1455 # if ENABLE_FEATURE_VI_UNDO_QUEUE
1456 // Flush any queued objects to the undo stack
1457 static void undo_queue_commit(void)
1458 {
1459         // Pushes the queue object onto the undo stack
1460         if (undo_q > 0) {
1461                 // Deleted character undo events grow from the end
1462                 undo_push(undo_queue + CONFIG_FEATURE_VI_UNDO_QUEUE_MAX - undo_q,
1463                         undo_q,
1464                         (undo_queue_state | UNDO_USE_SPOS)
1465                 );
1466                 undo_queue_state = UNDO_EMPTY;
1467                 undo_q = 0;
1468         }
1469 }
1470 # else
1471 #  define undo_queue_commit() ((void)0)
1472 # endif
1473
1474 static void flush_undo_data(void)
1475 {
1476         struct undo_object *undo_entry;
1477
1478         while (undo_stack_tail) {
1479                 undo_entry = undo_stack_tail;
1480                 undo_stack_tail = undo_entry->prev;
1481                 free(undo_entry);
1482         }
1483 }
1484
1485 // Undo functions and hooks added by Jody Bruchon (jody@jodybruchon.com)
1486 // Add to the undo stack
1487 static void undo_push(char *src, unsigned length, uint8_t u_type)
1488 {
1489         struct undo_object *undo_entry;
1490
1491         // "u_type" values
1492         // UNDO_INS: insertion, undo will remove from buffer
1493         // UNDO_DEL: deleted text, undo will restore to buffer
1494         // UNDO_{INS,DEL}_CHAIN: Same as above but also calls undo_pop() when complete
1495         // The CHAIN operations are for handling multiple operations that the user
1496         // performs with a single action, i.e. REPLACE mode or find-and-replace commands
1497         // UNDO_{INS,DEL}_QUEUED: If queuing feature is enabled, allow use of the queue
1498         // for the INS/DEL operation. The raw values should be equal to the values of
1499         // UNDO_{INS,DEL} ORed with UNDO_QUEUED_FLAG
1500
1501 # if ENABLE_FEATURE_VI_UNDO_QUEUE
1502         // This undo queuing functionality groups multiple character typing or backspaces
1503         // into a single large undo object. This greatly reduces calls to malloc() for
1504         // single-character operations while typing and has the side benefit of letting
1505         // an undo operation remove chunks of text rather than a single character.
1506         switch (u_type) {
1507         case UNDO_EMPTY:        // Just in case this ever happens...
1508                 return;
1509         case UNDO_DEL_QUEUED:
1510                 if (length != 1)
1511                         return; // Only queue single characters
1512                 switch (undo_queue_state) {
1513                 case UNDO_EMPTY:
1514                         undo_queue_state = UNDO_DEL;
1515                 case UNDO_DEL:
1516                         undo_queue_spos = src;
1517                         undo_q++;
1518                         undo_queue[CONFIG_FEATURE_VI_UNDO_QUEUE_MAX - undo_q] = *src;
1519                         // If queue is full, dump it into an object
1520                         if (undo_q == CONFIG_FEATURE_VI_UNDO_QUEUE_MAX)
1521                                 undo_queue_commit();
1522                         return;
1523                 case UNDO_INS:
1524                         // Switch from storing inserted text to deleted text
1525                         undo_queue_commit();
1526                         undo_push(src, length, UNDO_DEL_QUEUED);
1527                         return;
1528                 }
1529                 break;
1530         case UNDO_INS_QUEUED:
1531                 if (length < 1)
1532                         return;
1533                 switch (undo_queue_state) {
1534                 case UNDO_EMPTY:
1535                         undo_queue_state = UNDO_INS;
1536                         undo_queue_spos = src;
1537                 case UNDO_INS:
1538                         while (length--) {
1539                                 undo_q++;       // Don't need to save any data for insertions
1540                                 if (undo_q == CONFIG_FEATURE_VI_UNDO_QUEUE_MAX)
1541                                         undo_queue_commit();
1542                         }
1543                         return;
1544                 case UNDO_DEL:
1545                         // Switch from storing deleted text to inserted text
1546                         undo_queue_commit();
1547                         undo_push(src, length, UNDO_INS_QUEUED);
1548                         return;
1549                 }
1550                 break;
1551         }
1552 # else
1553         // If undo queuing is disabled, ignore the queuing flag entirely
1554         u_type = u_type & ~UNDO_QUEUED_FLAG;
1555 # endif
1556
1557         // Allocate a new undo object
1558         if (u_type == UNDO_DEL || u_type == UNDO_DEL_CHAIN) {
1559                 // For UNDO_DEL objects, save deleted text
1560                 if ((text + length) == end)
1561                         length--;
1562                 // If this deletion empties text[], strip the newline. When the buffer becomes
1563                 // zero-length, a newline is added back, which requires this to compensate.
1564                 undo_entry = xzalloc(offsetof(struct undo_object, undo_text) + length);
1565                 memcpy(undo_entry->undo_text, src, length);
1566         } else {
1567                 undo_entry = xzalloc(sizeof(*undo_entry));
1568         }
1569         undo_entry->length = length;
1570 # if ENABLE_FEATURE_VI_UNDO_QUEUE
1571         if ((u_type & UNDO_USE_SPOS) != 0) {
1572                 undo_entry->start = undo_queue_spos - text;     // use start position from queue
1573         } else {
1574                 undo_entry->start = src - text; // use offset from start of text buffer
1575         }
1576         u_type = (u_type & ~UNDO_USE_SPOS);
1577 # else
1578         undo_entry->start = src - text;
1579 # endif
1580         undo_entry->u_type = u_type;
1581
1582         // Push it on undo stack
1583         undo_entry->prev = undo_stack_tail;
1584         undo_stack_tail = undo_entry;
1585         modified_count++;
1586 }
1587
1588 static void undo_push_insert(char *p, int len, int undo)
1589 {
1590         switch (undo) {
1591         case ALLOW_UNDO:
1592                 undo_push(p, len, UNDO_INS);
1593                 break;
1594         case ALLOW_UNDO_CHAIN:
1595                 undo_push(p, len, UNDO_INS_CHAIN);
1596                 break;
1597 # if ENABLE_FEATURE_VI_UNDO_QUEUE
1598         case ALLOW_UNDO_QUEUED:
1599                 undo_push(p, len, UNDO_INS_QUEUED);
1600                 break;
1601 # endif
1602         }
1603 }
1604
1605 // Undo the last operation
1606 static void undo_pop(void)
1607 {
1608         int repeat;
1609         char *u_start, *u_end;
1610         struct undo_object *undo_entry;
1611
1612         // Commit pending undo queue before popping (should be unnecessary)
1613         undo_queue_commit();
1614
1615         undo_entry = undo_stack_tail;
1616         // Check for an empty undo stack
1617         if (!undo_entry) {
1618                 status_line("Already at oldest change");
1619                 return;
1620         }
1621
1622         switch (undo_entry->u_type) {
1623         case UNDO_DEL:
1624         case UNDO_DEL_CHAIN:
1625                 // make hole and put in text that was deleted; deallocate text
1626                 u_start = text + undo_entry->start;
1627                 text_hole_make(u_start, undo_entry->length);
1628                 memcpy(u_start, undo_entry->undo_text, undo_entry->length);
1629                 status_line("Undo [%d] %s %d chars at position %d",
1630                         modified_count, "restored",
1631                         undo_entry->length, undo_entry->start
1632                 );
1633                 break;
1634         case UNDO_INS:
1635         case UNDO_INS_CHAIN:
1636                 // delete what was inserted
1637                 u_start = undo_entry->start + text;
1638                 u_end = u_start - 1 + undo_entry->length;
1639                 text_hole_delete(u_start, u_end, NO_UNDO);
1640                 status_line("Undo [%d] %s %d chars at position %d",
1641                         modified_count, "deleted",
1642                         undo_entry->length, undo_entry->start
1643                 );
1644                 break;
1645         }
1646         repeat = 0;
1647         switch (undo_entry->u_type) {
1648         // If this is the end of a chain, lower modification count and refresh display
1649         case UNDO_DEL:
1650         case UNDO_INS:
1651                 dot = (text + undo_entry->start);
1652                 refresh(FALSE);
1653                 break;
1654         case UNDO_DEL_CHAIN:
1655         case UNDO_INS_CHAIN:
1656                 repeat = 1;
1657                 break;
1658         }
1659         // Deallocate the undo object we just processed
1660         undo_stack_tail = undo_entry->prev;
1661         free(undo_entry);
1662         modified_count--;
1663         // For chained operations, continue popping all the way down the chain.
1664         if (repeat) {
1665                 undo_pop();     // Follow the undo chain if one exists
1666         }
1667 }
1668
1669 #else
1670 # define flush_undo_data()   ((void)0)
1671 # define undo_queue_commit() ((void)0)
1672 #endif /* ENABLE_FEATURE_VI_UNDO */
1673
1674 //----- Dot Movement Routines ----------------------------------
1675 static void dot_left(void)
1676 {
1677         undo_queue_commit();
1678         if (dot > text && dot[-1] != '\n')
1679                 dot--;
1680 }
1681
1682 static void dot_right(void)
1683 {
1684         undo_queue_commit();
1685         if (dot < end - 1 && *dot != '\n')
1686                 dot++;
1687 }
1688
1689 static void dot_begin(void)
1690 {
1691         undo_queue_commit();
1692         dot = begin_line(dot);  // return pointer to first char cur line
1693 }
1694
1695 static void dot_end(void)
1696 {
1697         undo_queue_commit();
1698         dot = end_line(dot);    // return pointer to last char cur line
1699 }
1700
1701 static char *move_to_col(char *p, int l)
1702 {
1703         int co;
1704
1705         p = begin_line(p);
1706         co = 0;
1707         while (co < l && p < end) {
1708                 if (*p == '\n') //vda || *p == '\0')
1709                         break;
1710                 if (*p == '\t') {
1711                         co = next_tabstop(co);
1712                 } else if (*p < ' ' || *p == 127) {
1713                         co++; // display as ^X, use 2 columns
1714                 }
1715                 co++;
1716                 p++;
1717         }
1718         return p;
1719 }
1720
1721 static void dot_next(void)
1722 {
1723         undo_queue_commit();
1724         dot = next_line(dot);
1725 }
1726
1727 static void dot_prev(void)
1728 {
1729         undo_queue_commit();
1730         dot = prev_line(dot);
1731 }
1732
1733 static void dot_skip_over_ws(void)
1734 {
1735         // skip WS
1736         while (isspace(*dot) && *dot != '\n' && dot < end - 1)
1737                 dot++;
1738 }
1739
1740 static void dot_scroll(int cnt, int dir)
1741 {
1742         char *q;
1743
1744         undo_queue_commit();
1745         for (; cnt > 0; cnt--) {
1746                 if (dir < 0) {
1747                         // scroll Backwards
1748                         // ctrl-Y scroll up one line
1749                         screenbegin = prev_line(screenbegin);
1750                 } else {
1751                         // scroll Forwards
1752                         // ctrl-E scroll down one line
1753                         screenbegin = next_line(screenbegin);
1754                 }
1755         }
1756         // make sure "dot" stays on the screen so we dont scroll off
1757         if (dot < screenbegin)
1758                 dot = screenbegin;
1759         q = end_screen();       // find new bottom line
1760         if (dot > q)
1761                 dot = begin_line(q);    // is dot is below bottom line?
1762         dot_skip_over_ws();
1763 }
1764
1765 static char *bound_dot(char *p) // make sure  text[0] <= P < "end"
1766 {
1767         if (p >= end && end > text) {
1768                 p = end - 1;
1769                 indicate_error();
1770         }
1771         if (p < text) {
1772                 p = text;
1773                 indicate_error();
1774         }
1775         return p;
1776 }
1777
1778 #if ENABLE_FEATURE_VI_DOT_CMD
1779 static void start_new_cmd_q(char c)
1780 {
1781         // get buffer for new cmd
1782         // if there is a current cmd count put it in the buffer first
1783         if (cmdcnt > 0) {
1784                 lmc_len = sprintf(last_modifying_cmd, "%d%c", cmdcnt, c);
1785         } else { // just save char c onto queue
1786                 last_modifying_cmd[0] = c;
1787                 lmc_len = 1;
1788         }
1789         adding2q = 1;
1790 }
1791 static void end_cmd_q(void)
1792 {
1793 # if ENABLE_FEATURE_VI_YANKMARK
1794         YDreg = 26;                     // go back to default Yank/Delete reg
1795 # endif
1796         adding2q = 0;
1797 }
1798 #else
1799 # define end_cmd_q() ((void)0)
1800 #endif /* FEATURE_VI_DOT_CMD */
1801
1802 // copy text into register, then delete text.
1803 // if dist <= 0, do not include, or go past, a NewLine
1804 //
1805 #if !ENABLE_FEATURE_VI_UNDO
1806 #define yank_delete(a,b,c,d,e) yank_delete(a,b,c,d)
1807 #endif
1808 static char *yank_delete(char *start, char *stop, int dist, int yf, int undo)
1809 {
1810         char *p;
1811
1812         // make sure start <= stop
1813         if (start > stop) {
1814                 // they are backwards, reverse them
1815                 p = start;
1816                 start = stop;
1817                 stop = p;
1818         }
1819         if (dist <= 0) {
1820                 // we cannot cross NL boundaries
1821                 p = start;
1822                 if (*p == '\n')
1823                         return p;
1824                 // dont go past a NewLine
1825                 for (; p + 1 <= stop; p++) {
1826                         if (p[1] == '\n') {
1827                                 stop = p;       // "stop" just before NewLine
1828                                 break;
1829                         }
1830                 }
1831         }
1832         p = start;
1833 #if ENABLE_FEATURE_VI_YANKMARK
1834         text_yank(start, stop, YDreg);
1835 #endif
1836         if (yf == YANKDEL) {
1837                 p = text_hole_delete(start, stop, undo);
1838         }                                       // delete lines
1839         return p;
1840 }
1841
1842 // might reallocate text[]!
1843 static int file_insert(const char *fn, char *p, int initial)
1844 {
1845         int cnt = -1;
1846         int fd, size;
1847         struct stat statbuf;
1848
1849         if (p < text)
1850                 p = text;
1851         if (p > end)
1852                 p = end;
1853
1854         fd = open(fn, O_RDONLY);
1855         if (fd < 0) {
1856                 if (!initial)
1857                         status_line_bold_errno(fn);
1858                 return cnt;
1859         }
1860
1861         // Validate file
1862         if (fstat(fd, &statbuf) < 0) {
1863                 status_line_bold_errno(fn);
1864                 goto fi;
1865         }
1866         if (!S_ISREG(statbuf.st_mode)) {
1867                 status_line_bold("'%s' is not a regular file", fn);
1868                 goto fi;
1869         }
1870         size = (statbuf.st_size < INT_MAX ? (int)statbuf.st_size : INT_MAX);
1871         p += text_hole_make(p, size);
1872         cnt = full_read(fd, p, size);
1873         if (cnt < 0) {
1874                 status_line_bold_errno(fn);
1875                 p = text_hole_delete(p, p + size - 1, NO_UNDO); // un-do buffer insert
1876         } else if (cnt < size) {
1877                 // There was a partial read, shrink unused space
1878                 p = text_hole_delete(p + cnt, p + size - 1, NO_UNDO);
1879                 status_line_bold("can't read '%s'", fn);
1880         }
1881  fi:
1882         close(fd);
1883
1884 #if ENABLE_FEATURE_VI_READONLY
1885         if (initial
1886          && ((access(fn, W_OK) < 0) ||
1887                 // root will always have access()
1888                 // so we check fileperms too
1889                 !(statbuf.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH))
1890             )
1891         ) {
1892                 SET_READONLY_FILE(readonly_mode);
1893         }
1894 #endif
1895         return cnt;
1896 }
1897
1898 // find matching char of pair  ()  []  {}
1899 // will crash if c is not one of these
1900 static char *find_pair(char *p, const char c)
1901 {
1902         const char *braces = "()[]{}";
1903         char match;
1904         int dir, level;
1905
1906         dir = strchr(braces, c) - braces;
1907         dir ^= 1;
1908         match = braces[dir];
1909         dir = ((dir & 1) << 1) - 1; // 1 for ([{, -1 for )\}
1910
1911         // look for match, count levels of pairs  (( ))
1912         level = 1;
1913         for (;;) {
1914                 p += dir;
1915                 if (p < text || p >= end)
1916                         return NULL;
1917                 if (*p == c)
1918                         level++;        // increase pair levels
1919                 if (*p == match) {
1920                         level--;        // reduce pair level
1921                         if (level == 0)
1922                                 return p; // found matching pair
1923                 }
1924         }
1925 }
1926
1927 #if ENABLE_FEATURE_VI_SETOPTS
1928 // show the matching char of a pair,  ()  []  {}
1929 static void showmatching(char *p)
1930 {
1931         char *q, *save_dot;
1932
1933         // we found half of a pair
1934         q = find_pair(p, *p);   // get loc of matching char
1935         if (q == NULL) {
1936                 indicate_error();       // no matching char
1937         } else {
1938                 // "q" now points to matching pair
1939                 save_dot = dot; // remember where we are
1940                 dot = q;                // go to new loc
1941                 refresh(FALSE); // let the user see it
1942                 mysleep(40);    // give user some time
1943                 dot = save_dot; // go back to old loc
1944                 refresh(FALSE);
1945         }
1946 }
1947 #endif /* FEATURE_VI_SETOPTS */
1948
1949 // might reallocate text[]! use p += stupid_insert(p, ...),
1950 // and be careful to not use pointers into potentially freed text[]!
1951 static uintptr_t stupid_insert(char *p, char c) // stupidly insert the char c at 'p'
1952 {
1953         uintptr_t bias;
1954         bias = text_hole_make(p, 1);
1955         p += bias;
1956         *p = c;
1957         return bias;
1958 }
1959
1960 #if !ENABLE_FEATURE_VI_UNDO
1961 #define char_insert(a,b,c) char_insert(a,b)
1962 #endif
1963 static char *char_insert(char *p, char c, int undo) // insert the char c at 'p'
1964 {
1965         if (c == 22) {          // Is this an ctrl-V?
1966                 p += stupid_insert(p, '^');     // use ^ to indicate literal next
1967                 refresh(FALSE); // show the ^
1968                 c = get_one_char();
1969                 *p = c;
1970 #if ENABLE_FEATURE_VI_UNDO
1971                 undo_push_insert(p, 1, undo);
1972 #else
1973                 modified_count++;
1974 #endif /* ENABLE_FEATURE_VI_UNDO */
1975                 p++;
1976         } else if (c == 27) {   // Is this an ESC?
1977                 cmd_mode = 0;
1978                 undo_queue_commit();
1979                 cmdcnt = 0;
1980                 end_cmd_q();    // stop adding to q
1981                 last_status_cksum = 0;  // force status update
1982                 if ((p[-1] != '\n') && (dot > text)) {
1983                         p--;
1984                 }
1985         } else if (c == erase_char || c == 8 || c == 127) { // Is this a BS
1986                 if (p > text) {
1987                         p--;
1988                         p = text_hole_delete(p, p, ALLOW_UNDO_QUEUED);  // shrink buffer 1 char
1989                 }
1990         } else {
1991                 // insert a char into text[]
1992                 if (c == 13)
1993                         c = '\n';       // translate \r to \n
1994 #if ENABLE_FEATURE_VI_UNDO
1995 # if ENABLE_FEATURE_VI_UNDO_QUEUE
1996                 if (c == '\n')
1997                         undo_queue_commit();
1998 # endif
1999                 undo_push_insert(p, 1, undo);
2000 #else
2001                 modified_count++;
2002 #endif /* ENABLE_FEATURE_VI_UNDO */
2003                 p += 1 + stupid_insert(p, c);   // insert the char
2004 #if ENABLE_FEATURE_VI_SETOPTS
2005                 if (showmatch && strchr(")]}", c) != NULL) {
2006                         showmatching(p - 1);
2007                 }
2008                 if (autoindent && c == '\n') {  // auto indent the new line
2009                         char *q;
2010                         size_t len;
2011                         q = prev_line(p);       // use prev line as template
2012                         len = strspn(q, " \t"); // space or tab
2013                         if (len) {
2014                                 uintptr_t bias;
2015                                 bias = text_hole_make(p, len);
2016                                 p += bias;
2017                                 q += bias;
2018 #if ENABLE_FEATURE_VI_UNDO
2019                                 undo_push_insert(p, len, undo);
2020 #endif
2021                                 memcpy(p, q, len);
2022                                 p += len;
2023                         }
2024                 }
2025 #endif
2026         }
2027         return p;
2028 }
2029
2030 // read text from file or create an empty buf
2031 // will also update current_filename
2032 static int init_text_buffer(char *fn)
2033 {
2034         int rc;
2035
2036         // allocate/reallocate text buffer
2037         free(text);
2038         text_size = 10240;
2039         screenbegin = dot = end = text = xzalloc(text_size);
2040
2041         if (fn != current_filename) {
2042                 free(current_filename);
2043                 current_filename = xstrdup(fn);
2044         }
2045         rc = file_insert(fn, text, 1);
2046         if (rc < 0) {
2047                 // file doesnt exist. Start empty buf with dummy line
2048                 char_insert(text, '\n', NO_UNDO);
2049         }
2050
2051         flush_undo_data();
2052         modified_count = 0;
2053         last_modified_count = -1;
2054 #if ENABLE_FEATURE_VI_YANKMARK
2055         // init the marks
2056         memset(mark, 0, sizeof(mark));
2057 #endif
2058         return rc;
2059 }
2060
2061 #if ENABLE_FEATURE_VI_YANKMARK \
2062  || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) \
2063  || ENABLE_FEATURE_VI_CRASHME
2064 // might reallocate text[]! use p += string_insert(p, ...),
2065 // and be careful to not use pointers into potentially freed text[]!
2066 # if !ENABLE_FEATURE_VI_UNDO
2067 #  define string_insert(a,b,c) string_insert(a,b)
2068 # endif
2069 static uintptr_t string_insert(char *p, const char *s, int undo) // insert the string at 'p'
2070 {
2071         uintptr_t bias;
2072         int i;
2073
2074         i = strlen(s);
2075 #if ENABLE_FEATURE_VI_UNDO
2076         undo_push_insert(p, i, undo);
2077 #endif
2078         bias = text_hole_make(p, i);
2079         p += bias;
2080         memcpy(p, s, i);
2081 #if ENABLE_FEATURE_VI_YANKMARK
2082         {
2083                 int cnt;
2084                 for (cnt = 0; *s != '\0'; s++) {
2085                         if (*s == '\n')
2086                                 cnt++;
2087                 }
2088                 status_line("Put %d lines (%d chars) from [%c]", cnt, i, what_reg());
2089         }
2090 #endif
2091         return bias;
2092 }
2093 #endif
2094
2095 static int file_write(char *fn, char *first, char *last)
2096 {
2097         int fd, cnt, charcnt;
2098
2099         if (fn == 0) {
2100                 status_line_bold("No current filename");
2101                 return -2;
2102         }
2103         // By popular request we do not open file with O_TRUNC,
2104         // but instead ftruncate() it _after_ successful write.
2105         // Might reduce amount of data lost on power fail etc.
2106         fd = open(fn, (O_WRONLY | O_CREAT), 0666);
2107         if (fd < 0)
2108                 return -1;
2109         cnt = last - first + 1;
2110         charcnt = full_write(fd, first, cnt);
2111         ftruncate(fd, charcnt);
2112         if (charcnt == cnt) {
2113                 // good write
2114                 //modified_count = FALSE;
2115         } else {
2116                 charcnt = 0;
2117         }
2118         close(fd);
2119         return charcnt;
2120 }
2121
2122 #if ENABLE_FEATURE_VI_SEARCH
2123 # if ENABLE_FEATURE_VI_REGEX_SEARCH
2124 // search for pattern starting at p
2125 static char *char_search(char *p, const char *pat, int dir_and_range)
2126 {
2127         struct re_pattern_buffer preg;
2128         const char *err;
2129         char *q;
2130         int i;
2131         int size;
2132         int range;
2133
2134         re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
2135         if (ignorecase)
2136                 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED | RE_ICASE;
2137
2138         memset(&preg, 0, sizeof(preg));
2139         err = re_compile_pattern(pat, strlen(pat), &preg);
2140         if (err != NULL) {
2141                 status_line_bold("bad search pattern '%s': %s", pat, err);
2142                 return p;
2143         }
2144
2145         range = (dir_and_range & 1);
2146         q = end - 1; // if FULL
2147         if (range == LIMITED)
2148                 q = next_line(p);
2149         if (dir_and_range < 0) { // BACK?
2150                 q = text;
2151                 if (range == LIMITED)
2152                         q = prev_line(p);
2153         }
2154
2155         // RANGE could be negative if we are searching backwards
2156         range = q - p;
2157         q = p;
2158         size = range;
2159         if (range < 0) {
2160                 size = -size;
2161                 q = p - size;
2162                 if (q < text)
2163                         q = text;
2164         }
2165         // search for the compiled pattern, preg, in p[]
2166         // range < 0: search backward
2167         // range > 0: search forward
2168         // 0 < start < size
2169         // re_search() < 0: not found or error
2170         // re_search() >= 0: index of found pattern
2171         //           struct pattern   char     int   int    int    struct reg
2172         // re_search(*pattern_buffer, *string, size, start, range, *regs)
2173         i = re_search(&preg, q, size, /*start:*/ 0, range, /*struct re_registers*:*/ NULL);
2174         regfree(&preg);
2175         if (i < 0)
2176                 return NULL;
2177         if (dir_and_range > 0) // FORWARD?
2178                 p = p + i;
2179         else
2180                 p = p - i;
2181         return p;
2182 }
2183 # else
2184 #  if ENABLE_FEATURE_VI_SETOPTS
2185 static int mycmp(const char *s1, const char *s2, int len)
2186 {
2187         if (ignorecase) {
2188                 return strncasecmp(s1, s2, len);
2189         }
2190         return strncmp(s1, s2, len);
2191 }
2192 #  else
2193 #   define mycmp strncmp
2194 #  endif
2195 static char *char_search(char *p, const char *pat, int dir_and_range)
2196 {
2197         char *start, *stop;
2198         int len;
2199         int range;
2200
2201         len = strlen(pat);
2202         range = (dir_and_range & 1);
2203         if (dir_and_range > 0) { //FORWARD?
2204                 stop = end - 1; // assume range is p..end-1
2205                 if (range == LIMITED)
2206                         stop = next_line(p);    // range is to next line
2207                 for (start = p; start < stop; start++) {
2208                         if (mycmp(start, pat, len) == 0) {
2209                                 return start;
2210                         }
2211                 }
2212         } else { //BACK
2213                 stop = text;    // assume range is text..p
2214                 if (range == LIMITED)
2215                         stop = prev_line(p);    // range is to prev line
2216                 for (start = p - len; start >= stop; start--) {
2217                         if (mycmp(start, pat, len) == 0) {
2218                                 return start;
2219                         }
2220                 }
2221         }
2222         // pattern not found
2223         return NULL;
2224 }
2225 # endif
2226 #endif /* FEATURE_VI_SEARCH */
2227
2228 //----- The Colon commands -------------------------------------
2229 #if ENABLE_FEATURE_VI_COLON
2230 static char *get_one_address(char *p, int *addr)        // get colon addr, if present
2231 {
2232         int st;
2233         char *q;
2234         IF_FEATURE_VI_YANKMARK(char c;)
2235         IF_FEATURE_VI_SEARCH(char *pat;)
2236
2237         *addr = -1;                     // assume no addr
2238         if (*p == '.') {        // the current line
2239                 p++;
2240                 q = begin_line(dot);
2241                 *addr = count_lines(text, q);
2242         }
2243 #if ENABLE_FEATURE_VI_YANKMARK
2244         else if (*p == '\'') {  // is this a mark addr
2245                 p++;
2246                 c = tolower(*p);
2247                 p++;
2248                 if (c >= 'a' && c <= 'z') {
2249                         // we have a mark
2250                         c = c - 'a';
2251                         q = mark[(unsigned char) c];
2252                         if (q != NULL) {        // is mark valid
2253                                 *addr = count_lines(text, q);
2254                         }
2255                 }
2256         }
2257 #endif
2258 #if ENABLE_FEATURE_VI_SEARCH
2259         else if (*p == '/') {   // a search pattern
2260                 q = strchrnul(++p, '/');
2261                 pat = xstrndup(p, q - p); // save copy of pattern
2262                 p = q;
2263                 if (*p == '/')
2264                         p++;
2265                 q = char_search(dot, pat, (FORWARD << 1) | FULL);
2266                 if (q != NULL) {
2267                         *addr = count_lines(text, q);
2268                 }
2269                 free(pat);
2270         }
2271 #endif
2272         else if (*p == '$') {   // the last line in file
2273                 p++;
2274                 q = begin_line(end - 1);
2275                 *addr = count_lines(text, q);
2276         } else if (isdigit(*p)) {       // specific line number
2277                 sscanf(p, "%d%n", addr, &st);
2278                 p += st;
2279         } else {
2280                 // unrecognized address - assume -1
2281                 *addr = -1;
2282         }
2283         return p;
2284 }
2285
2286 static char *get_address(char *p, int *b, int *e)       // get two colon addrs, if present
2287 {
2288         //----- get the address' i.e., 1,3   'a,'b  -----
2289         // get FIRST addr, if present
2290         while (isblank(*p))
2291                 p++;                            // skip over leading spaces
2292         if (*p == '%') {                        // alias for 1,$
2293                 p++;
2294                 *b = 1;
2295                 *e = count_lines(text, end-1);
2296                 goto ga0;
2297         }
2298         p = get_one_address(p, b);
2299         while (isblank(*p))
2300                 p++;
2301         if (*p == ',') {                        // is there a address separator
2302                 p++;
2303                 while (isblank(*p))
2304                         p++;
2305                 // get SECOND addr, if present
2306                 p = get_one_address(p, e);
2307         }
2308  ga0:
2309         while (isblank(*p))
2310                 p++;                            // skip over trailing spaces
2311         return p;
2312 }
2313
2314 #if ENABLE_FEATURE_VI_SET && ENABLE_FEATURE_VI_SETOPTS
2315 static void setops(const char *args, const char *opname, int flg_no,
2316                         const char *short_opname, int opt)
2317 {
2318         const char *a = args + flg_no;
2319         int l = strlen(opname) - 1; // opname have + ' '
2320
2321         // maybe strncmp? we had tons of erroneous strncasecmp's...
2322         if (strncasecmp(a, opname, l) == 0
2323          || strncasecmp(a, short_opname, 2) == 0
2324         ) {
2325                 if (flg_no)
2326                         vi_setops &= ~opt;
2327                 else
2328                         vi_setops |= opt;
2329         }
2330 }
2331 #endif
2332
2333 #endif /* FEATURE_VI_COLON */
2334
2335 // buf must be no longer than MAX_INPUT_LEN!
2336 static void colon(char *buf)
2337 {
2338 #if !ENABLE_FEATURE_VI_COLON
2339         // Simple ":cmd" handler with minimal set of commands
2340         char *p = buf;
2341         int cnt;
2342
2343         if (*p == ':')
2344                 p++;
2345         cnt = strlen(p);
2346         if (cnt == 0)
2347                 return;
2348         if (strncmp(p, "quit", cnt) == 0
2349          || strncmp(p, "q!", cnt) == 0
2350         ) {
2351                 if (modified_count && p[1] != '!') {
2352                         status_line_bold("No write since last change (:%s! overrides)", p);
2353                 } else {
2354                         editing = 0;
2355                 }
2356                 return;
2357         }
2358         if (strncmp(p, "write", cnt) == 0
2359          || strncmp(p, "wq", cnt) == 0
2360          || strncmp(p, "wn", cnt) == 0
2361          || (p[0] == 'x' && !p[1])
2362         ) {
2363                 if (modified_count != 0 || p[0] != 'x') {
2364                         cnt = file_write(current_filename, text, end - 1);
2365                 }
2366                 if (cnt < 0) {
2367                         if (cnt == -1)
2368                                 status_line_bold("Write error: "STRERROR_FMT STRERROR_ERRNO);
2369                 } else {
2370                         modified_count = 0;
2371                         last_modified_count = -1;
2372                         status_line("'%s' %dL, %dC",
2373                                 current_filename,
2374                                 count_lines(text, end - 1), cnt
2375                         );
2376                         if (p[0] == 'x'
2377                          || p[1] == 'q' || p[1] == 'n'
2378                          || p[1] == 'Q' || p[1] == 'N'
2379                         ) {
2380                                 editing = 0;
2381                         }
2382                 }
2383                 return;
2384         }
2385         if (strncmp(p, "file", cnt) == 0) {
2386                 last_status_cksum = 0;  // force status update
2387                 return;
2388         }
2389         if (sscanf(p, "%d", &cnt) > 0) {
2390                 dot = find_line(cnt);
2391                 dot_skip_over_ws();
2392                 return;
2393         }
2394         not_implemented(p);
2395 #else
2396
2397         char c, *buf1, *q, *r;
2398         char *fn, cmd[MAX_INPUT_LEN], args[MAX_INPUT_LEN];
2399         int i, l, li, b, e;
2400         int useforce;
2401 # if ENABLE_FEATURE_VI_SEARCH || ENABLE_FEATURE_ALLOW_EXEC
2402         char *orig_buf;
2403 # endif
2404
2405         // :3154        // if (-e line 3154) goto it  else stay put
2406         // :4,33w! foo  // write a portion of buffer to file "foo"
2407         // :w           // write all of buffer to current file
2408         // :q           // quit
2409         // :q!          // quit- dont care about modified file
2410         // :'a,'z!sort -u   // filter block through sort
2411         // :'f          // goto mark "f"
2412         // :'fl         // list literal the mark "f" line
2413         // :.r bar      // read file "bar" into buffer before dot
2414         // :/123/,/abc/d    // delete lines from "123" line to "abc" line
2415         // :/xyz/       // goto the "xyz" line
2416         // :s/find/replace/ // substitute pattern "find" with "replace"
2417         // :!<cmd>      // run <cmd> then return
2418         //
2419
2420         if (!buf[0])
2421                 goto ret;
2422         if (*buf == ':')
2423                 buf++;                  // move past the ':'
2424
2425         li = i = 0;
2426         b = e = -1;
2427         q = text;                       // assume 1,$ for the range
2428         r = end - 1;
2429         li = count_lines(text, end - 1);
2430         fn = current_filename;
2431
2432         // look for optional address(es)  :.  :1  :1,9   :'q,'a   :%
2433         buf = get_address(buf, &b, &e);
2434
2435 # if ENABLE_FEATURE_VI_SEARCH || ENABLE_FEATURE_ALLOW_EXEC
2436         // remember orig command line
2437         orig_buf = buf;
2438 # endif
2439
2440         // get the COMMAND into cmd[]
2441         buf1 = cmd;
2442         while (*buf != '\0') {
2443                 if (isspace(*buf))
2444                         break;
2445                 *buf1++ = *buf++;
2446         }
2447         *buf1 = '\0';
2448         // get any ARGuments
2449         while (isblank(*buf))
2450                 buf++;
2451         strcpy(args, buf);
2452         useforce = FALSE;
2453         buf1 = last_char_is(cmd, '!');
2454         if (buf1) {
2455                 useforce = TRUE;
2456                 *buf1 = '\0';   // get rid of !
2457         }
2458         if (b >= 0) {
2459                 // if there is only one addr, then the addr
2460                 // is the line number of the single line the
2461                 // user wants. So, reset the end
2462                 // pointer to point at end of the "b" line
2463                 q = find_line(b);       // what line is #b
2464                 r = end_line(q);
2465                 li = 1;
2466         }
2467         if (e >= 0) {
2468                 // we were given two addrs.  change the
2469                 // end pointer to the addr given by user.
2470                 r = find_line(e);       // what line is #e
2471                 r = end_line(r);
2472                 li = e - b + 1;
2473         }
2474         // ------------ now look for the command ------------
2475         i = strlen(cmd);
2476         if (i == 0) {           // :123CR goto line #123
2477                 if (b >= 0) {
2478                         dot = find_line(b);     // what line is #b
2479                         dot_skip_over_ws();
2480                 }
2481         }
2482 # if ENABLE_FEATURE_ALLOW_EXEC
2483         else if (cmd[0] == '!') {       // run a cmd
2484                 int retcode;
2485                 // :!ls   run the <cmd>
2486                 go_bottom_and_clear_to_eol();
2487                 cookmode();
2488                 retcode = system(orig_buf + 1); // run the cmd
2489                 if (retcode)
2490                         printf("\nshell returned %i\n\n", retcode);
2491                 rawmode();
2492                 Hit_Return();                   // let user see results
2493         }
2494 # endif
2495         else if (cmd[0] == '=' && !cmd[1]) {    // where is the address
2496                 if (b < 0) {    // no addr given- use defaults
2497                         b = e = count_lines(text, dot);
2498                 }
2499                 status_line("%d", b);
2500         } else if (strncmp(cmd, "delete", i) == 0) {    // delete lines
2501                 if (b < 0) {    // no addr given- use defaults
2502                         q = begin_line(dot);    // assume .,. for the range
2503                         r = end_line(dot);
2504                 }
2505                 dot = yank_delete(q, r, 1, YANKDEL, ALLOW_UNDO);        // save, then delete lines
2506                 dot_skip_over_ws();
2507         } else if (strncmp(cmd, "edit", i) == 0) {      // Edit a file
2508                 int size;
2509
2510                 // don't edit, if the current file has been modified
2511                 if (modified_count && !useforce) {
2512                         status_line_bold("No write since last change (:%s! overrides)", cmd);
2513                         goto ret;
2514                 }
2515                 if (args[0]) {
2516                         // the user supplied a file name
2517                         fn = args;
2518                 } else if (current_filename && current_filename[0]) {
2519                         // no user supplied name- use the current filename
2520                         // fn = current_filename;  was set by default
2521                 } else {
2522                         // no user file name, no current name- punt
2523                         status_line_bold("No current filename");
2524                         goto ret;
2525                 }
2526
2527                 size = init_text_buffer(fn);
2528
2529 # if ENABLE_FEATURE_VI_YANKMARK
2530                 if (Ureg >= 0 && Ureg < 28) {
2531                         free(reg[Ureg]);        //   free orig line reg- for 'U'
2532                         reg[Ureg] = NULL;
2533                 }
2534                 if (YDreg >= 0 && YDreg < 28) {
2535                         free(reg[YDreg]);       //   free default yank/delete register
2536                         reg[YDreg] = NULL;
2537                 }
2538 # endif
2539                 // how many lines in text[]?
2540                 li = count_lines(text, end - 1);
2541                 status_line("'%s'%s"
2542                         IF_FEATURE_VI_READONLY("%s")
2543                         " %dL, %dC",
2544                         current_filename,
2545                         (size < 0 ? " [New file]" : ""),
2546                         IF_FEATURE_VI_READONLY(
2547                                 ((readonly_mode) ? " [Readonly]" : ""),
2548                         )
2549                         li, (int)(end - text)
2550                 );
2551         } else if (strncmp(cmd, "file", i) == 0) {      // what File is this
2552                 if (b != -1 || e != -1) {
2553                         status_line_bold("No address allowed on this command");
2554                         goto ret;
2555                 }
2556                 if (args[0]) {
2557                         // user wants a new filename
2558                         free(current_filename);
2559                         current_filename = xstrdup(args);
2560                 } else {
2561                         // user wants file status info
2562                         last_status_cksum = 0;  // force status update
2563                 }
2564         } else if (strncmp(cmd, "features", i) == 0) {  // what features are available
2565                 // print out values of all features
2566                 go_bottom_and_clear_to_eol();
2567                 cookmode();
2568                 show_help();
2569                 rawmode();
2570                 Hit_Return();
2571         } else if (strncmp(cmd, "list", i) == 0) {      // literal print line
2572                 if (b < 0) {    // no addr given- use defaults
2573                         q = begin_line(dot);    // assume .,. for the range
2574                         r = end_line(dot);
2575                 }
2576                 go_bottom_and_clear_to_eol();
2577                 puts("\r");
2578                 for (; q <= r; q++) {
2579                         int c_is_no_print;
2580
2581                         c = *q;
2582                         c_is_no_print = (c & 0x80) && !Isprint(c);
2583                         if (c_is_no_print) {
2584                                 c = '.';
2585                                 standout_start();
2586                         }
2587                         if (c == '\n') {
2588                                 write1("$\r");
2589                         } else if (c < ' ' || c == 127) {
2590                                 bb_putchar('^');
2591                                 if (c == 127)
2592                                         c = '?';
2593                                 else
2594                                         c += '@';
2595                         }
2596                         bb_putchar(c);
2597                         if (c_is_no_print)
2598                                 standout_end();
2599                 }
2600                 Hit_Return();
2601         } else if (strncmp(cmd, "quit", i) == 0 // quit
2602                 || strncmp(cmd, "next", i) == 0 // edit next file
2603                 || strncmp(cmd, "prev", i) == 0 // edit previous file
2604         ) {
2605                 int n;
2606                 if (useforce) {
2607                         if (*cmd == 'q') {
2608                                 // force end of argv list
2609                                 optind = save_argc;
2610                         }
2611                         editing = 0;
2612                         goto ret;
2613                 }
2614                 // don't exit if the file been modified
2615                 if (modified_count) {
2616                         status_line_bold("No write since last change (:%s! overrides)", cmd);
2617                         goto ret;
2618                 }
2619                 // are there other file to edit
2620                 n = save_argc - optind - 1;
2621                 if (*cmd == 'q' && n > 0) {
2622                         status_line_bold("%d more file(s) to edit", n);
2623                         goto ret;
2624                 }
2625                 if (*cmd == 'n' && n <= 0) {
2626                         status_line_bold("No more files to edit");
2627                         goto ret;
2628                 }
2629                 if (*cmd == 'p') {
2630                         // are there previous files to edit
2631                         if (optind < 1) {
2632                                 status_line_bold("No previous files to edit");
2633                                 goto ret;
2634                         }
2635                         optind -= 2;
2636                 }
2637                 editing = 0;
2638         } else if (strncmp(cmd, "read", i) == 0) {      // read file into text[]
2639                 int size;
2640
2641                 fn = args;
2642                 if (!fn[0]) {
2643                         status_line_bold("No filename given");
2644                         goto ret;
2645                 }
2646                 if (b < 0) {    // no addr given- use defaults
2647                         q = begin_line(dot);    // assume "dot"
2648                 }
2649                 // read after current line- unless user said ":0r foo"
2650                 if (b != 0) {
2651                         q = next_line(q);
2652                         // read after last line
2653                         if (q == end-1)
2654                                 ++q;
2655                 }
2656                 { // dance around potentially-reallocated text[]
2657                         uintptr_t ofs = q - text;
2658                         size = file_insert(fn, q, 0);
2659                         q = text + ofs;
2660                 }
2661                 if (size < 0)
2662                         goto ret;       // nothing was inserted
2663                 // how many lines in text[]?
2664                 li = count_lines(q, q + size - 1);
2665                 status_line("'%s'"
2666                         IF_FEATURE_VI_READONLY("%s")
2667                         " %dL, %dC",
2668                         fn,
2669                         IF_FEATURE_VI_READONLY((readonly_mode ? " [Readonly]" : ""),)
2670                         li, size
2671                 );
2672                 if (size > 0) {
2673                         // if the insert is before "dot" then we need to update
2674                         if (q <= dot)
2675                                 dot += size;
2676                 }
2677         } else if (strncmp(cmd, "rewind", i) == 0) {    // rewind cmd line args
2678                 if (modified_count && !useforce) {
2679                         status_line_bold("No write since last change (:%s! overrides)", cmd);
2680                 } else {
2681                         // reset the filenames to edit
2682                         optind = -1; // start from 0th file
2683                         editing = 0;
2684                 }
2685 # if ENABLE_FEATURE_VI_SET
2686         } else if (strncmp(cmd, "set", i) == 0) {       // set or clear features
2687 #  if ENABLE_FEATURE_VI_SETOPTS
2688                 char *argp;
2689 #  endif
2690                 i = 0;                  // offset into args
2691                 // only blank is regarded as args delimiter. What about tab '\t'?
2692                 if (!args[0] || strcasecmp(args, "all") == 0) {
2693                         // print out values of all options
2694 #  if ENABLE_FEATURE_VI_SETOPTS
2695                         status_line_bold(
2696                                 "%sautoindent "
2697                                 "%sflash "
2698                                 "%signorecase "
2699                                 "%sshowmatch "
2700                                 "tabstop=%u",
2701                                 autoindent ? "" : "no",
2702                                 err_method ? "" : "no",
2703                                 ignorecase ? "" : "no",
2704                                 showmatch ? "" : "no",
2705                                 tabstop
2706                         );
2707 #  endif
2708                         goto ret;
2709                 }
2710 #  if ENABLE_FEATURE_VI_SETOPTS
2711                 argp = args;
2712                 while (*argp) {
2713                         if (strncmp(argp, "no", 2) == 0)
2714                                 i = 2;          // ":set noautoindent"
2715                         setops(argp, "autoindent ", i, "ai", VI_AUTOINDENT);
2716                         setops(argp, "flash "     , i, "fl", VI_ERR_METHOD);
2717                         setops(argp, "ignorecase ", i, "ic", VI_IGNORECASE);
2718                         setops(argp, "showmatch " , i, "sm", VI_SHOWMATCH );
2719                         if (strncmp(argp + i, "tabstop=", 8) == 0) {
2720                                 int t = 0;
2721                                 sscanf(argp + i+8, "%u", &t);
2722                                 if (t > 0 && t <= MAX_TABSTOP)
2723                                         tabstop = t;
2724                         }
2725                         argp = skip_non_whitespace(argp);
2726                         argp = skip_whitespace(argp);
2727                 }
2728 #  endif /* FEATURE_VI_SETOPTS */
2729 # endif /* FEATURE_VI_SET */
2730
2731 # if ENABLE_FEATURE_VI_SEARCH
2732         } else if (cmd[0] == 's') {     // substitute a pattern with a replacement pattern
2733                 char *F, *R, *flags;
2734                 size_t len_F, len_R;
2735                 int gflag;              // global replace flag
2736 #  if ENABLE_FEATURE_VI_UNDO
2737                 int dont_chain_first_item = ALLOW_UNDO;
2738 #  endif
2739
2740                 // F points to the "find" pattern
2741                 // R points to the "replace" pattern
2742                 // replace the cmd line delimiters "/" with NULs
2743                 c = orig_buf[1];        // what is the delimiter
2744                 F = orig_buf + 2;       // start of "find"
2745                 R = strchr(F, c);       // middle delimiter
2746                 if (!R)
2747                         goto colon_s_fail;
2748                 len_F = R - F;
2749                 *R++ = '\0';    // terminate "find"
2750                 flags = strchr(R, c);
2751                 if (!flags)
2752                         goto colon_s_fail;
2753                 len_R = flags - R;
2754                 *flags++ = '\0';        // terminate "replace"
2755                 gflag = *flags;
2756
2757                 q = begin_line(q);
2758                 if (b < 0) {    // maybe :s/foo/bar/
2759                         q = begin_line(dot);      // start with cur line
2760                         b = count_lines(text, q); // cur line number
2761                 }
2762                 if (e < 0)
2763                         e = b;          // maybe :.s/foo/bar/
2764
2765                 for (i = b; i <= e; i++) {      // so, :20,23 s \0 find \0 replace \0
2766                         char *ls = q;           // orig line start
2767                         char *found;
2768  vc4:
2769                         found = char_search(q, F, (FORWARD << 1) | LIMITED);    // search cur line only for "find"
2770                         if (found) {
2771                                 uintptr_t bias;
2772                                 // we found the "find" pattern - delete it
2773                                 // For undo support, the first item should not be chained
2774                                 text_hole_delete(found, found + len_F - 1, dont_chain_first_item);
2775 #  if ENABLE_FEATURE_VI_UNDO
2776                                 dont_chain_first_item = ALLOW_UNDO_CHAIN;
2777 #  endif
2778                                 // insert the "replace" patern
2779                                 bias = string_insert(found, R, ALLOW_UNDO_CHAIN);
2780                                 found += bias;
2781                                 ls += bias;
2782                                 /*q += bias; - recalculated anyway */
2783                                 // check for "global"  :s/foo/bar/g
2784                                 if (gflag == 'g') {
2785                                         if ((found + len_R) < end_line(ls)) {
2786                                                 q = found + len_R;
2787                                                 goto vc4;       // don't let q move past cur line
2788                                         }
2789                                 }
2790                         }
2791                         q = next_line(ls);
2792                 }
2793 # endif /* FEATURE_VI_SEARCH */
2794         } else if (strncmp(cmd, "version", i) == 0) {  // show software version
2795                 status_line(BB_VER);
2796         } else if (strncmp(cmd, "write", i) == 0  // write text to file
2797                 || strncmp(cmd, "wq", i) == 0
2798                 || strncmp(cmd, "wn", i) == 0
2799                 || (cmd[0] == 'x' && !cmd[1])
2800         ) {
2801                 int size;
2802                 //int forced = FALSE;
2803
2804                 // is there a file name to write to?
2805                 if (args[0]) {
2806                         fn = args;
2807                 }
2808 # if ENABLE_FEATURE_VI_READONLY
2809                 if (readonly_mode && !useforce) {
2810                         status_line_bold("'%s' is read only", fn);
2811                         goto ret;
2812                 }
2813 # endif
2814                 //if (useforce) {
2815                         // if "fn" is not write-able, chmod u+w
2816                         // sprintf(syscmd, "chmod u+w %s", fn);
2817                         // system(syscmd);
2818                         // forced = TRUE;
2819                 //}
2820                 if (modified_count != 0 || cmd[0] != 'x') {
2821                         size = r - q + 1;
2822                         l = file_write(fn, q, r);
2823                 } else {
2824                         size = 0;
2825                         l = 0;
2826                 }
2827                 //if (useforce && forced) {
2828                         // chmod u-w
2829                         // sprintf(syscmd, "chmod u-w %s", fn);
2830                         // system(syscmd);
2831                         // forced = FALSE;
2832                 //}
2833                 if (l < 0) {
2834                         if (l == -1)
2835                                 status_line_bold_errno(fn);
2836                 } else {
2837                         // how many lines written
2838                         li = count_lines(q, q + l - 1);
2839                         status_line("'%s' %dL, %dC", fn, li, l);
2840                         if (l == size) {
2841                                 if (q == text && q + l == end) {
2842                                         modified_count = 0;
2843                                         last_modified_count = -1;
2844                                 }
2845                                 if (cmd[0] == 'x'
2846                                  || cmd[1] == 'q' || cmd[1] == 'n'
2847                                  || cmd[1] == 'Q' || cmd[1] == 'N'
2848                                 ) {
2849                                         editing = 0;
2850                                 }
2851                         }
2852                 }
2853 # if ENABLE_FEATURE_VI_YANKMARK
2854         } else if (strncmp(cmd, "yank", i) == 0) {      // yank lines
2855                 if (b < 0) {    // no addr given- use defaults
2856                         q = begin_line(dot);    // assume .,. for the range
2857                         r = end_line(dot);
2858                 }
2859                 text_yank(q, r, YDreg);
2860                 li = count_lines(q, r);
2861                 status_line("Yank %d lines (%d chars) into [%c]",
2862                                 li, strlen(reg[YDreg]), what_reg());
2863 # endif
2864         } else {
2865                 // cmd unknown
2866                 not_implemented(cmd);
2867         }
2868  ret:
2869         dot = bound_dot(dot);   // make sure "dot" is valid
2870         return;
2871 # if ENABLE_FEATURE_VI_SEARCH
2872  colon_s_fail:
2873         status_line(":s expression missing delimiters");
2874 # endif
2875 #endif /* FEATURE_VI_COLON */
2876 }
2877
2878 //----- Helper Utility Routines --------------------------------
2879
2880 //----------------------------------------------------------------
2881 //----- Char Routines --------------------------------------------
2882 /* Chars that are part of a word-
2883  *    0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
2884  * Chars that are Not part of a word (stoppers)
2885  *    !"#$%&'()*+,-./:;<=>?@[\]^`{|}~
2886  * Chars that are WhiteSpace
2887  *    TAB NEWLINE VT FF RETURN SPACE
2888  * DO NOT COUNT NEWLINE AS WHITESPACE
2889  */
2890
2891 static char *new_screen(int ro, int co)
2892 {
2893         int li;
2894
2895         free(screen);
2896         screensize = ro * co + 8;
2897         screen = xmalloc(screensize);
2898         // initialize the new screen. assume this will be a empty file.
2899         screen_erase();
2900         //   non-existent text[] lines start with a tilde (~).
2901         for (li = 1; li < ro - 1; li++) {
2902                 screen[(li * co) + 0] = '~';
2903         }
2904         return screen;
2905 }
2906
2907 static int st_test(char *p, int type, int dir, char *tested)
2908 {
2909         char c, c0, ci;
2910         int test, inc;
2911
2912         inc = dir;
2913         c = c0 = p[0];
2914         ci = p[inc];
2915         test = 0;
2916
2917         if (type == S_BEFORE_WS) {
2918                 c = ci;
2919                 test = (!isspace(c) || c == '\n');
2920         }
2921         if (type == S_TO_WS) {
2922                 c = c0;
2923                 test = (!isspace(c) || c == '\n');
2924         }
2925         if (type == S_OVER_WS) {
2926                 c = c0;
2927                 test = isspace(c);
2928         }
2929         if (type == S_END_PUNCT) {
2930                 c = ci;
2931                 test = ispunct(c);
2932         }
2933         if (type == S_END_ALNUM) {
2934                 c = ci;
2935                 test = (isalnum(c) || c == '_');
2936         }
2937         *tested = c;
2938         return test;
2939 }
2940
2941 static char *skip_thing(char *p, int linecnt, int dir, int type)
2942 {
2943         char c;
2944
2945         while (st_test(p, type, dir, &c)) {
2946                 // make sure we limit search to correct number of lines
2947                 if (c == '\n' && --linecnt < 1)
2948                         break;
2949                 if (dir >= 0 && p >= end - 1)
2950                         break;
2951                 if (dir < 0 && p <= text)
2952                         break;
2953                 p += dir;               // move to next char
2954         }
2955         return p;
2956 }
2957
2958 #if ENABLE_FEATURE_VI_USE_SIGNALS
2959 static void winch_handler(int sig UNUSED_PARAM)
2960 {
2961         int save_errno = errno;
2962         // FIXME: do it in main loop!!!
2963         signal(SIGWINCH, winch_handler);
2964         query_screen_dimensions();
2965         new_screen(rows, columns);      // get memory for virtual screen
2966         redraw(TRUE);           // re-draw the screen
2967         errno = save_errno;
2968 }
2969 static void tstp_handler(int sig UNUSED_PARAM)
2970 {
2971         int save_errno = errno;
2972
2973         // ioctl inside cookmode() was seen to generate SIGTTOU,
2974         // stopping us too early. Prevent that:
2975         signal(SIGTTOU, SIG_IGN);
2976
2977         go_bottom_and_clear_to_eol();
2978         cookmode(); // terminal to "cooked"
2979
2980         // stop now
2981         //signal(SIGTSTP, SIG_DFL);
2982         //raise(SIGTSTP);
2983         raise(SIGSTOP); // avoid "dance" with TSTP handler - use SIGSTOP instead
2984         //signal(SIGTSTP, tstp_handler);
2985
2986         // we have been "continued" with SIGCONT, restore screen and termios
2987         rawmode(); // terminal to "raw"
2988         last_status_cksum = 0; // force status update
2989         redraw(TRUE); // re-draw the screen
2990
2991         errno = save_errno;
2992 }
2993 static void int_handler(int sig)
2994 {
2995         signal(SIGINT, int_handler);
2996         siglongjmp(restart, sig);
2997 }
2998 #endif /* FEATURE_VI_USE_SIGNALS */
2999
3000 static void do_cmd(int c);
3001
3002 static int find_range(char **start, char **stop, char c)
3003 {
3004         char *save_dot, *p, *q, *t;
3005         int cnt, multiline = 0;
3006
3007         save_dot = dot;
3008         p = q = dot;
3009
3010         if (strchr("cdy><", c)) {
3011                 // these cmds operate on whole lines
3012                 p = q = begin_line(p);
3013                 for (cnt = 1; cnt < cmdcnt; cnt++) {
3014                         q = next_line(q);
3015                 }
3016                 q = end_line(q);
3017         } else if (strchr("^%$0bBeEfth\b\177", c)) {
3018                 // These cmds operate on char positions
3019                 do_cmd(c);              // execute movement cmd
3020                 q = dot;
3021         } else if (strchr("wW", c)) {
3022                 do_cmd(c);              // execute movement cmd
3023                 // if we are at the next word's first char
3024                 // step back one char
3025                 // but check the possibilities when it is true
3026                 if (dot > text && ((isspace(dot[-1]) && !isspace(dot[0]))
3027                                 || (ispunct(dot[-1]) && !ispunct(dot[0]))
3028                                 || (isalnum(dot[-1]) && !isalnum(dot[0]))))
3029                         dot--;          // move back off of next word
3030                 if (dot > text && *dot == '\n')
3031                         dot--;          // stay off NL
3032                 q = dot;
3033         } else if (strchr("H-k{", c)) {
3034                 // these operate on multi-lines backwards
3035                 q = end_line(dot);      // find NL
3036                 do_cmd(c);              // execute movement cmd
3037                 dot_begin();
3038                 p = dot;
3039         } else if (strchr("L+j}\r\n", c)) {
3040                 // these operate on multi-lines forwards
3041                 p = begin_line(dot);
3042                 do_cmd(c);              // execute movement cmd
3043                 dot_end();              // find NL
3044                 q = dot;
3045         } else {
3046                 // nothing -- this causes any other values of c to
3047                 // represent the one-character range under the
3048                 // cursor.  this is correct for ' ' and 'l', but
3049                 // perhaps no others.
3050                 //
3051         }
3052         if (q < p) {
3053                 t = q;
3054                 q = p;
3055                 p = t;
3056         }
3057
3058         // backward char movements don't include start position
3059         if (q > p && strchr("^0bBh\b\177", c)) q--;
3060
3061         multiline = 0;
3062         for (t = p; t <= q; t++) {
3063                 if (*t == '\n') {
3064                         multiline = 1;
3065                         break;
3066                 }
3067         }
3068
3069         *start = p;
3070         *stop = q;
3071         dot = save_dot;
3072         return multiline;
3073 }
3074
3075 //---------------------------------------------------------------------
3076 //----- the Ascii Chart -----------------------------------------------
3077 //  00 nul   01 soh   02 stx   03 etx   04 eot   05 enq   06 ack   07 bel
3078 //  08 bs    09 ht    0a nl    0b vt    0c np    0d cr    0e so    0f si
3079 //  10 dle   11 dc1   12 dc2   13 dc3   14 dc4   15 nak   16 syn   17 etb
3080 //  18 can   19 em    1a sub   1b esc   1c fs    1d gs    1e rs    1f us
3081 //  20 sp    21 !     22 "     23 #     24 $     25 %     26 &     27 '
3082 //  28 (     29 )     2a *     2b +     2c ,     2d -     2e .     2f /
3083 //  30 0     31 1     32 2     33 3     34 4     35 5     36 6     37 7
3084 //  38 8     39 9     3a :     3b ;     3c <     3d =     3e >     3f ?
3085 //  40 @     41 A     42 B     43 C     44 D     45 E     46 F     47 G
3086 //  48 H     49 I     4a J     4b K     4c L     4d M     4e N     4f O
3087 //  50 P     51 Q     52 R     53 S     54 T     55 U     56 V     57 W
3088 //  58 X     59 Y     5a Z     5b [     5c \     5d ]     5e ^     5f _
3089 //  60 `     61 a     62 b     63 c     64 d     65 e     66 f     67 g
3090 //  68 h     69 i     6a j     6b k     6c l     6d m     6e n     6f o
3091 //  70 p     71 q     72 r     73 s     74 t     75 u     76 v     77 w
3092 //  78 x     79 y     7a z     7b {     7c |     7d }     7e ~     7f del
3093 //---------------------------------------------------------------------
3094
3095 //----- Execute a Vi Command -----------------------------------
3096 static void do_cmd(int c)
3097 {
3098         char *p, *q, *save_dot;
3099         char buf[12];
3100         int dir;
3101         int cnt, i, j;
3102         int c1;
3103
3104 //      c1 = c; // quiet the compiler
3105 //      cnt = yf = 0; // quiet the compiler
3106 //      p = q = save_dot = buf; // quiet the compiler
3107         memset(buf, '\0', sizeof(buf));
3108
3109         show_status_line();
3110
3111         // if this is a cursor key, skip these checks
3112         switch (c) {
3113                 case KEYCODE_UP:
3114                 case KEYCODE_DOWN:
3115                 case KEYCODE_LEFT:
3116                 case KEYCODE_RIGHT:
3117                 case KEYCODE_HOME:
3118                 case KEYCODE_END:
3119                 case KEYCODE_PAGEUP:
3120                 case KEYCODE_PAGEDOWN:
3121                 case KEYCODE_DELETE:
3122                         goto key_cmd_mode;
3123         }
3124
3125         if (cmd_mode == 2) {
3126                 //  flip-flop Insert/Replace mode
3127                 if (c == KEYCODE_INSERT)
3128                         goto dc_i;
3129                 // we are 'R'eplacing the current *dot with new char
3130                 if (*dot == '\n') {
3131                         // don't Replace past E-o-l
3132                         cmd_mode = 1;   // convert to insert
3133                         undo_queue_commit();
3134                 } else {
3135                         if (1 <= c || Isprint(c)) {
3136                                 if (c != 27)
3137                                         dot = yank_delete(dot, dot, 0, YANKDEL, ALLOW_UNDO);    // delete char
3138                                 dot = char_insert(dot, c, ALLOW_UNDO_CHAIN);    // insert new char
3139                         }
3140                         goto dc1;
3141                 }
3142         }
3143         if (cmd_mode == 1) {
3144                 // hitting "Insert" twice means "R" replace mode
3145                 if (c == KEYCODE_INSERT) goto dc5;
3146                 // insert the char c at "dot"
3147                 if (1 <= c || Isprint(c)) {
3148                         dot = char_insert(dot, c, ALLOW_UNDO_QUEUED);
3149                 }
3150                 goto dc1;
3151         }
3152
3153  key_cmd_mode:
3154         switch (c) {
3155                 //case 0x01:    // soh
3156                 //case 0x09:    // ht
3157                 //case 0x0b:    // vt
3158                 //case 0x0e:    // so
3159                 //case 0x0f:    // si
3160                 //case 0x10:    // dle
3161                 //case 0x11:    // dc1
3162                 //case 0x13:    // dc3
3163 #if ENABLE_FEATURE_VI_CRASHME
3164         case 0x14:                      // dc4  ctrl-T
3165                 crashme = (crashme == 0) ? 1 : 0;
3166                 break;
3167 #endif
3168                 //case 0x16:    // syn
3169                 //case 0x17:    // etb
3170                 //case 0x18:    // can
3171                 //case 0x1c:    // fs
3172                 //case 0x1d:    // gs
3173                 //case 0x1e:    // rs
3174                 //case 0x1f:    // us
3175                 //case '!':     // !-
3176                 //case '#':     // #-
3177                 //case '&':     // &-
3178                 //case '(':     // (-
3179                 //case ')':     // )-
3180                 //case '*':     // *-
3181                 //case '=':     // =-
3182                 //case '@':     // @-
3183                 //case 'F':     // F-
3184                 //case 'K':     // K-
3185                 //case 'Q':     // Q-
3186                 //case 'S':     // S-
3187                 //case 'T':     // T-
3188                 //case 'V':     // V-
3189                 //case '[':     // [-
3190                 //case '\\':    // \-
3191                 //case ']':     // ]-
3192                 //case '_':     // _-
3193                 //case '`':     // `-
3194                 //case 'v':     // v-
3195         default:                        // unrecognized command
3196                 buf[0] = c;
3197                 buf[1] = '\0';
3198                 not_implemented(buf);
3199                 end_cmd_q();    // stop adding to q
3200         case 0x00:                      // nul- ignore
3201                 break;
3202         case 2:                 // ctrl-B  scroll up   full screen
3203         case KEYCODE_PAGEUP:    // Cursor Key Page Up
3204                 dot_scroll(rows - 2, -1);
3205                 break;
3206         case 4:                 // ctrl-D  scroll down half screen
3207                 dot_scroll((rows - 2) / 2, 1);
3208                 break;
3209         case 5:                 // ctrl-E  scroll down one line
3210                 dot_scroll(1, 1);
3211                 break;
3212         case 6:                 // ctrl-F  scroll down full screen
3213         case KEYCODE_PAGEDOWN:  // Cursor Key Page Down
3214                 dot_scroll(rows - 2, 1);
3215                 break;
3216         case 7:                 // ctrl-G  show current status
3217                 last_status_cksum = 0;  // force status update
3218                 break;
3219         case 'h':                       // h- move left
3220         case KEYCODE_LEFT:      // cursor key Left
3221         case 8:         // ctrl-H- move left    (This may be ERASE char)
3222         case 0x7f:      // DEL- move left   (This may be ERASE char)
3223                 do {
3224                         dot_left();
3225                 } while (--cmdcnt > 0);
3226                 break;
3227         case 10:                        // Newline ^J
3228         case 'j':                       // j- goto next line, same col
3229         case KEYCODE_DOWN:      // cursor key Down
3230                 do {
3231                         dot_next();             // go to next B-o-l
3232                         // try stay in same col
3233                         dot = move_to_col(dot, ccol + offset);
3234                 } while (--cmdcnt > 0);
3235                 break;
3236         case 12:                        // ctrl-L  force redraw whole screen
3237         case 18:                        // ctrl-R  force redraw
3238                 redraw(TRUE);   // this will redraw the entire display
3239                 break;
3240         case 13:                        // Carriage Return ^M
3241         case '+':                       // +- goto next line
3242                 do {
3243                         dot_next();
3244                         dot_skip_over_ws();
3245                 } while (--cmdcnt > 0);
3246                 break;
3247         case 21:                        // ctrl-U  scroll up   half screen
3248                 dot_scroll((rows - 2) / 2, -1);
3249                 break;
3250         case 25:                        // ctrl-Y  scroll up one line
3251                 dot_scroll(1, -1);
3252                 break;
3253         case 27:                        // esc
3254                 if (cmd_mode == 0)
3255                         indicate_error();
3256                 cmd_mode = 0;   // stop insrting
3257                 undo_queue_commit();
3258                 end_cmd_q();
3259                 last_status_cksum = 0;  // force status update
3260                 break;
3261         case ' ':                       // move right
3262         case 'l':                       // move right
3263         case KEYCODE_RIGHT:     // Cursor Key Right
3264                 do {
3265                         dot_right();
3266                 } while (--cmdcnt > 0);
3267                 break;
3268 #if ENABLE_FEATURE_VI_YANKMARK
3269         case '"':                       // "- name a register to use for Delete/Yank
3270                 c1 = (get_one_char() | 0x20) - 'a'; // | 0x20 is tolower()
3271                 if ((unsigned)c1 <= 25) { // a-z?
3272                         YDreg = c1;
3273                 } else {
3274                         indicate_error();
3275                 }
3276                 break;
3277         case '\'':                      // '- goto a specific mark
3278                 c1 = (get_one_char() | 0x20);
3279                 if ((unsigned)(c1 - 'a') <= 25) { // a-z?
3280                         c1 = (c1 - 'a');
3281                         // get the b-o-l
3282                         q = mark[c1];
3283                         if (text <= q && q < end) {
3284                                 dot = q;
3285                                 dot_begin();    // go to B-o-l
3286                                 dot_skip_over_ws();
3287                         }
3288                 } else if (c1 == '\'') {        // goto previous context
3289                         dot = swap_context(dot);        // swap current and previous context
3290                         dot_begin();    // go to B-o-l
3291                         dot_skip_over_ws();
3292                 } else {
3293                         indicate_error();
3294                 }
3295                 break;
3296         case 'm':                       // m- Mark a line
3297                 // this is really stupid.  If there are any inserts or deletes
3298                 // between text[0] and dot then this mark will not point to the
3299                 // correct location! It could be off by many lines!
3300                 // Well..., at least its quick and dirty.
3301                 c1 = (get_one_char() | 0x20) - 'a';
3302                 if ((unsigned)c1 <= 25) { // a-z?
3303                         // remember the line
3304                         mark[c1] = dot;
3305                 } else {
3306                         indicate_error();
3307                 }
3308                 break;
3309         case 'P':                       // P- Put register before
3310         case 'p':                       // p- put register after
3311                 p = reg[YDreg];
3312                 if (p == NULL) {
3313                         status_line_bold("Nothing in register %c", what_reg());
3314                         break;
3315                 }
3316                 // are we putting whole lines or strings
3317                 if (strchr(p, '\n') != NULL) {
3318                         if (c == 'P') {
3319                                 dot_begin();    // putting lines- Put above
3320                         }
3321                         if (c == 'p') {
3322                                 // are we putting after very last line?
3323                                 if (end_line(dot) == (end - 1)) {
3324                                         dot = end;      // force dot to end of text[]
3325                                 } else {
3326                                         dot_next();     // next line, then put before
3327                                 }
3328                         }
3329                 } else {
3330                         if (c == 'p')
3331                                 dot_right();    // move to right, can move to NL
3332                 }
3333                 string_insert(dot, p, ALLOW_UNDO);      // insert the string
3334                 end_cmd_q();    // stop adding to q
3335                 break;
3336         case 'U':                       // U- Undo; replace current line with original version
3337                 if (reg[Ureg] != NULL) {
3338                         p = begin_line(dot);
3339                         q = end_line(dot);
3340                         p = text_hole_delete(p, q, ALLOW_UNDO); // delete cur line
3341                         p += string_insert(p, reg[Ureg], ALLOW_UNDO_CHAIN);     // insert orig line
3342                         dot = p;
3343                         dot_skip_over_ws();
3344                 }
3345                 break;
3346 #endif /* FEATURE_VI_YANKMARK */
3347 #if ENABLE_FEATURE_VI_UNDO
3348         case 'u':       // u- undo last operation
3349                 undo_pop();
3350                 break;
3351 #endif
3352         case '$':                       // $- goto end of line
3353         case KEYCODE_END:               // Cursor Key End
3354                 for (;;) {
3355                         dot = end_line(dot);
3356                         if (--cmdcnt <= 0)
3357                                 break;
3358                         dot_next();
3359                 }
3360                 break;
3361         case '%':                       // %- find matching char of pair () [] {}
3362                 for (q = dot; q < end && *q != '\n'; q++) {
3363                         if (strchr("()[]{}", *q) != NULL) {
3364                                 // we found half of a pair
3365                                 p = find_pair(q, *q);
3366                                 if (p == NULL) {
3367                                         indicate_error();
3368                                 } else {
3369                                         dot = p;
3370                                 }
3371                                 break;
3372                         }
3373                 }
3374                 if (*q == '\n')
3375                         indicate_error();
3376                 break;
3377         case 'f':                       // f- forward to a user specified char
3378                 last_forward_char = get_one_char();     // get the search char
3379                 //
3380                 // dont separate these two commands. 'f' depends on ';'
3381                 //
3382                 //**** fall through to ... ';'
3383         case ';':                       // ;- look at rest of line for last forward char
3384                 do {
3385                         if (last_forward_char == 0)
3386                                 break;
3387                         q = dot + 1;
3388                         while (q < end - 1 && *q != '\n' && *q != last_forward_char) {
3389                                 q++;
3390                         }
3391                         if (*q == last_forward_char)
3392                                 dot = q;
3393                 } while (--cmdcnt > 0);
3394                 break;
3395         case ',':           // repeat latest 'f' in opposite direction
3396                 if (last_forward_char == 0)
3397                         break;
3398                 do {
3399                         q = dot - 1;
3400                         while (q >= text && *q != '\n' && *q != last_forward_char) {
3401                                 q--;
3402                         }
3403                         if (q >= text && *q == last_forward_char)
3404                                 dot = q;
3405                 } while (--cmdcnt > 0);
3406                 break;
3407
3408         case '-':                       // -- goto prev line
3409                 do {
3410                         dot_prev();
3411                         dot_skip_over_ws();
3412                 } while (--cmdcnt > 0);
3413                 break;
3414 #if ENABLE_FEATURE_VI_DOT_CMD
3415         case '.':                       // .- repeat the last modifying command
3416                 // Stuff the last_modifying_cmd back into stdin
3417                 // and let it be re-executed.
3418                 if (lmc_len > 0) {
3419                         last_modifying_cmd[lmc_len] = 0;
3420                         ioq = ioq_start = xstrdup(last_modifying_cmd);
3421                 }
3422                 break;
3423 #endif
3424 #if ENABLE_FEATURE_VI_SEARCH
3425         case '?':                       // /- search for a pattern
3426         case '/':                       // /- search for a pattern
3427                 buf[0] = c;
3428                 buf[1] = '\0';
3429                 q = get_input_line(buf);        // get input line- use "status line"
3430                 if (q[0] && !q[1]) {
3431                         if (last_search_pattern[0])
3432                                 last_search_pattern[0] = c;
3433                         goto dc3; // if no pat re-use old pat
3434                 }
3435                 if (q[0]) {       // strlen(q) > 1: new pat- save it and find
3436                         // there is a new pat
3437                         free(last_search_pattern);
3438                         last_search_pattern = xstrdup(q);
3439                         goto dc3;       // now find the pattern
3440                 }
3441                 // user changed mind and erased the "/"-  do nothing
3442                 break;
3443         case 'N':                       // N- backward search for last pattern
3444                 dir = BACK;             // assume BACKWARD search
3445                 p = dot - 1;
3446                 if (last_search_pattern[0] == '?') {
3447                         dir = FORWARD;
3448                         p = dot + 1;
3449                 }
3450                 goto dc4;               // now search for pattern
3451                 break;
3452         case 'n':                       // n- repeat search for last pattern
3453                 // search rest of text[] starting at next char
3454                 // if search fails return orignal "p" not the "p+1" address
3455                 do {
3456                         const char *msg;
3457  dc3:
3458                         dir = FORWARD;  // assume FORWARD search
3459                         p = dot + 1;
3460                         if (last_search_pattern[0] == '?') {
3461                                 dir = BACK;
3462                                 p = dot - 1;
3463                         }
3464  dc4:
3465                         q = char_search(p, last_search_pattern + 1, (dir << 1) | FULL);
3466                         if (q != NULL) {
3467                                 dot = q;        // good search, update "dot"
3468                                 msg = NULL;
3469                                 goto dc2;
3470                         }
3471                         // no pattern found between "dot" and "end"- continue at top
3472                         p = text;
3473                         if (dir == BACK) {
3474                                 p = end - 1;
3475                         }
3476                         q = char_search(p, last_search_pattern + 1, (dir << 1) | FULL);
3477                         if (q != NULL) {        // found something
3478                                 dot = q;        // found new pattern- goto it
3479                                 msg = "search hit BOTTOM, continuing at TOP";
3480                                 if (dir == BACK) {
3481                                         msg = "search hit TOP, continuing at BOTTOM";
3482                                 }
3483                         } else {
3484                                 msg = "Pattern not found";
3485                         }
3486  dc2:
3487                         if (msg)
3488                                 status_line_bold("%s", msg);
3489                 } while (--cmdcnt > 0);
3490                 break;
3491         case '{':                       // {- move backward paragraph
3492                 q = char_search(dot, "\n\n", (BACK << 1) | FULL);
3493                 if (q != NULL) {        // found blank line
3494                         dot = next_line(q);     // move to next blank line
3495                 }
3496                 break;
3497         case '}':                       // }- move forward paragraph
3498                 q = char_search(dot, "\n\n", (FORWARD << 1) | FULL);
3499                 if (q != NULL) {        // found blank line
3500                         dot = next_line(q);     // move to next blank line
3501                 }
3502                 break;
3503 #endif /* FEATURE_VI_SEARCH */
3504         case '0':                       // 0- goto beginning of line
3505         case '1':                       // 1-
3506         case '2':                       // 2-
3507         case '3':                       // 3-
3508         case '4':                       // 4-
3509         case '5':                       // 5-
3510         case '6':                       // 6-
3511         case '7':                       // 7-
3512         case '8':                       // 8-
3513         case '9':                       // 9-
3514                 if (c == '0' && cmdcnt < 1) {
3515                         dot_begin();    // this was a standalone zero
3516                 } else {
3517                         cmdcnt = cmdcnt * 10 + (c - '0');       // this 0 is part of a number
3518                 }
3519                 break;
3520         case ':':                       // :- the colon mode commands
3521                 p = get_input_line(":");        // get input line- use "status line"
3522                 colon(p);               // execute the command
3523                 break;
3524         case '<':                       // <- Left  shift something
3525         case '>':                       // >- Right shift something
3526                 cnt = count_lines(text, dot);   // remember what line we are on
3527                 c1 = get_one_char();    // get the type of thing to delete
3528                 find_range(&p, &q, c1);
3529                 yank_delete(p, q, 1, YANKONLY, NO_UNDO);        // save copy before change
3530                 p = begin_line(p);
3531                 q = end_line(q);
3532                 i = count_lines(p, q);  // # of lines we are shifting
3533                 for ( ; i > 0; i--, p = next_line(p)) {
3534                         if (c == '<') {
3535                                 // shift left- remove tab or 8 spaces
3536                                 if (*p == '\t') {
3537                                         // shrink buffer 1 char
3538                                         text_hole_delete(p, p, NO_UNDO);
3539                                 } else if (*p == ' ') {
3540                                         // we should be calculating columns, not just SPACE
3541                                         for (j = 0; *p == ' ' && j < tabstop; j++) {
3542                                                 text_hole_delete(p, p, NO_UNDO);
3543                                         }
3544                                 }
3545                         } else if (c == '>') {
3546                                 // shift right -- add tab or 8 spaces
3547                                 char_insert(p, '\t', ALLOW_UNDO);
3548                         }
3549                 }
3550                 dot = find_line(cnt);   // what line were we on
3551                 dot_skip_over_ws();
3552                 end_cmd_q();    // stop adding to q
3553                 break;
3554         case 'A':                       // A- append at e-o-l
3555                 dot_end();              // go to e-o-l
3556                 //**** fall through to ... 'a'
3557         case 'a':                       // a- append after current char
3558                 if (*dot != '\n')
3559                         dot++;
3560                 goto dc_i;
3561                 break;
3562         case 'B':                       // B- back a blank-delimited Word
3563         case 'E':                       // E- end of a blank-delimited word
3564         case 'W':                       // W- forward a blank-delimited word
3565                 dir = FORWARD;
3566                 if (c == 'B')
3567                         dir = BACK;
3568                 do {
3569                         if (c == 'W' || isspace(dot[dir])) {
3570                                 dot = skip_thing(dot, 1, dir, S_TO_WS);
3571                                 dot = skip_thing(dot, 2, dir, S_OVER_WS);
3572                         }
3573                         if (c != 'W')
3574                                 dot = skip_thing(dot, 1, dir, S_BEFORE_WS);
3575                 } while (--cmdcnt > 0);
3576                 break;
3577         case 'C':                       // C- Change to e-o-l
3578         case 'D':                       // D- delete to e-o-l
3579                 save_dot = dot;
3580                 dot = dollar_line(dot); // move to before NL
3581                 // copy text into a register and delete
3582                 dot = yank_delete(save_dot, dot, 0, YANKDEL, ALLOW_UNDO);       // delete to e-o-l
3583                 if (c == 'C')
3584                         goto dc_i;      // start inserting
3585 #if ENABLE_FEATURE_VI_DOT_CMD
3586                 if (c == 'D')
3587                         end_cmd_q();    // stop adding to q
3588 #endif
3589                 break;
3590         case 'g': // 'gg' goto a line number (vim) (default: very first line)
3591                 c1 = get_one_char();
3592                 if (c1 != 'g') {
3593                         buf[0] = 'g';
3594                         // c1 < 0 if the key was special. Try "g<up-arrow>"
3595                         // TODO: if Unicode?
3596                         buf[1] = (c1 >= 0 ? c1 : '*');
3597                         buf[2] = '\0';
3598                         not_implemented(buf);
3599                         break;
3600                 }
3601                 if (cmdcnt == 0)
3602                         cmdcnt = 1;
3603                 // fall through
3604         case 'G':               // G- goto to a line number (default= E-O-F)
3605                 dot = end - 1;                          // assume E-O-F
3606                 if (cmdcnt > 0) {
3607                         dot = find_line(cmdcnt);        // what line is #cmdcnt
3608                 }
3609                 dot_skip_over_ws();
3610                 break;
3611         case 'H':                       // H- goto top line on screen
3612                 dot = screenbegin;
3613                 if (cmdcnt > (rows - 1)) {
3614                         cmdcnt = (rows - 1);
3615                 }
3616                 if (--cmdcnt > 0) {
3617                         do_cmd('+');
3618                 }
3619                 dot_skip_over_ws();
3620                 break;
3621         case 'I':                       // I- insert before first non-blank
3622                 dot_begin();    // 0
3623                 dot_skip_over_ws();
3624                 //**** fall through to ... 'i'
3625         case 'i':                       // i- insert before current char
3626         case KEYCODE_INSERT:    // Cursor Key Insert
3627  dc_i:
3628                 cmd_mode = 1;   // start inserting
3629                 undo_queue_commit();    // commit queue when cmd_mode changes
3630                 break;
3631         case 'J':                       // J- join current and next lines together
3632                 do {
3633                         dot_end();              // move to NL
3634                         if (dot < end - 1) {    // make sure not last char in text[]
3635 #if ENABLE_FEATURE_VI_UNDO
3636                                 undo_push(dot, 1, UNDO_DEL);
3637                                 *dot++ = ' ';   // replace NL with space
3638                                 undo_push((dot - 1), 1, UNDO_INS_CHAIN);
3639 #else
3640                                 *dot++ = ' ';
3641                                 modified_count++;
3642 #endif
3643                                 while (isblank(*dot)) { // delete leading WS
3644                                         text_hole_delete(dot, dot, ALLOW_UNDO_CHAIN);
3645                                 }
3646                         }
3647                 } while (--cmdcnt > 0);
3648                 end_cmd_q();    // stop adding to q
3649                 break;
3650         case 'L':                       // L- goto bottom line on screen
3651                 dot = end_screen();
3652                 if (cmdcnt > (rows - 1)) {
3653                         cmdcnt = (rows - 1);
3654                 }
3655                 if (--cmdcnt > 0) {
3656                         do_cmd('-');
3657                 }
3658                 dot_begin();
3659                 dot_skip_over_ws();
3660                 break;
3661         case 'M':                       // M- goto middle line on screen
3662                 dot = screenbegin;
3663                 for (cnt = 0; cnt < (rows-1) / 2; cnt++)
3664                         dot = next_line(dot);
3665                 break;
3666         case 'O':                       // O- open a empty line above
3667                 //    0i\n ESC -i
3668                 p = begin_line(dot);
3669                 if (p[-1] == '\n') {
3670                         dot_prev();
3671         case 'o':                       // o- open a empty line below; Yes, I know it is in the middle of the "if (..."
3672                         dot_end();
3673                         dot = char_insert(dot, '\n', ALLOW_UNDO);
3674                 } else {
3675                         dot_begin();    // 0
3676                         dot = char_insert(dot, '\n', ALLOW_UNDO);       // i\n ESC
3677                         dot_prev();     // -
3678                 }
3679                 goto dc_i;
3680                 break;
3681         case 'R':                       // R- continuous Replace char
3682  dc5:
3683                 cmd_mode = 2;
3684                 undo_queue_commit();
3685                 break;
3686         case KEYCODE_DELETE:
3687                 if (dot < end - 1)
3688                         dot = yank_delete(dot, dot, 1, YANKDEL, ALLOW_UNDO);
3689                 break;
3690         case 'X':                       // X- delete char before dot
3691         case 'x':                       // x- delete the current char
3692         case 's':                       // s- substitute the current char
3693                 dir = 0;
3694                 if (c == 'X')
3695                         dir = -1;
3696                 do {
3697                         if (dot[dir] != '\n') {
3698                                 if (c == 'X')
3699                                         dot--;  // delete prev char
3700                                 dot = yank_delete(dot, dot, 0, YANKDEL, ALLOW_UNDO);    // delete char
3701                         }
3702                 } while (--cmdcnt > 0);
3703                 end_cmd_q();    // stop adding to q
3704                 if (c == 's')
3705                         goto dc_i;      // start inserting
3706                 break;
3707         case 'Z':                       // Z- if modified, {write}; exit
3708                 // ZZ means to save file (if necessary), then exit
3709                 c1 = get_one_char();
3710                 if (c1 != 'Z') {
3711                         indicate_error();
3712                         break;
3713                 }
3714                 if (modified_count) {
3715                         if (ENABLE_FEATURE_VI_READONLY && readonly_mode) {
3716                                 status_line_bold("'%s' is read only", current_filename);
3717                                 break;
3718                         }
3719                         cnt = file_write(current_filename, text, end - 1);
3720                         if (cnt < 0) {
3721                                 if (cnt == -1)
3722                                         status_line_bold("Write error: "STRERROR_FMT STRERROR_ERRNO);
3723                         } else if (cnt == (end - 1 - text + 1)) {
3724                                 editing = 0;
3725                         }
3726                 } else {
3727                         editing = 0;
3728                 }
3729                 break;
3730         case '^':                       // ^- move to first non-blank on line
3731                 dot_begin();
3732                 dot_skip_over_ws();
3733                 break;
3734         case 'b':                       // b- back a word
3735         case 'e':                       // e- end of word
3736                 dir = FORWARD;
3737                 if (c == 'b')
3738                         dir = BACK;
3739                 do {
3740                         if ((dot + dir) < text || (dot + dir) > end - 1)
3741                                 break;
3742                         dot += dir;
3743                         if (isspace(*dot)) {
3744                                 dot = skip_thing(dot, (c == 'e') ? 2 : 1, dir, S_OVER_WS);
3745                         }
3746                         if (isalnum(*dot) || *dot == '_') {
3747                                 dot = skip_thing(dot, 1, dir, S_END_ALNUM);
3748                         } else if (ispunct(*dot)) {
3749                                 dot = skip_thing(dot, 1, dir, S_END_PUNCT);
3750                         }
3751                 } while (--cmdcnt > 0);
3752                 break;
3753         case 'c':                       // c- change something
3754         case 'd':                       // d- delete something
3755 #if ENABLE_FEATURE_VI_YANKMARK
3756         case 'y':                       // y- yank   something
3757         case 'Y':                       // Y- Yank a line
3758 #endif
3759         {
3760                 int yf, ml, whole = 0;
3761                 yf = YANKDEL;   // assume either "c" or "d"
3762 #if ENABLE_FEATURE_VI_YANKMARK
3763                 if (c == 'y' || c == 'Y')
3764                         yf = YANKONLY;
3765 #endif
3766                 c1 = 'y';
3767                 if (c != 'Y')
3768                         c1 = get_one_char();    // get the type of thing to delete
3769                 // determine range, and whether it spans lines
3770                 ml = find_range(&p, &q, c1);
3771                 place_cursor(0, 0);
3772                 if (c1 == 27) { // ESC- user changed mind and wants out
3773                         c = c1 = 27;    // Escape- do nothing
3774                 } else if (strchr("wW", c1)) {
3775                         if (c == 'c') {
3776                                 // don't include trailing WS as part of word
3777                                 while (isblank(*q)) {
3778                                         if (q <= text || q[-1] == '\n')
3779                                                 break;
3780                                         q--;
3781                                 }
3782                         }
3783                         dot = yank_delete(p, q, ml, yf, ALLOW_UNDO);    // delete word
3784                 } else if (strchr("^0bBeEft%$ lh\b\177", c1)) {
3785                         // partial line copy text into a register and delete
3786                         dot = yank_delete(p, q, ml, yf, ALLOW_UNDO);    // delete word
3787                 } else if (strchr("cdykjHL+-{}\r\n", c1)) {
3788                         // whole line copy text into a register and delete
3789                         dot = yank_delete(p, q, ml, yf, ALLOW_UNDO);    // delete lines
3790                         whole = 1;
3791                 } else {
3792                         // could not recognize object
3793                         c = c1 = 27;    // error-
3794                         ml = 0;
3795                         indicate_error();
3796                 }
3797                 if (ml && whole) {
3798                         if (c == 'c') {
3799                                 dot = char_insert(dot, '\n', ALLOW_UNDO_CHAIN);
3800                                 // on the last line of file don't move to prev line
3801                                 if (whole && dot != (end-1)) {
3802                                         dot_prev();
3803                                 }
3804                         } else if (c == 'd') {
3805                                 dot_begin();
3806                                 dot_skip_over_ws();
3807                         }
3808                 }
3809                 if (c1 != 27) {
3810                         // if CHANGING, not deleting, start inserting after the delete
3811                         if (c == 'c') {
3812                                 strcpy(buf, "Change");
3813                                 goto dc_i;      // start inserting
3814                         }
3815                         if (c == 'd') {
3816                                 strcpy(buf, "Delete");
3817                         }
3818 #if ENABLE_FEATURE_VI_YANKMARK
3819                         if (c == 'y' || c == 'Y') {
3820                                 strcpy(buf, "Yank");
3821                         }
3822                         p = reg[YDreg];
3823                         q = p + strlen(p);
3824                         for (cnt = 0; p <= q; p++) {
3825                                 if (*p == '\n')
3826                                         cnt++;
3827                         }
3828                         status_line("%s %u lines (%u chars) using [%c]",
3829                                 buf, cnt, (unsigned)strlen(reg[YDreg]), what_reg());
3830 #endif
3831                         end_cmd_q();    // stop adding to q
3832                 }
3833                 break;
3834         }
3835         case 'k':                       // k- goto prev line, same col
3836         case KEYCODE_UP:                // cursor key Up
3837                 do {
3838                         dot_prev();
3839                         dot = move_to_col(dot, ccol + offset);  // try stay in same col
3840                 } while (--cmdcnt > 0);
3841                 break;
3842         case 'r':                       // r- replace the current char with user input
3843                 c1 = get_one_char();    // get the replacement char
3844                 if (*dot != '\n') {
3845                         dot = text_hole_delete(dot, dot, ALLOW_UNDO);
3846                         dot = char_insert(dot, c1, ALLOW_UNDO_CHAIN);
3847                         dot_left();
3848                 }
3849                 end_cmd_q();    // stop adding to q
3850                 break;
3851         case 't':                       // t- move to char prior to next x
3852                 last_forward_char = get_one_char();
3853                 do_cmd(';');
3854                 if (*dot == last_forward_char)
3855                         dot_left();
3856                 last_forward_char = 0;
3857                 break;
3858         case 'w':                       // w- forward a word
3859                 do {
3860                         if (isalnum(*dot) || *dot == '_') {     // we are on ALNUM
3861                                 dot = skip_thing(dot, 1, FORWARD, S_END_ALNUM);
3862                         } else if (ispunct(*dot)) {     // we are on PUNCT
3863                                 dot = skip_thing(dot, 1, FORWARD, S_END_PUNCT);
3864                         }
3865                         if (dot < end - 1)
3866                                 dot++;          // move over word
3867                         if (isspace(*dot)) {
3868                                 dot = skip_thing(dot, 2, FORWARD, S_OVER_WS);
3869                         }
3870                 } while (--cmdcnt > 0);
3871                 break;
3872         case 'z':                       // z-
3873                 c1 = get_one_char();    // get the replacement char
3874                 cnt = 0;
3875                 if (c1 == '.')
3876                         cnt = (rows - 2) / 2;   // put dot at center
3877                 if (c1 == '-')
3878                         cnt = rows - 2; // put dot at bottom
3879                 screenbegin = begin_line(dot);  // start dot at top
3880                 dot_scroll(cnt, -1);
3881                 break;
3882         case '|':                       // |- move to column "cmdcnt"
3883                 dot = move_to_col(dot, cmdcnt - 1);     // try to move to column
3884                 break;
3885         case '~':                       // ~- flip the case of letters   a-z -> A-Z
3886                 do {
3887 #if ENABLE_FEATURE_VI_UNDO
3888                         if (islower(*dot)) {
3889                                 undo_push(dot, 1, UNDO_DEL);
3890                                 *dot = toupper(*dot);
3891                                 undo_push(dot, 1, UNDO_INS_CHAIN);
3892                         } else if (isupper(*dot)) {
3893                                 undo_push(dot, 1, UNDO_DEL);
3894                                 *dot = tolower(*dot);
3895                                 undo_push(dot, 1, UNDO_INS_CHAIN);
3896                         }
3897 #else
3898                         if (islower(*dot)) {
3899                                 *dot = toupper(*dot);
3900                                 modified_count++;
3901                         } else if (isupper(*dot)) {
3902                                 *dot = tolower(*dot);
3903                                 modified_count++;
3904                         }
3905 #endif
3906                         dot_right();
3907                 } while (--cmdcnt > 0);
3908                 end_cmd_q();    // stop adding to q
3909                 break;
3910                 //----- The Cursor and Function Keys -----------------------------
3911         case KEYCODE_HOME:      // Cursor Key Home
3912                 dot_begin();
3913                 break;
3914                 // The Fn keys could point to do_macro which could translate them
3915 #if 0
3916         case KEYCODE_FUN1:      // Function Key F1
3917         case KEYCODE_FUN2:      // Function Key F2
3918         case KEYCODE_FUN3:      // Function Key F3
3919         case KEYCODE_FUN4:      // Function Key F4
3920         case KEYCODE_FUN5:      // Function Key F5
3921         case KEYCODE_FUN6:      // Function Key F6
3922         case KEYCODE_FUN7:      // Function Key F7
3923         case KEYCODE_FUN8:      // Function Key F8
3924         case KEYCODE_FUN9:      // Function Key F9
3925         case KEYCODE_FUN10:     // Function Key F10
3926         case KEYCODE_FUN11:     // Function Key F11
3927         case KEYCODE_FUN12:     // Function Key F12
3928                 break;
3929 #endif
3930         }
3931
3932  dc1:
3933         // if text[] just became empty, add back an empty line
3934         if (end == text) {
3935                 char_insert(text, '\n', NO_UNDO);       // start empty buf with dummy line
3936                 dot = text;
3937         }
3938         // it is OK for dot to exactly equal to end, otherwise check dot validity
3939         if (dot != end) {
3940                 dot = bound_dot(dot);   // make sure "dot" is valid
3941         }
3942 #if ENABLE_FEATURE_VI_YANKMARK
3943         check_context(c);       // update the current context
3944 #endif
3945
3946         if (!isdigit(c))
3947                 cmdcnt = 0;             // cmd was not a number, reset cmdcnt
3948         cnt = dot - begin_line(dot);
3949         // Try to stay off of the Newline
3950         if (*dot == '\n' && cnt > 0 && cmd_mode == 0)
3951                 dot--;
3952 }
3953
3954 /* NB!  the CRASHME code is unmaintained, and doesn't currently build */
3955 #if ENABLE_FEATURE_VI_CRASHME
3956 static int totalcmds = 0;
3957 static int Mp = 85;             // Movement command Probability
3958 static int Np = 90;             // Non-movement command Probability
3959 static int Dp = 96;             // Delete command Probability
3960 static int Ip = 97;             // Insert command Probability
3961 static int Yp = 98;             // Yank command Probability
3962 static int Pp = 99;             // Put command Probability
3963 static int M = 0, N = 0, I = 0, D = 0, Y = 0, P = 0, U = 0;
3964 static const char chars[20] = "\t012345 abcdABCD-=.$";
3965 static const char *const words[20] = {
3966         "this", "is", "a", "test",
3967         "broadcast", "the", "emergency", "of",
3968         "system", "quick", "brown", "fox",
3969         "jumped", "over", "lazy", "dogs",
3970         "back", "January", "Febuary", "March"
3971 };
3972 static const char *const lines[20] = {
3973         "You should have received a copy of the GNU General Public License\n",
3974         "char c, cm, *cmd, *cmd1;\n",
3975         "generate a command by percentages\n",
3976         "Numbers may be typed as a prefix to some commands.\n",
3977         "Quit, discarding changes!\n",
3978         "Forced write, if permission originally not valid.\n",
3979         "In general, any ex or ed command (such as substitute or delete).\n",
3980         "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
3981         "Please get w/ me and I will go over it with you.\n",
3982         "The following is a list of scheduled, committed changes.\n",
3983         "1.   Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
3984         "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
3985         "Any question about transactions please contact Sterling Huxley.\n",
3986         "I will try to get back to you by Friday, December 31.\n",
3987         "This Change will be implemented on Friday.\n",
3988         "Let me know if you have problems accessing this;\n",
3989         "Sterling Huxley recently added you to the access list.\n",
3990         "Would you like to go to lunch?\n",
3991         "The last command will be automatically run.\n",
3992         "This is too much english for a computer geek.\n",
3993 };
3994 static char *multilines[20] = {
3995         "You should have received a copy of the GNU General Public License\n",
3996         "char c, cm, *cmd, *cmd1;\n",
3997         "generate a command by percentages\n",
3998         "Numbers may be typed as a prefix to some commands.\n",
3999         "Quit, discarding changes!\n",
4000         "Forced write, if permission originally not valid.\n",
4001         "In general, any ex or ed command (such as substitute or delete).\n",
4002         "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
4003         "Please get w/ me and I will go over it with you.\n",
4004         "The following is a list of scheduled, committed changes.\n",
4005         "1.   Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
4006         "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
4007         "Any question about transactions please contact Sterling Huxley.\n",
4008         "I will try to get back to you by Friday, December 31.\n",
4009         "This Change will be implemented on Friday.\n",
4010         "Let me know if you have problems accessing this;\n",
4011         "Sterling Huxley recently added you to the access list.\n",
4012         "Would you like to go to lunch?\n",
4013         "The last command will be automatically run.\n",
4014         "This is too much english for a computer geek.\n",
4015 };
4016
4017 // create a random command to execute
4018 static void crash_dummy()
4019 {
4020         static int sleeptime;   // how long to pause between commands
4021         char c, cm, *cmd, *cmd1;
4022         int i, cnt, thing, rbi, startrbi, percent;
4023
4024         // "dot" movement commands
4025         cmd1 = " \n\r\002\004\005\006\025\0310^$-+wWeEbBhjklHL";
4026
4027         // is there already a command running?
4028         if (readbuffer[0] > 0)
4029                 goto cd1;
4030  cd0:
4031         readbuffer[0] = 'X';
4032         startrbi = rbi = 1;
4033         sleeptime = 0;          // how long to pause between commands
4034         memset(readbuffer, '\0', sizeof(readbuffer));
4035         // generate a command by percentages
4036         percent = (int) lrand48() % 100;        // get a number from 0-99
4037         if (percent < Mp) {     //  Movement commands
4038                 // available commands
4039                 cmd = cmd1;
4040                 M++;
4041         } else if (percent < Np) {      //  non-movement commands
4042                 cmd = "mz<>\'\"";       // available commands
4043                 N++;
4044         } else if (percent < Dp) {      //  Delete commands
4045                 cmd = "dx";             // available commands
4046                 D++;
4047         } else if (percent < Ip) {      //  Inset commands
4048                 cmd = "iIaAsrJ";        // available commands
4049                 I++;
4050         } else if (percent < Yp) {      //  Yank commands
4051                 cmd = "yY";             // available commands
4052                 Y++;
4053         } else if (percent < Pp) {      //  Put commands
4054                 cmd = "pP";             // available commands
4055                 P++;
4056         } else {
4057                 // We do not know how to handle this command, try again
4058                 U++;
4059                 goto cd0;
4060         }
4061         // randomly pick one of the available cmds from "cmd[]"
4062         i = (int) lrand48() % strlen(cmd);
4063         cm = cmd[i];
4064         if (strchr(":\024", cm))
4065                 goto cd0;               // dont allow colon or ctrl-T commands
4066         readbuffer[rbi++] = cm; // put cmd into input buffer
4067
4068         // now we have the command-
4069         // there are 1, 2, and multi char commands
4070         // find out which and generate the rest of command as necessary
4071         if (strchr("dmryz<>\'\"", cm)) {        // 2-char commands
4072                 cmd1 = " \n\r0$^-+wWeEbBhjklHL";
4073                 if (cm == 'm' || cm == '\'' || cm == '\"') {    // pick a reg[]
4074                         cmd1 = "abcdefghijklmnopqrstuvwxyz";
4075                 }
4076                 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
4077                 c = cmd1[thing];
4078                 readbuffer[rbi++] = c;  // add movement to input buffer
4079         }
4080         if (strchr("iIaAsc", cm)) {     // multi-char commands
4081                 if (cm == 'c') {
4082                         // change some thing
4083                         thing = (int) lrand48() % strlen(cmd1); // pick a movement command
4084                         c = cmd1[thing];
4085                         readbuffer[rbi++] = c;  // add movement to input buffer
4086                 }
4087                 thing = (int) lrand48() % 4;    // what thing to insert
4088                 cnt = (int) lrand48() % 10;     // how many to insert
4089                 for (i = 0; i < cnt; i++) {
4090                         if (thing == 0) {       // insert chars
4091                                 readbuffer[rbi++] = chars[((int) lrand48() % strlen(chars))];
4092                         } else if (thing == 1) {        // insert words
4093                                 strcat(readbuffer, words[(int) lrand48() % 20]);
4094                                 strcat(readbuffer, " ");
4095                                 sleeptime = 0;  // how fast to type
4096                         } else if (thing == 2) {        // insert lines
4097                                 strcat(readbuffer, lines[(int) lrand48() % 20]);
4098                                 sleeptime = 0;  // how fast to type
4099                         } else {        // insert multi-lines
4100                                 strcat(readbuffer, multilines[(int) lrand48() % 20]);
4101                                 sleeptime = 0;  // how fast to type
4102                         }
4103                 }
4104                 strcat(readbuffer, ESC);
4105         }
4106         readbuffer[0] = strlen(readbuffer + 1);
4107  cd1:
4108         totalcmds++;
4109         if (sleeptime > 0)
4110                 mysleep(sleeptime);      // sleep 1/100 sec
4111 }
4112
4113 // test to see if there are any errors
4114 static void crash_test()
4115 {
4116         static time_t oldtim;
4117
4118         time_t tim;
4119         char d[2], msg[80];
4120
4121         msg[0] = '\0';
4122         if (end < text) {
4123                 strcat(msg, "end<text ");
4124         }
4125         if (end > textend) {
4126                 strcat(msg, "end>textend ");
4127         }
4128         if (dot < text) {
4129                 strcat(msg, "dot<text ");
4130         }
4131         if (dot > end) {
4132                 strcat(msg, "dot>end ");
4133         }
4134         if (screenbegin < text) {
4135                 strcat(msg, "screenbegin<text ");
4136         }
4137         if (screenbegin > end - 1) {
4138                 strcat(msg, "screenbegin>end-1 ");
4139         }
4140
4141         if (msg[0]) {
4142                 printf("\n\n%d: \'%c\' %s\n\n\n%s[Hit return to continue]%s",
4143                         totalcmds, last_input_char, msg, ESC_BOLD_TEXT, ESC_NORM_TEXT);
4144                 fflush_all();
4145                 while (safe_read(STDIN_FILENO, d, 1) > 0) {
4146                         if (d[0] == '\n' || d[0] == '\r')
4147                                 break;
4148                 }
4149         }
4150         tim = time(NULL);
4151         if (tim >= (oldtim + 3)) {
4152                 sprintf(status_buffer,
4153                                 "Tot=%d: M=%d N=%d I=%d D=%d Y=%d P=%d U=%d size=%d",
4154                                 totalcmds, M, N, I, D, Y, P, U, end - text + 1);
4155                 oldtim = tim;
4156         }
4157 }
4158 #endif
4159
4160 static void edit_file(char *fn)
4161 {
4162 #if ENABLE_FEATURE_VI_YANKMARK
4163 #define cur_line edit_file__cur_line
4164 #endif
4165         int c;
4166 #if ENABLE_FEATURE_VI_USE_SIGNALS
4167         int sig;
4168 #endif
4169
4170         editing = 1;    // 0 = exit, 1 = one file, 2 = multiple files
4171         rawmode();
4172         rows = 24;
4173         columns = 80;
4174         IF_FEATURE_VI_ASK_TERMINAL(G.get_rowcol_error =) query_screen_dimensions();
4175 #if ENABLE_FEATURE_VI_ASK_TERMINAL
4176         if (G.get_rowcol_error /* TODO? && no input on stdin */) {
4177                 uint64_t k;
4178                 write1(ESC"[999;999H" ESC"[6n");
4179                 fflush_all();
4180                 k = read_key(STDIN_FILENO, readbuffer, /*timeout_ms:*/ 100);
4181                 if ((int32_t)k == KEYCODE_CURSOR_POS) {
4182                         uint32_t rc = (k >> 32);
4183                         columns = (rc & 0x7fff);
4184                         if (columns > MAX_SCR_COLS)
4185                                 columns = MAX_SCR_COLS;
4186                         rows = ((rc >> 16) & 0x7fff);
4187                         if (rows > MAX_SCR_ROWS)
4188                                 rows = MAX_SCR_ROWS;
4189                 }
4190         }
4191 #endif
4192         new_screen(rows, columns);      // get memory for virtual screen
4193         init_text_buffer(fn);
4194
4195 #if ENABLE_FEATURE_VI_YANKMARK
4196         YDreg = 26;                     // default Yank/Delete reg
4197 //      Ureg = 27; - const              // hold orig line for "U" cmd
4198         mark[26] = mark[27] = text;     // init "previous context"
4199 #endif
4200
4201         last_forward_char = last_input_char = '\0';
4202         crow = 0;
4203         ccol = 0;
4204
4205 #if ENABLE_FEATURE_VI_USE_SIGNALS
4206         signal(SIGWINCH, winch_handler);
4207         signal(SIGTSTP, tstp_handler);
4208         sig = sigsetjmp(restart, 1);
4209         if (sig != 0) {
4210                 screenbegin = dot = text;
4211         }
4212         // int_handler() can jump to "restart",
4213         // must install handler *after* initializing "restart"
4214         signal(SIGINT, int_handler);
4215 #endif
4216
4217         cmd_mode = 0;           // 0=command  1=insert  2='R'eplace
4218         cmdcnt = 0;
4219         tabstop = 8;
4220         offset = 0;                     // no horizontal offset
4221         c = '\0';
4222 #if ENABLE_FEATURE_VI_DOT_CMD
4223         free(ioq_start);
4224         ioq = ioq_start = NULL;
4225         lmc_len = 0;
4226         adding2q = 0;
4227 #endif
4228
4229 #if ENABLE_FEATURE_VI_COLON
4230         {
4231                 char *p, *q;
4232                 int n = 0;
4233
4234                 while ((p = initial_cmds[n]) != NULL) {
4235                         do {
4236                                 q = p;
4237                                 p = strchr(q, '\n');
4238                                 if (p)
4239                                         while (*p == '\n')
4240                                                 *p++ = '\0';
4241                                 if (*q)
4242                                         colon(q);
4243                         } while (p);
4244                         free(initial_cmds[n]);
4245                         initial_cmds[n] = NULL;
4246                         n++;
4247                 }
4248         }
4249 #endif
4250         redraw(FALSE);                  // dont force every col re-draw
4251         //------This is the main Vi cmd handling loop -----------------------
4252         while (editing > 0) {
4253 #if ENABLE_FEATURE_VI_CRASHME
4254                 if (crashme > 0) {
4255                         if ((end - text) > 1) {
4256                                 crash_dummy();  // generate a random command
4257                         } else {
4258                                 crashme = 0;
4259                                 string_insert(text, "\n\n#####  Ran out of text to work on.  #####\n\n", NO_UNDO); // insert the string
4260                                 dot = text;
4261                                 refresh(FALSE);
4262                         }
4263                 }
4264 #endif
4265                 last_input_char = c = get_one_char();   // get a cmd from user
4266 #if ENABLE_FEATURE_VI_YANKMARK
4267                 // save a copy of the current line- for the 'U" command
4268                 if (begin_line(dot) != cur_line) {
4269                         cur_line = begin_line(dot);
4270                         text_yank(begin_line(dot), end_line(dot), Ureg);
4271                 }
4272 #endif
4273 #if ENABLE_FEATURE_VI_DOT_CMD
4274                 // These are commands that change text[].
4275                 // Remember the input for the "." command
4276                 if (!adding2q && ioq_start == NULL
4277                  && cmd_mode == 0 // command mode
4278                  && c > '\0' // exclude NUL and non-ASCII chars
4279                  && c < 0x7f // (Unicode and such)
4280                  && strchr(modifying_cmds, c)
4281                 ) {
4282                         start_new_cmd_q(c);
4283                 }
4284 #endif
4285                 do_cmd(c);              // execute the user command
4286
4287                 // poll to see if there is input already waiting. if we are
4288                 // not able to display output fast enough to keep up, skip
4289                 // the display update until we catch up with input.
4290                 if (!readbuffer[0] && mysleep(0) == 0) {
4291                         // no input pending - so update output
4292                         refresh(FALSE);
4293                         show_status_line();
4294                 }
4295 #if ENABLE_FEATURE_VI_CRASHME
4296                 if (crashme > 0)
4297                         crash_test();   // test editor variables
4298 #endif
4299         }
4300         //-------------------------------------------------------------------
4301
4302         go_bottom_and_clear_to_eol();
4303         cookmode();
4304 #undef cur_line
4305 }
4306
4307 int vi_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
4308 int vi_main(int argc, char **argv)
4309 {
4310         int c;
4311
4312         INIT_G();
4313
4314 #if ENABLE_FEATURE_VI_UNDO
4315         /* undo_stack_tail = NULL; - already is */
4316 # if ENABLE_FEATURE_VI_UNDO_QUEUE
4317         undo_queue_state = UNDO_EMPTY;
4318         /* undo_q = 0; - already is  */
4319 # endif
4320 #endif
4321
4322 #if ENABLE_FEATURE_VI_CRASHME
4323         srand((long) getpid());
4324 #endif
4325 #ifdef NO_SUCH_APPLET_YET
4326         // if we aren't "vi", we are "view"
4327         if (ENABLE_FEATURE_VI_READONLY && applet_name[2]) {
4328                 SET_READONLY_MODE(readonly_mode);
4329         }
4330 #endif
4331
4332         // autoindent is not default in vim 7.3
4333         vi_setops = /*VI_AUTOINDENT |*/ VI_SHOWMATCH | VI_IGNORECASE;
4334         //  1-  process $HOME/.exrc file (not inplemented yet)
4335         //  2-  process EXINIT variable from environment
4336         //  3-  process command line args
4337 #if ENABLE_FEATURE_VI_COLON
4338         {
4339                 char *p = getenv("EXINIT");
4340                 if (p && *p)
4341                         initial_cmds[0] = xstrndup(p, MAX_INPUT_LEN);
4342         }
4343 #endif
4344         while ((c = getopt(argc, argv, "hCRH" IF_FEATURE_VI_COLON("c:"))) != -1) {
4345                 switch (c) {
4346 #if ENABLE_FEATURE_VI_CRASHME
4347                 case 'C':
4348                         crashme = 1;
4349                         break;
4350 #endif
4351 #if ENABLE_FEATURE_VI_READONLY
4352                 case 'R':               // Read-only flag
4353                         SET_READONLY_MODE(readonly_mode);
4354                         break;
4355 #endif
4356 #if ENABLE_FEATURE_VI_COLON
4357                 case 'c':               // cmd line vi command
4358                         if (*optarg)
4359                                 initial_cmds[initial_cmds[0] != NULL] = xstrndup(optarg, MAX_INPUT_LEN);
4360                         break;
4361 #endif
4362                 case 'H':
4363                         show_help();
4364                         // fall through
4365                 default:
4366                         bb_show_usage();
4367                         return 1;
4368                 }
4369         }
4370
4371         // The argv array can be used by the ":next"  and ":rewind" commands
4372         argv += optind;
4373         argc -= optind;
4374
4375         //----- This is the main file handling loop --------------
4376         save_argc = argc;
4377         optind = 0;
4378         // "Save cursor, use alternate screen buffer, clear screen"
4379         write1(ESC"[?1049h");
4380         while (1) {
4381                 edit_file(argv[optind]); // param might be NULL
4382                 if (++optind >= argc)
4383                         break;
4384         }
4385         // "Use normal screen buffer, restore cursor"
4386         write1(ESC"[?1049l");
4387         //-----------------------------------------------------------
4388
4389         return 0;
4390 }