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