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