1 /* vi: set sw=4 ts=4: */
3 * tiny vi.c: A small 'vi' clone
4 * Copyright (C) 2000, 2001 Sterling Huxley <sterling@europa.com>
6 * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
12 * $HOME/.exrc and ./.exrc
13 * add magic to search /foo.*bar
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"
26 /* the CRASHME code is unmaintained, and doesn't currently build */
27 #define ENABLE_FEATURE_VI_CRASHME 0
30 #if ENABLE_LOCALE_SUPPORT
32 #if ENABLE_FEATURE_VI_8BIT
33 //FIXME: this does not work properly for Unicode anyway
34 # define Isprint(c) (isprint)(c)
36 # define Isprint(c) isprint_asciionly(c)
41 /* 0x9b is Meta-ESC */
42 #if ENABLE_FEATURE_VI_8BIT
43 #define Isprint(c) ((unsigned char)(c) >= ' ' && (c) != 0x7f && (unsigned char)(c) != 0x9b)
45 #define Isprint(c) ((unsigned char)(c) >= ' ' && (unsigned char)(c) < 0x7f)
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.
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,
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";
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<>~";
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
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"
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 */
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
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)
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)
127 #define SET_READONLY_FILE(flags) ((void)0)
128 #define SET_READONLY_MODE(flags) ((void)0)
129 #define UNSET_READONLY_FILE(flags) ((void)0)
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
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
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"
160 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
161 int last_row; // where the cursor was last moved to
163 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
166 #if ENABLE_FEATURE_VI_SEARCH
167 char *last_search_pattern; // last pattern from a '/' or '?' search
171 #if ENABLE_FEATURE_VI_YANKMARK
172 char *edit_file__cur_line;
174 int refresh__old_offset;
175 int format_edit_status__tot;
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;
184 #if ENABLE_FEATURE_VI_USE_SIGNALS
185 sigjmp_buf restart; // catch_sig()
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
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];
196 char readbuffer[KEYCODE_BUFFER_SIZE];
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 "."
203 char get_input_line__buf[MAX_INPUT_LEN]; /* former static */
205 char scr_out_buf[MAX_SCR_COLS + MAX_TABSTOP * 2];
207 #define G (*ptr_to_globals)
208 #define text (G.text )
209 #define text_size (G.text_size )
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 )
241 #define readonly_mode 0
243 #define adding2q (G.adding2q )
244 #define lmc_len (G.lmc_len )
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)
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)
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)
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);) \
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)
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)
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[]
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);
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"
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
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
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
370 #define end_cmd_q() ((void)0)
372 #if ENABLE_FEATURE_VI_SETOPTS
373 static void showmatching(char *); // show the matching pair () [] {}
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'
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
385 #if ENABLE_FEATURE_VI_CRASHME
386 static void crash_dummy();
387 static void crash_test();
388 static int crashme = 0;
392 static void write1(const char *out)
397 int vi_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
398 int vi_main(int argc, char **argv)
404 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
407 #if ENABLE_FEATURE_VI_CRASHME
408 srand((long) my_pid);
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);
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
423 char *p = getenv("EXINIT");
425 initial_cmds[0] = xstrndup(p, MAX_INPUT_LEN);
428 while ((c = getopt(argc, argv, "hCRH" IF_FEATURE_VI_COLON("c:"))) != -1) {
430 #if ENABLE_FEATURE_VI_CRASHME
435 #if ENABLE_FEATURE_VI_READONLY
436 case 'R': // Read-only flag
437 SET_READONLY_MODE(readonly_mode);
440 #if ENABLE_FEATURE_VI_COLON
441 case 'c': // cmd line vi command
443 initial_cmds[initial_cmds[0] != 0] = xstrndup(optarg, MAX_INPUT_LEN);
455 // The argv array can be used by the ":next" and ":rewind" commands
457 fn_start = optind; // remember first file name for :next and :rew
460 //----- This is the main file handling loop --------------
461 if (optind >= argc) {
464 for (; optind < argc; optind++) {
465 edit_file(argv[optind]);
468 //-----------------------------------------------------------
473 /* read text from file or create an empty buf */
474 /* will also update current_filename */
475 static int init_text_buffer(char *fn)
478 int size = file_size(fn); // file size. -1 means does not exist.
480 /* allocate/reallocate text buffer */
482 text_size = size + 10240;
483 screenbegin = dot = end = text = xzalloc(text_size);
485 if (fn != current_filename) {
486 free(current_filename);
487 current_filename = xstrdup(fn);
490 // file dont exist. Start empty buf with dummy line
491 char_insert(text, '\n');
494 rc = file_insert(fn, text, 1);
497 last_file_modified = -1;
498 #if ENABLE_FEATURE_VI_YANKMARK
499 /* init the marks. */
500 memset(mark, 0, sizeof(mark));
505 static void edit_file(char *fn)
507 #if ENABLE_FEATURE_VI_YANKMARK
508 #define cur_line edit_file__cur_line
512 #if ENABLE_FEATURE_VI_USE_SIGNALS
516 editing = 1; // 0 = exit, 1 = one file, 2 = multiple files
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;
526 new_screen(rows, columns); // get memory for virtual screen
527 init_text_buffer(fn);
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"
535 last_forward_char = last_input_char = '\0';
539 #if ENABLE_FEATURE_VI_USE_SIGNALS
541 signal(SIGWINCH, winch_sig);
542 signal(SIGTSTP, suspend_sig);
543 sig = sigsetjmp(restart, 1);
545 screenbegin = dot = text;
549 cmd_mode = 0; // 0=command 1=insert 2='R'eplace
552 offset = 0; // no horizontal offset
554 #if ENABLE_FEATURE_VI_DOT_CMD
556 ioq = ioq_start = NULL;
561 #if ENABLE_FEATURE_VI_COLON
566 while ((p = initial_cmds[n])) {
576 free(initial_cmds[n]);
577 initial_cmds[n] = NULL;
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
587 if ((end - text) > 1) {
588 crash_dummy(); // generate a random command
591 string_insert(text, "\n\n##### Ran out of text to work on. #####\n\n"); // insert the string
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);
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)
617 do_cmd(c); // execute the user command
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
627 #if ENABLE_FEATURE_VI_CRASHME
629 crash_test(); // test editor variables
632 //-------------------------------------------------------------------
634 go_bottom_and_clear_to_eol();
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
645 IF_FEATURE_VI_YANKMARK(char c;)
646 IF_FEATURE_VI_SEARCH(char *pat;)
648 *addr = -1; // assume no addr
649 if (*p == '.') { // the current line
652 *addr = count_lines(text, q);
654 #if ENABLE_FEATURE_VI_YANKMARK
655 else if (*p == '\'') { // is this a mark addr
659 if (c >= 'a' && c <= 'z') {
662 q = mark[(unsigned char) c];
663 if (q != NULL) { // is mark valid
664 *addr = count_lines(text, q);
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
676 q = char_search(dot, pat, FORWARD, FULL);
678 *addr = count_lines(text, q);
683 else if (*p == '$') { // the last line in file
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);
691 // unrecognized address - assume -1
697 static char *get_address(char *p, int *b, int *e) // get two colon addrs, if present
699 //----- get the address' i.e., 1,3 'a,'b -----
700 // get FIRST addr, if present
702 p++; // skip over leading spaces
703 if (*p == '%') { // alias for 1,$
706 *e = count_lines(text, end-1);
709 p = get_one_address(p, b);
712 if (*p == ',') { // is there a address separator
716 // get SECOND addr, if present
717 p = get_one_address(p, e);
721 p++; // skip over trailing spaces
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)
729 const char *a = args + flg_no;
730 int l = strlen(opname) - 1; /* opname have + ' ' */
732 // maybe strncmp? we had tons of erroneous strncasecmp's...
733 if (strncasecmp(a, opname, l) == 0
734 || strncasecmp(a, short_opname, 2) == 0
744 // buf must be no longer than MAX_INPUT_LEN!
745 static void colon(char *buf)
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;
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
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
770 buf++; // move past the ':'
774 q = text; // assume 1,$ for the range
776 li = count_lines(text, end - 1);
777 fn = current_filename;
779 // look for optional address(es) :. :1 :1,9 :'q,'a :%
780 buf = get_address(buf, &b, &e);
782 // remember orig command line
785 // get the COMMAND into cmd[]
787 while (*buf != '\0') {
794 while (isblank(*buf))
798 buf1 = last_char_is(cmd, '!');
801 *buf1 = '\0'; // get rid of !
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
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
819 // ------------ now look for the command ------------
821 if (i == 0) { // :123CR goto line #123
823 dot = find_line(b); // what line is #b
827 #if ENABLE_FEATURE_ALLOW_EXEC
828 else if (cmd[0] == '!') { // run a cmd
830 // :!ls run the <cmd>
831 go_bottom_and_clear_to_eol();
833 retcode = system(orig_buf + 1); // run the cmd
835 printf("\nshell returned %i\n\n", retcode);
837 Hit_Return(); // let user see results
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);
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
850 dot = yank_delete(q, r, 1, YANKDEL); // save, then delete lines
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)");
859 // the user supplied a file name
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
865 // no user file name, no current name- punt
866 status_line_bold("No current filename");
870 if (init_text_buffer(fn) < 0)
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'
878 if (YDreg >= 0 && YDreg < 28 && reg[YDreg] != 0) {
879 free(reg[YDreg]); // free default yank/delete register
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]" : ""),
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");
899 // user wants a new filename
900 free(current_filename);
901 current_filename = xstrdup(args);
903 // user wants file status info
904 last_status_cksum = 0; // force status update
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();
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
918 go_bottom_and_clear_to_eol();
920 for (; q <= r; q++) {
924 c_is_no_print = (c & 0x80) && !Isprint(c);
931 } else if (c < ' ' || c == 127) {
942 #if ENABLE_FEATURE_VI_SET
946 } else if (strncmp(cmd, "quit", i) == 0 // Quit
947 || strncmp(cmd, "next", i) == 0 // edit next file
950 // force end of argv list
957 // don't exit if the file been modified
959 status_line_bold("No write since last change (:%s! overrides)",
960 (*cmd == 'q' ? "quit" : "next"));
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));
968 if (*cmd == 'n' && optind >= save_argc - 1) {
969 status_line_bold("No more files to edit");
973 } else if (strncmp(cmd, "read", i) == 0) { // read file into text[]
976 status_line_bold("No filename given");
979 if (b < 0) { // no addr given- use defaults
980 q = begin_line(dot); // assume "dot"
982 // read after current line- unless user said ":0r foo"
985 { // dance around potentially-reallocated text[]
986 uintptr_t ofs = q - text;
987 ch = file_insert(fn, q, 0);
991 goto vc1; // nothing was inserted
992 // how many lines in text[]?
993 li = count_lines(q, q + ch - 1);
995 IF_FEATURE_VI_READONLY("%s")
997 IF_FEATURE_VI_READONLY((readonly_mode ? " [Readonly]" : ""),)
1000 // if the insert is before "dot" then we need to update
1003 /*file_modified++; - done by file_insert */
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)");
1009 // reset the filenames to edit
1010 optind = fn_start - 1;
1013 #if ENABLE_FEATURE_VI_SET
1014 } else if (strncmp(cmd, "set", i) == 0) { // set or clear features
1015 #if ENABLE_FEATURE_VI_SETOPTS
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
1027 printf("autoindent ");
1033 printf("ignorecase ");
1036 printf("showmatch ");
1037 printf("tabstop=%d ", tabstop);
1042 #if ENABLE_FEATURE_VI_SETOPTS
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);
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)
1057 while (*argp && *argp != ' ')
1058 argp++; // skip to arg delimiter (i.e. blank)
1059 while (*argp && *argp == ' ')
1060 argp++; // skip all delimiting blanks
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
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
1078 *R++ = '\0'; // terminate "find"
1079 buf1 = strchr(R, c);
1082 *buf1++ = '\0'; // terminate "replace"
1083 if (*buf1 == 'g') { // :s/foo/bar/g
1085 gflag++; // turn on gflag
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
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
1097 buf1 = char_search(q, F, FORWARD, LIMITED); // search cur line only for "find"
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
1106 /*q += bias; - recalculated anyway */
1107 // check for "global" :s/foo/bar/g
1109 if ((buf1 + strlen(R)) < end_line(ls)) {
1110 q = buf1 + strlen(R);
1111 goto vc4; // don't let q move past cur line
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])
1125 // is there a file name to write to?
1129 #if ENABLE_FEATURE_VI_READONLY
1130 if (readonly_mode && !useforce) {
1131 status_line_bold("\"%s\" File is read only", fn);
1135 // how many lines in text[]?
1136 li = count_lines(q, r);
1138 // see if file exists- if not, its just a new file request
1140 // if "fn" is not write-able, chmod u+w
1141 // sprintf(syscmd, "chmod u+w %s", fn);
1145 l = file_write(fn, q, r);
1146 if (useforce && forced) {
1148 // sprintf(syscmd, "chmod u-w %s", fn);
1154 status_line_bold("\"%s\" %s", fn, strerror(errno));
1156 status_line("\"%s\" %dL, %dC", fn, li, l);
1157 if (q == text && r == end - 1 && l == ch) {
1159 last_file_modified = -1;
1161 if ((cmd[0] == 'x' || cmd[1] == 'q' || cmd[1] == 'n'
1162 || cmd[0] == 'X' || cmd[1] == 'Q' || cmd[1] == 'N'
1169 #if ENABLE_FEATURE_VI_READONLY
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
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());
1185 not_implemented(cmd);
1188 dot = bound_dot(dot); // make sure "dot" is valid
1190 #if ENABLE_FEATURE_VI_SEARCH
1192 status_line(":s expression missing delimiters");
1196 #endif /* FEATURE_VI_COLON */
1198 static void Hit_Return(void)
1203 write1("[Hit return to continue]");
1205 while ((c = get_one_char()) != '\n' && c != '\r')
1207 redraw(TRUE); // force redraw all
1210 static int next_tabstop(int col)
1212 return col + ((tabstop - 1) - (col % tabstop));
1215 //----- Synchronize the cursor to Dot --------------------------
1216 static NOINLINE void sync_cursor(char *d, int *row, int *col)
1218 char *beg_cur; // begin and end of "d" line
1222 beg_cur = begin_line(d); // first char of cur line
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);
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);
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);
1254 // "d" is on screen- find out which row
1256 for (ro = 0; ro < rows - 1; ro++) { // drive "ro" to correct row
1262 // find out what col "d" is on
1264 while (tp < d) { // drive "co" to correct column
1265 if (*tp == '\n') //vda || *tp == '\0')
1268 // handle tabs like real vi
1269 if (d == tp && cmd_mode) {
1272 co = next_tabstop(co);
1273 } else if ((unsigned char)*tp < ' ' || *tp == 0x7f) {
1274 co++; // display as ^X, use 2 columns
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 // |-------------------------------------------------------------|
1285 // offset | |------- columns ----------------|
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.
1293 if (co < 0 + offset) {
1296 if (co >= columns + offset) {
1297 offset = co - columns + 1;
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') {
1310 //----- Text Movement Routines ---------------------------------
1311 static char *begin_line(char *p) // return pointer to first char cur line
1314 p = memrchr(text, '\n', p - text);
1322 static char *end_line(char *p) // return pointer to NL of cur line
1325 p = memchr(p, '\n', end - p - 1);
1332 static char *dollar_line(char *p) // return pointer to just before NL line
1335 // Try to stay off of the Newline
1336 if (*p == '\n' && (p - begin_line(p)) > 0)
1341 static char *prev_line(char *p) // return pointer first char prev line
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
1350 static char *next_line(char *p) // return pointer first char next line
1353 if (p < end - 1 && *p == '\n')
1354 p++; // step to next line
1358 //----- Text Information Routines ------------------------------
1359 static char *end_screen(void)
1364 // find new bottom line
1366 for (cnt = 0; cnt < rows - 2; cnt++)
1372 // count line from start to stop
1373 static int count_lines(char *start, char *stop)
1378 if (stop < start) { // start and stop are backwards- reverse them
1384 stop = end_line(stop);
1385 while (start <= stop && start <= end - 1) {
1386 start = end_line(start);
1394 static char *find_line(int li) // find begining of line #li
1398 for (q = text; li > 1; li--) {
1404 //----- Dot Movement Routines ----------------------------------
1405 static void dot_left(void)
1407 if (dot > text && dot[-1] != '\n')
1411 static void dot_right(void)
1413 if (dot < end - 1 && *dot != '\n')
1417 static void dot_begin(void)
1419 dot = begin_line(dot); // return pointer to first char cur line
1422 static void dot_end(void)
1424 dot = end_line(dot); // return pointer to last char cur line
1427 static char *move_to_col(char *p, int l)
1433 while (co < l && p < end) {
1434 if (*p == '\n') //vda || *p == '\0')
1437 co = next_tabstop(co);
1438 } else if (*p < ' ' || *p == 127) {
1439 co++; // display as ^X, use 2 columns
1447 static void dot_next(void)
1449 dot = next_line(dot);
1452 static void dot_prev(void)
1454 dot = prev_line(dot);
1457 static void dot_scroll(int cnt, int dir)
1461 for (; cnt > 0; cnt--) {
1464 // ctrl-Y scroll up one line
1465 screenbegin = prev_line(screenbegin);
1468 // ctrl-E scroll down one line
1469 screenbegin = next_line(screenbegin);
1472 // make sure "dot" stays on the screen so we dont scroll off
1473 if (dot < screenbegin)
1475 q = end_screen(); // find new bottom line
1477 dot = begin_line(q); // is dot is below bottom line?
1481 static void dot_skip_over_ws(void)
1484 while (isspace(*dot) && *dot != '\n' && dot < end - 1)
1488 static void dot_delete(void) // delete the char at 'dot'
1490 text_hole_delete(dot, dot);
1493 static char *bound_dot(char *p) // make sure text[0] <= P < "end"
1495 if (p >= end && end > text) {
1497 indicate_error('1');
1501 indicate_error('2');
1506 //----- Helper Utility Routines --------------------------------
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
1519 static char *new_screen(int ro, int co)
1524 screensize = ro * co + 8;
1525 screen = xmalloc(screensize);
1526 // initialize the new screen. assume this will be a empty file.
1528 // non-existent text[] lines start with a tilde (~).
1529 for (li = 1; li < ro - 1; li++) {
1530 screen[(li * co) + 0] = '~';
1535 #if ENABLE_FEATURE_VI_SEARCH
1536 static int mycmp(const char *s1, const char *s2, int len)
1538 if (ENABLE_FEATURE_VI_SETOPTS && ignorecase) {
1539 return strncasecmp(s1, s2, len);
1541 return strncmp(s1, s2, len);
1544 // search for pattern starting at p
1545 static char *char_search(char *p, const char *pat, int dir, int range)
1547 #ifndef REGEX_SEARCH
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) {
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) {
1571 // pattern not found
1573 #else /* REGEX_SEARCH */
1575 struct re_pattern_buffer preg;
1579 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1585 // assume a LIMITED forward search
1593 // count the number of chars to search over, forward or backward
1597 // RANGE could be negative if we are searching backwards
1600 q = re_compile_pattern(pat, strlen(pat), &preg);
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
1614 // search for the compiled pattern, preg, in p[]
1615 // range < 0- search backward
1616 // range > 0- search forward
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);
1625 i = 0; // return NULL if pattern not found
1628 if (dir == FORWARD) {
1634 #endif /* REGEX_SEARCH */
1636 #endif /* FEATURE_VI_SEARCH */
1638 static char *char_insert(char *p, char c) // insert the char c at 'p'
1640 if (c == 22) { // Is this an ctrl-V?
1641 p += stupid_insert(p, '^'); // use ^ to indicate literal next
1642 refresh(FALSE); // show the ^
1647 } else if (c == 27) { // Is this an ESC?
1650 end_cmd_q(); // stop adding to q
1651 last_status_cksum = 0; // force status update
1652 if ((p[-1] != '\n') && (dot > text)) {
1655 } else if (c == erase_char || c == 8 || c == 127) { // Is this a BS
1657 if ((p[-1] != '\n') && (dot>text)) {
1659 p = text_hole_delete(p, p); // shrink buffer 1 char
1662 // insert a char into text[]
1663 char *sp; // "save p"
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) {
1673 if (autoindent && c == '\n') { // auto indent the new line
1676 q = prev_line(p); // use prev line as template
1677 len = strspn(q, " \t"); // space or tab
1680 bias = text_hole_make(p, len);
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'
1697 bias = text_hole_make(p, 1);
1700 //file_modified++; - done by text_hole_make()
1704 static int find_range(char **start, char **stop, char c)
1706 char *save_dot, *p, *q, *t;
1707 int cnt, multiline = 0;
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++) {
1719 } else if (strchr("^%$0bBeEfth\b\177", c)) {
1720 // These cmds operate on char positions
1721 do_cmd(c); // execute movement cmd
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
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
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
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.
1760 // backward char movements don't include start position
1761 if (q > p && strchr("^0bBh\b\177", c)) q--;
1764 for (t = p; t <= q; t++) {
1777 static int st_test(char *p, int type, int dir, char *tested)
1787 if (type == S_BEFORE_WS) {
1789 test = (!isspace(c) || c == '\n');
1791 if (type == S_TO_WS) {
1793 test = (!isspace(c) || c == '\n');
1795 if (type == S_OVER_WS) {
1799 if (type == S_END_PUNCT) {
1803 if (type == S_END_ALNUM) {
1805 test = (isalnum(c) || c == '_');
1811 static char *skip_thing(char *p, int linecnt, int dir, int type)
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)
1819 if (dir >= 0 && p >= end - 1)
1821 if (dir < 0 && p <= text)
1823 p += dir; // move to next char
1828 // find matching char of pair () [] {}
1829 static char *find_pair(char *p, const char c)
1836 dir = 1; // assume forward
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;
1845 for (q = p + dir; text <= q && q < end; q += dir) {
1846 // look for match, count levels of pairs (( ))
1848 level++; // increase pair levels
1850 level--; // reduce pair level
1852 break; // found matching pair
1855 q = NULL; // indicate no match
1859 #if ENABLE_FEATURE_VI_SETOPTS
1860 // show the matching char of a pair, () [] {}
1861 static void showmatching(char *p)
1865 // we found half of a pair
1866 q = find_pair(p, *p); // get loc of matching char
1868 indicate_error('3'); // no matching char
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
1879 #endif /* FEATURE_VI_SETOPTS */
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
1890 end += size; // adjust the new END
1891 if (end >= (text + text_size)) {
1893 text_size += end - (text + text_size) + 10240;
1894 new_text = xrealloc(text, text_size);
1895 bias = (new_text - text);
1896 screenbegin += bias;
1902 memmove(p + size, p, end - size - p);
1903 memset(p, ' ', size); // clear new hole
1908 // close a hole in text[]
1909 static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclusive
1914 // move forwards, from beginning
1918 if (q < p) { // they are backward- swap them
1922 hole_size = q - p + 1;
1924 if (src < text || src > end)
1926 if (dest < text || dest >= end)
1929 goto thd_atend; // just delete the end of the buffer
1930 memmove(dest, src, cnt);
1932 end = end - hole_size; // adjust the new END
1934 dest = end - 1; // make sure dest in below end-1
1936 dest = end = text; // keep pointers valid
1942 // copy text into register, then delete text.
1943 // if dist <= 0, do not include, or go past, a NewLine
1945 static char *yank_delete(char *start, char *stop, int dist, int yf)
1949 // make sure start <= stop
1951 // they are backwards, reverse them
1957 // we cannot cross NL boundaries
1961 // dont go past a NewLine
1962 for (; p + 1 <= stop; p++) {
1964 stop = p; // "stop" just before NewLine
1970 #if ENABLE_FEATURE_VI_YANKMARK
1971 text_yank(start, stop, YDreg);
1973 if (yf == YANKDEL) {
1974 p = text_hole_delete(start, stop);
1979 static void show_help(void)
1981 puts("These features are available:"
1982 #if ENABLE_FEATURE_VI_SEARCH
1983 "\n\tPattern searches with / and ?"
1985 #if ENABLE_FEATURE_VI_DOT_CMD
1986 "\n\tLast command repeat with \'.\'"
1988 #if ENABLE_FEATURE_VI_YANKMARK
1989 "\n\tLine marking with 'x"
1990 "\n\tNamed buffers with \"x"
1992 #if ENABLE_FEATURE_VI_READONLY
1993 "\n\tReadonly if vi is called as \"view\""
1994 "\n\tReadonly with -R command line arg"
1996 #if ENABLE_FEATURE_VI_SET
1997 "\n\tSome colon mode commands with \':\'"
1999 #if ENABLE_FEATURE_VI_SETOPTS
2000 "\n\tSettable options with \":set\""
2002 #if ENABLE_FEATURE_VI_USE_SIGNALS
2003 "\n\tSignal catching- ^C"
2004 "\n\tJob suspend and resume with ^Z"
2006 #if ENABLE_FEATURE_VI_WIN_RESIZE
2007 "\n\tAdapt to window re-sizes"
2012 #if ENABLE_FEATURE_VI_DOT_CMD
2013 static void start_new_cmd_q(char c)
2015 // get buffer for new cmd
2016 // if there is a current cmd count put it in the buffer first
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;
2026 static void end_cmd_q(void)
2028 #if ENABLE_FEATURE_VI_YANKMARK
2029 YDreg = 26; // go back to default Yank/Delete reg
2033 #endif /* FEATURE_VI_DOT_CMD */
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'
2046 bias = text_hole_make(p, i);
2049 #if ENABLE_FEATURE_VI_YANKMARK
2052 for (cnt = 0; *s != '\0'; s++) {
2056 status_line("Put %d lines (%d chars) from [%c]", cnt, i, what_reg());
2063 #if ENABLE_FEATURE_VI_YANKMARK
2064 static char *text_yank(char *p, char *q, int dest) // copy text into a register
2067 if (cnt < 0) { // they are backwards- reverse them
2071 free(reg[dest]); // if already a yank register, free it
2072 reg[dest] = xstrndup(p, cnt + 1);
2076 static char what_reg(void)
2080 c = 'D'; // default to D-reg
2081 if (0 <= YDreg && YDreg <= 25)
2082 c = 'a' + (char) YDreg;
2090 static void check_context(char cmd)
2092 // A context is defined to be "modifying text"
2093 // Any modifying command establishes a new context.
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;
2107 static char *swap_context(char *p) // goto new context for '' command make this the current context
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) {
2116 mark[27] = mark[26];
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)));
2124 #endif /* FEATURE_VI_YANKMARK */
2126 //----- Set terminal attributes --------------------------------
2127 static void rawmode(void)
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);
2140 static void cookmode(void)
2143 tcsetattr_stdin_TCSANOW(&term_orig);
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)
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;
2157 new_screen(rows, columns); // get memory for virtual screen
2158 redraw(TRUE); // re-draw the screen
2161 //----- Come here when we get a continue signal -------------------
2162 static void cont_sig(int sig UNUSED_PARAM)
2164 rawmode(); // terminal to "raw"
2165 last_status_cksum = 0; // force status update
2166 redraw(TRUE); // re-draw the screen
2168 signal(SIGTSTP, suspend_sig);
2169 signal(SIGCONT, SIG_DFL);
2170 kill(my_pid, SIGCONT); // huh? why? we are already "continued"...
2173 //----- Come here when we get a Suspend signal -------------------
2174 static void suspend_sig(int sig UNUSED_PARAM)
2176 go_bottom_and_clear_to_eol();
2177 cookmode(); // terminal to "cooked"
2179 signal(SIGCONT, cont_sig);
2180 signal(SIGTSTP, SIG_DFL);
2181 kill(my_pid, SIGTSTP);
2184 //----- Come here when we get a signal ---------------------------
2185 static void catch_sig(int sig)
2187 signal(SIGINT, catch_sig);
2189 siglongjmp(restart, sig);
2191 #endif /* FEATURE_VI_USE_SIGNALS */
2193 static int mysleep(int hund) // sleep for 'hund' 1/100 seconds or stdin ready
2195 struct pollfd pfd[1];
2197 pfd[0].fd = STDIN_FILENO;
2198 pfd[0].events = POLLIN;
2199 return safe_poll(pfd, 1, hund*10) > 0;
2202 //----- IO Routines --------------------------------------------
2203 static int readit(void) // read (maybe cursor) key from stdin
2208 c = read_key(STDIN_FILENO, readbuffer);
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");
2217 //----- IO Routines --------------------------------------------
2218 static int get_one_char(void)
2222 #if ENABLE_FEATURE_VI_DOT_CMD
2224 // we are not adding to the q.
2225 // but, we may be reading from a q
2227 // there is no current q, read from STDIN
2228 c = readit(); // get the users input
2230 // there is a queue to get chars from first
2231 // careful with correct sign expansion!
2232 c = (unsigned char)*ioq++;
2234 // the end of the q, read from STDIN
2236 ioq_start = ioq = 0;
2237 c = readit(); // get the users input
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");
2246 // add new char to q
2247 last_modifying_cmd[lmc_len++] = c;
2251 c = readit(); // get the users input
2252 #endif /* FEATURE_VI_DOT_CMD */
2256 // Get input line (uses "status line" area)
2257 static char *get_input_line(const char *prompt)
2259 // char [MAX_INPUT_LEN]
2260 #define buf get_input_line__buf
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
2271 while (i < MAX_INPUT_LEN) {
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
2278 write1("\b \b"); // erase char on screen
2279 if (i <= 0) // user backs up before b-o-l, exit
2281 } else if (c > 0 && c < 256) { // exclude Unicode
2282 // (TODO: need to handle Unicode)
2293 static int file_size(const char *fn) // what is the byte size of "fn"
2299 if (fn && fn[0] && stat(fn, &st_buf) == 0) // see if file exists
2300 cnt = (int) st_buf.st_size;
2304 // might reallocate text[]!
2305 static int file_insert(const char *fn, char *p, int update_ro_status)
2309 struct stat statbuf;
2312 if (stat(fn, &statbuf) < 0) {
2313 status_line_bold("\"%s\" %s", fn, strerror(errno));
2316 if (!S_ISREG(statbuf.st_mode)) {
2317 // This is not a regular file
2318 status_line_bold("\"%s\" Not a regular file", fn);
2321 if (p < text || p > end) {
2322 status_line_bold("Trying to insert file outside of memory");
2326 // read file to buffer
2327 fd = open(fn, O_RDONLY);
2329 status_line_bold("\"%s\" %s", fn, strerror(errno));
2332 size = statbuf.st_size;
2333 p += text_hole_make(p, size);
2334 cnt = safe_read(fd, p, size);
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);
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))
2355 SET_READONLY_FILE(readonly_mode);
2361 static int file_write(char *fn, char *first, char *last)
2363 int fd, cnt, charcnt;
2366 status_line_bold("No current filename");
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.
2374 fd = open(fn, (O_WRONLY | O_CREAT), 0666);
2377 cnt = last - first + 1;
2378 charcnt = full_write(fd, first, cnt);
2379 ftruncate(fd, charcnt);
2380 if (charcnt == cnt) {
2382 //file_modified = FALSE;
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
2399 // 23,0 ... 23,79 <- status line
2401 //----- Move the cursor to row x col (count from 0, not 1) -------
2402 static void place_cursor(int row, int col, int optimize)
2404 char cm1[sizeof(CMrc) + sizeof(int)*3 * 2];
2405 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
2407 SZ_UP = sizeof(CMup),
2408 SZ_DN = sizeof(CMdown),
2409 SEQ_SIZE = SZ_UP > SZ_DN ? SZ_UP : SZ_DN,
2411 char cm2[SEQ_SIZE * 5 + 32]; // bigger than worst case size
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;
2420 //----- 1. Try the standard terminal ESC sequence
2421 sprintf(cm1, CMrc, row + 1, col + 1);
2424 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
2425 if (optimize && col < 16) {
2427 int Rrow = last_row;
2428 int diff = Rrow - row;
2430 if (diff < -5 || diff > 5)
2433 //----- find the minimum # of chars to move cursor -------------
2434 //----- 2. Try moving with discreet chars (Newline, [back]space, ...)
2437 // move to the correct row
2438 while (row < Rrow) {
2439 // the cursor has to move up
2443 while (row > Rrow) {
2444 // the cursor has to move down
2445 strcat(cm2, CMdown);
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);
2455 // pick the shortest cursor motion to send out
2456 if (strlen(cm2) < strlen(cm)) {
2462 #endif /* FEATURE_VI_OPTIMIZE_CURSOR */
2466 //----- Erase from cursor to end of line -----------------------
2467 static void clear_to_eol(void)
2469 write1(Ceol); // Erase from cursor to end of line
2472 static void go_bottom_and_clear_to_eol(void)
2474 place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
2475 clear_to_eol(); // erase to end of line
2478 //----- Erase from cursor to end of screen -----------------------
2479 static void clear_to_eos(void)
2481 write1(Ceos); // Erase from cursor to end of screen
2484 //----- Start standout mode ------------------------------------
2485 static void standout_start(void) // send "start reverse video" sequence
2487 write1(SOs); // Start reverse video mode
2490 //----- End standout mode --------------------------------------
2491 static void standout_end(void) // send "end reverse video" sequence
2493 write1(SOn); // End reverse video mode
2496 //----- Flash the screen --------------------------------------
2497 static void flash(int h)
2499 standout_start(); // send "start reverse video" sequence
2502 standout_end(); // send "end reverse video" sequence
2506 static void Indicate_Error(void)
2508 #if ENABLE_FEATURE_VI_CRASHME
2510 return; // generate a random command
2513 write1(bell); // send out a bell character
2519 //----- Screen[] Routines --------------------------------------
2520 //----- Erase the Screen[] memory ------------------------------
2521 static void screen_erase(void)
2523 memset(screen, ' ', screensize); // clear new screen
2526 static int bufsum(char *buf, int count)
2529 char *e = buf + count;
2532 sum += (unsigned char) *buf++;
2536 //----- Draw the status line at bottom of the screen -------------
2537 static void show_status_line(void)
2539 int cnt = 0, cksum = 0;
2541 // either we already have an error or status message, or we
2543 if (!have_status_msg) {
2544 cnt = format_edit_status();
2545 cksum = bufsum(status_buffer, cnt);
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)) >
2554 have_status_msg = 0;
2557 have_status_msg = 0;
2559 place_cursor(crow, ccol, FALSE); // put cursor back in correct place
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, ...)
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
2576 have_status_msg = 1 + sizeof(SOs) + sizeof(SOn) - 2;
2579 // format status buffer
2580 static void status_line(const char *format, ...)
2584 va_start(args, format);
2585 vsprintf(status_buffer, format, args);
2588 have_status_msg = 1;
2591 // copy s to buf, convert unprintable
2592 static void print_literal(char *buf, const char *s)
2606 c_is_no_print = (c & 0x80) && !Isprint(c);
2607 if (c_is_no_print) {
2612 if (c < ' ' || c == 0x7f) {
2614 c |= '@'; /* 0x40 */
2620 if (c_is_no_print) {
2628 if (d - buf > MAX_INPUT_LEN - 10) // paranoia
2633 static void not_implemented(const char *s)
2635 char buf[MAX_INPUT_LEN];
2637 print_literal(buf, s);
2638 status_line_bold("\'%s\' is not implemented", buf);
2641 // show file status on status line
2642 static int format_edit_status(void)
2644 static const char cmd_mode_indicator[] ALIGN1 = "-IR-";
2646 #define tot format_edit_status__tot
2648 int cur, percent, ret, trunc_at;
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.)
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);
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;
2667 // current line percent
2668 // ------------- ~~ ----------
2671 percent = (100 * cur) / tot;
2677 trunc_at = columns < STATUS_BUFFER_LEN-1 ?
2678 columns : STATUS_BUFFER_LEN-1;
2680 ret = snprintf(status_buffer, trunc_at+1,
2681 #if ENABLE_FEATURE_VI_READONLY
2682 "%c %s%s%s %d/%d %d%%",
2684 "%c %s%s %d/%d %d%%",
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]" : ""),
2691 (file_modified ? " [Modified]" : ""),
2694 if (ret >= 0 && ret < trunc_at)
2695 return ret; /* it all fit */
2697 return trunc_at; /* had to truncate */
2701 //----- Force refresh of all Lines -----------------------------
2702 static void redraw(int full_screen)
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
2712 //----- Format a text[] line into a buffer ---------------------
2713 static char* format_line(char *src /*, int li*/)
2718 char *dest = scr_out_buf; // [MAX_SCR_COLS + MAX_TABSTOP * 2]
2720 c = '~'; // char in col 0 in non-existent lines is '~'
2722 while (co < columns + tabstop) {
2723 // have we gone past the end?
2728 if ((c & 0x80) && !Isprint(c)) {
2731 if (c < ' ' || c == 0x7f) {
2735 while ((co % tabstop) != (tabstop - 1)) {
2743 c += '@'; // Ctrl-X -> 'X'
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);
2758 // check "short line, gigantic offset" case
2761 // discard last scrolled off part
2764 // fill the rest with spaces
2766 memset(&dest[co], ' ', columns - co);
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.
2775 static void refresh(int full_screen)
2777 #define old_offset refresh__old_offset
2780 char *tp, *sp; // pointer into text[] and screen[]
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);
2789 sync_cursor(dot, &crow, &ccol); // where cursor will be (on "dot")
2790 tp = screenbegin; // index into text[] of top line
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
2796 // format current text line
2797 out_buf = format_line(tp /*, li*/);
2799 // skip to the end of the current text[] line
2801 char *t = memchr(tp, '\n', end - tp);
2802 if (!t) t = end - 1;
2806 // see if there are any changes between vitual screen and out_buf
2807 changed = FALSE; // assume no change
2810 sp = &screen[li * columns]; // start of screen line
2812 // force re-draw of every single column from 0 - columns-1
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
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
2831 // now, cs is index of first diff, and ce is index of last diff
2833 // if horz offset has changed, force a redraw
2834 if (offset != old_offset) {
2839 // make a sanity check of columns indexes
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
2845 // copy changed part of buffer to virtual screen
2846 memcpy(sp+cs, out_buf+cs, ce-cs+1);
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);
2854 place_cursor(li, cs, TRUE);
2857 // write line out to terminal
2858 fwrite(&sp[cs], ce - cs + 1, 1, stdout);
2862 place_cursor(crow, ccol, TRUE);
2864 old_offset = offset;
2868 //---------------------------------------------------------------------
2869 //----- the Ascii Chart -----------------------------------------------
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 //---------------------------------------------------------------------
2889 //----- Execute a Vi Command -----------------------------------
2890 static void do_cmd(int c)
2892 const char *msg = msg; // for compiler
2893 char *p, *q, *save_dot;
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);
2906 /* if this is a cursor key, skip these checks */
2914 case KEYCODE_PAGEUP:
2915 case KEYCODE_PAGEDOWN:
2916 case KEYCODE_DELETE:
2920 if (cmd_mode == 2) {
2921 // flip-flop Insert/Replace mode
2922 if (c == KEYCODE_INSERT)
2924 // we are 'R'eplacing the current *dot with new char
2926 // don't Replace past E-o-l
2927 cmd_mode = 1; // convert to insert
2929 if (1 <= c || Isprint(c)) {
2931 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
2932 dot = char_insert(dot, c); // insert new char
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);
2957 #if ENABLE_FEATURE_VI_CRASHME
2958 case 0x14: // dc4 ctrl-T
2959 crashme = (crashme == 0) ? 1 : 0;
2988 //case 'u': // u- FIXME- there is no undo
2990 default: // unrecognized command
2993 not_implemented(buf);
2994 end_cmd_q(); // stop adding to q
2995 case 0x00: // nul- ignore
2997 case 2: // ctrl-B scroll up full screen
2998 case KEYCODE_PAGEUP: // Cursor Key Page Up
2999 dot_scroll(rows - 2, -1);
3001 case 4: // ctrl-D scroll down half screen
3002 dot_scroll((rows - 2) / 2, 1);
3004 case 5: // ctrl-E scroll down one line
3007 case 6: // ctrl-F scroll down full screen
3008 case KEYCODE_PAGEDOWN: // Cursor Key Page Down
3009 dot_scroll(rows - 2, 1);
3011 case 7: // ctrl-G show current status
3012 last_status_cksum = 0; // force status update
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)
3023 case 10: // Newline ^J
3024 case 'j': // j- goto next line, same col
3025 case KEYCODE_DOWN: // cursor key Down
3029 dot_next(); // go to next B-o-l
3030 dot = move_to_col(dot, ccol + offset); // try stay in same col
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
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
3041 case 13: // Carriage Return ^M
3042 case '+': // +- goto next line
3049 case 21: // ctrl-U scroll up half screen
3050 dot_scroll((rows - 2) / 2, -1);
3052 case 25: // ctrl-Y scroll up one line
3058 cmd_mode = 0; // stop insrting
3060 last_status_cksum = 0; // force status update
3062 case ' ': // move right
3063 case 'l': // move right
3064 case KEYCODE_RIGHT: // Cursor Key Right
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?
3079 case '\'': // '- goto a specific mark
3080 c1 = (get_one_char() | 0x20) - 'a';
3081 if ((unsigned)c1 <= 25) { // a-z?
3084 if (text <= q && q < end) {
3086 dot_begin(); // go to B-o-l
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
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
3110 case 'P': // P- Put register before
3111 case 'p': // p- put register after
3114 status_line_bold("Nothing in register %c", what_reg());
3117 // are we putting whole lines or strings
3118 if (strchr(p, '\n') != NULL) {
3120 dot_begin(); // putting lines- Put above
3123 // are we putting after very last line?
3124 if (end_line(dot) == (end - 1)) {
3125 dot = end; // force dot to end of text[]
3127 dot_next(); // next line, then put before
3132 dot_right(); // move to right, can move to NL
3134 string_insert(dot, p); // insert the string
3135 end_cmd_q(); // stop adding to q
3137 case 'U': // U- Undo; replace current line with original version
3138 if (reg[Ureg] != 0) {
3139 p = begin_line(dot);
3141 p = text_hole_delete(p, q); // delete cur line
3142 p += string_insert(p, reg[Ureg]); // insert orig line
3147 #endif /* FEATURE_VI_YANKMARK */
3148 case '$': // $- goto end of line
3149 case KEYCODE_END: // Cursor Key End
3153 dot = end_line(dot);
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);
3171 case 'f': // f- forward to a user specified char
3172 last_forward_char = get_one_char(); // get the search char
3174 // dont separate these two commands. 'f' depends on ';'
3176 //**** fall through to ... ';'
3177 case ';': // ;- look at rest of line for last forward char
3181 if (last_forward_char == 0)
3184 while (q < end - 1 && *q != '\n' && *q != last_forward_char) {
3187 if (*q == last_forward_char)
3190 case ',': // repeat latest 'f' in opposite direction
3194 if (last_forward_char == 0)
3197 while (q >= text && *q != '\n' && *q != last_forward_char) {
3200 if (q >= text && *q == last_forward_char)
3204 case '-': // -- goto prev line
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.
3216 last_modifying_cmd[lmc_len] = 0;
3217 ioq = ioq_start = xstrdup(last_modifying_cmd);
3221 #if ENABLE_FEATURE_VI_SEARCH
3222 case '?': // /- search for a pattern
3223 case '/': // /- search for a pattern
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
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
3238 // user changed mind and erased the "/"- do nothing
3240 case 'N': // N- backward search for last pattern
3244 dir = BACK; // assume BACKWARD search
3246 if (last_search_pattern[0] == '?') {
3250 goto dc4; // now search for pattern
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
3259 dir = FORWARD; // assume FORWARD search
3261 if (last_search_pattern[0] == '?') {
3266 q = char_search(p, last_search_pattern + 1, dir, FULL);
3268 dot = q; // good search, update "dot"
3272 // no pattern found between "dot" and "end"- continue at top
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";
3282 msg = "search hit TOP, continuing at BOTTOM";
3285 msg = "Pattern not found";
3289 status_line_bold("%s", msg);
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
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
3303 #endif /* FEATURE_VI_SEARCH */
3304 case '0': // 0- goto begining of line
3314 if (c == '0' && cmdcnt < 1) {
3315 dot_begin(); // this was a standalone zero
3317 cmdcnt = cmdcnt * 10 + (c - '0'); // this 0 is part of a number
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
3326 p++; // move past the ':'
3330 if (strncmp(p, "quit", cnt) == 0
3331 || strncmp(p, "q!", cnt) == 0 // delete lines
3333 if (file_modified && p[1] != '!') {
3334 status_line_bold("No write since last change (:quit! overrides)");
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])
3343 cnt = file_write(current_filename, text, end - 1);
3346 status_line_bold("Write error: %s", strerror(errno));
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'
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
3362 } else { // unrecognized cmd
3365 #endif /* !FEATURE_VI_COLON */
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
3375 i = count_lines(p, q); // # of lines we are shifting
3376 for ( ; i > 0; i--, p = next_line(p)) {
3378 // shift left- remove tab or 8 spaces
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);
3388 } else if (c == '>') {
3389 // shift right -- add tab or 8 spaces
3390 char_insert(p, '\t');
3393 dot = find_line(cnt); // what line were we on
3395 end_cmd_q(); // stop adding to q
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
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
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);
3419 dot = skip_thing(dot, 1, dir, S_BEFORE_WS);
3421 case 'C': // C- Change to e-o-l
3422 case 'D': // D- delete to e-o-l
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
3428 goto dc_i; // start inserting
3429 #if ENABLE_FEATURE_VI_DOT_CMD
3431 end_cmd_q(); // stop adding to q
3434 case 'g': // 'gg' goto a line number (vim) (default: very first line)
3435 c1 = get_one_char();
3438 buf[1] = c1; // TODO: if Unicode?
3440 not_implemented(buf);
3446 case 'G': // G- goto to a line number (default= E-O-F)
3447 dot = end - 1; // assume E-O-F
3449 dot = find_line(cmdcnt); // what line is #cmdcnt
3453 case 'H': // H- goto top line on screen
3455 if (cmdcnt > (rows - 1)) {
3456 cmdcnt = (rows - 1);
3463 case 'I': // I- insert before first non-blank
3466 //**** fall through to ... 'i'
3467 case 'i': // i- insert before current char
3468 case KEYCODE_INSERT: // Cursor Key Insert
3470 cmd_mode = 1; // start insrting
3472 case 'J': // J- join current and next lines together
3476 dot_end(); // move to NL
3477 if (dot < end - 1) { // make sure not last char in text[]
3478 *dot++ = ' '; // replace NL with space
3480 while (isblank(*dot)) { // delete leading WS
3484 end_cmd_q(); // stop adding to q
3486 case 'L': // L- goto bottom line on screen
3488 if (cmdcnt > (rows - 1)) {
3489 cmdcnt = (rows - 1);
3497 case 'M': // M- goto middle line on screen
3499 for (cnt = 0; cnt < (rows-1) / 2; cnt++)
3500 dot = next_line(dot);
3502 case 'O': // O- open a empty line above
3504 p = begin_line(dot);
3505 if (p[-1] == '\n') {
3507 case 'o': // o- open a empty line below; Yes, I know it is in the middle of the "if (..."
3509 dot = char_insert(dot, '\n');
3512 dot = char_insert(dot, '\n'); // i\n ESC
3517 case 'R': // R- continuous Replace char
3521 case KEYCODE_DELETE:
3524 case 'X': // X- delete char before dot
3525 case 'x': // x- delete the current char
3526 case 's': // s- substitute the current char
3533 if (dot[dir] != '\n') {
3535 dot--; // delete prev char
3536 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
3539 goto dc_i; // start insrting
3540 end_cmd_q(); // stop adding to q
3542 case 'Z': // Z- if modified, {write}; exit
3543 // ZZ means to save file (if necessary), then exit
3544 c1 = get_one_char();
3549 if (file_modified) {
3550 if (ENABLE_FEATURE_VI_READONLY && readonly_mode) {
3551 status_line_bold("\"%s\" File is read only", current_filename);
3554 cnt = file_write(current_filename, text, end - 1);
3557 status_line_bold("Write error: %s", strerror(errno));
3558 } else if (cnt == (end - 1 - text + 1)) {
3565 case '^': // ^- move to first non-blank on line
3569 case 'b': // b- back a word
3570 case 'e': // e- end of word
3577 if ((dot + dir) < text || (dot + dir) > end - 1)
3580 if (isspace(*dot)) {
3581 dot = skip_thing(dot, (c == 'e') ? 2 : 1, dir, S_OVER_WS);
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);
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
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')
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)) {
3611 // don't include trailing WS as part of word
3612 while (isblank(*q)) {
3613 if (q <= text || q[-1] == '\n')
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
3627 // could not recognize object
3628 c = c1 = 27; // error-
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)) {
3639 } else if (c == 'd') {
3645 // if CHANGING, not deleting, start inserting after the delete
3647 strcpy(buf, "Change");
3648 goto dc_i; // start inserting
3651 strcpy(buf, "Delete");
3653 #if ENABLE_FEATURE_VI_YANKMARK
3654 if (c == 'y' || c == 'Y') {
3655 strcpy(buf, "Yank");
3659 for (cnt = 0; p <= q; p++) {
3663 status_line("%s %d lines (%d chars) using [%c]",
3664 buf, cnt, strlen(reg[YDreg]), what_reg());
3666 end_cmd_q(); // stop adding to q
3670 case 'k': // k- goto prev line, same col
3671 case KEYCODE_UP: // cursor key Up
3676 dot = move_to_col(dot, ccol + offset); // try stay in same col
3678 case 'r': // r- replace the current char with user input
3679 c1 = get_one_char(); // get the replacement char
3684 end_cmd_q(); // stop adding to q
3686 case 't': // t- move to char prior to next x
3687 last_forward_char = get_one_char();
3689 if (*dot == last_forward_char)
3691 last_forward_char = 0;
3693 case 'w': // w- forward a word
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);
3703 dot++; // move over word
3704 if (isspace(*dot)) {
3705 dot = skip_thing(dot, 2, FORWARD, S_OVER_WS);
3709 c1 = get_one_char(); // get the replacement char
3712 cnt = (rows - 2) / 2; // put dot at center
3714 cnt = rows - 2; // put dot at bottom
3715 screenbegin = begin_line(dot); // start dot at top
3716 dot_scroll(cnt, -1);
3718 case '|': // |- move to column "cmdcnt"
3719 dot = move_to_col(dot, cmdcnt - 1); // try to move to column
3721 case '~': // ~- flip the case of letters a-z -> A-Z
3725 if (islower(*dot)) {
3726 *dot = toupper(*dot);
3728 } else if (isupper(*dot)) {
3729 *dot = tolower(*dot);
3733 end_cmd_q(); // stop adding to q
3735 //----- The Cursor and Function Keys -----------------------------
3736 case KEYCODE_HOME: // Cursor Key Home
3739 // The Fn keys could point to do_macro which could translate them
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
3758 // if text[] just became empty, add back an empty line
3760 char_insert(text, '\n'); // start empty buf with dummy line
3763 // it is OK for dot to exactly equal to end, otherwise check dot validity
3765 dot = bound_dot(dot); // make sure "dot" is valid
3767 #if ENABLE_FEATURE_VI_YANKMARK
3768 check_context(c); // update the current context
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)
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"
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",
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",
3842 // create a random command to execute
3843 static void crash_dummy()
3845 static int sleeptime; // how long to pause between commands
3846 char c, cm, *cmd, *cmd1;
3847 int i, cnt, thing, rbi, startrbi, percent;
3849 // "dot" movement commands
3850 cmd1 = " \n\r\002\004\005\006\025\0310^$-+wWeEbBhjklHL";
3852 // is there already a command running?
3853 if (readbuffer[0] > 0)
3856 readbuffer[0] = 'X';
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
3866 } else if (percent < Np) { // non-movement commands
3867 cmd = "mz<>\'\""; // available commands
3869 } else if (percent < Dp) { // Delete commands
3870 cmd = "dx"; // available commands
3872 } else if (percent < Ip) { // Inset commands
3873 cmd = "iIaAsrJ"; // available commands
3875 } else if (percent < Yp) { // Yank commands
3876 cmd = "yY"; // available commands
3878 } else if (percent < Pp) { // Put commands
3879 cmd = "pP"; // available commands
3882 // We do not know how to handle this command, try again
3886 // randomly pick one of the available cmds from "cmd[]"
3887 i = (int) lrand48() % strlen(cmd);
3889 if (strchr(":\024", cm))
3890 goto cd0; // dont allow colon or ctrl-T commands
3891 readbuffer[rbi++] = cm; // put cmd into input buffer
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";
3901 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
3903 readbuffer[rbi++] = c; // add movement to input buffer
3905 if (strchr("iIaAsc", cm)) { // multi-char commands
3907 // change some thing
3908 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
3910 readbuffer[rbi++] = c; // add movement to input buffer
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
3929 strcat(readbuffer, "\033");
3931 readbuffer[0] = strlen(readbuffer + 1);
3935 mysleep(sleeptime); // sleep 1/100 sec
3938 // test to see if there are any errors
3939 static void crash_test()
3941 static time_t oldtim;
3948 strcat(msg, "end<text ");
3950 if (end > textend) {
3951 strcat(msg, "end>textend ");
3954 strcat(msg, "dot<text ");
3957 strcat(msg, "dot>end ");
3959 if (screenbegin < text) {
3960 strcat(msg, "screenbegin<text ");
3962 if (screenbegin > end - 1) {
3963 strcat(msg, "screenbegin>end-1 ");
3967 printf("\n\n%d: \'%c\' %s\n\n\n%s[Hit return to continue]%s",
3968 totalcmds, last_input_char, msg, SOs, SOn);
3970 while (safe_read(STDIN_FILENO, d, 1) > 0) {
3971 if (d[0] == '\n' || d[0] == '\r')
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);