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[K";
69 static const char Ceos[] ALIGN1 = "\033[J";
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 #if ENABLE_FEATURE_VI_ASK_TERMINAL
142 int get_rowcol_error;
144 int crow, ccol; // cursor is on Crow x Ccol
145 int offset; // chars scrolled off the screen to the left
146 int have_status_msg; // is default edit status needed?
147 // [don't make smallint!]
148 int last_status_cksum; // hash of current status line
149 char *current_filename;
150 char *screenbegin; // index into text[], of top line on the screen
151 char *screen; // pointer to the virtual screen buffer
152 int screensize; // and its size
154 int last_forward_char; // last char searched for with 'f' (int because of Unicode)
155 char erase_char; // the users erase character
156 char last_input_char; // last char read from user
158 #if ENABLE_FEATURE_VI_DOT_CMD
159 smallint adding2q; // are we currently adding user input to q
160 int lmc_len; // length of last_modifying_cmd
161 char *ioq, *ioq_start; // pointer to string for get_one_char to "read"
163 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
164 int last_row; // where the cursor was last moved to
166 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
169 #if ENABLE_FEATURE_VI_SEARCH
170 char *last_search_pattern; // last pattern from a '/' or '?' search
174 #if ENABLE_FEATURE_VI_YANKMARK
175 char *edit_file__cur_line;
177 int refresh__old_offset;
178 int format_edit_status__tot;
180 /* a few references only */
181 #if ENABLE_FEATURE_VI_YANKMARK
182 int YDreg, Ureg; // default delete register and orig line for "U"
183 char *reg[28]; // named register a-z, "D", and "U" 0-25,26,27
184 char *mark[28]; // user marks points somewhere in text[]- a-z and previous context ''
185 char *context_start, *context_end;
187 #if ENABLE_FEATURE_VI_USE_SIGNALS
188 sigjmp_buf restart; // catch_sig()
190 struct termios term_orig, term_vi; // remember what the cooked mode was
191 #if ENABLE_FEATURE_VI_COLON
192 char *initial_cmds[3]; // currently 2 entries, NULL terminated
194 // Should be just enough to hold a key sequence,
195 // but CRASHME mode uses it as generated command buffer too
196 #if ENABLE_FEATURE_VI_CRASHME
197 char readbuffer[128];
199 char readbuffer[KEYCODE_BUFFER_SIZE];
201 #define STATUS_BUFFER_LEN 200
202 char status_buffer[STATUS_BUFFER_LEN]; // messages to the user
203 #if ENABLE_FEATURE_VI_DOT_CMD
204 char last_modifying_cmd[MAX_INPUT_LEN]; // last modifying cmd for "."
206 char get_input_line__buf[MAX_INPUT_LEN]; /* former static */
208 char scr_out_buf[MAX_SCR_COLS + MAX_TABSTOP * 2];
210 #define G (*ptr_to_globals)
211 #define text (G.text )
212 #define text_size (G.text_size )
217 #define vi_setops (G.vi_setops )
218 #define editing (G.editing )
219 #define cmd_mode (G.cmd_mode )
220 #define file_modified (G.file_modified )
221 #define last_file_modified (G.last_file_modified )
222 #define fn_start (G.fn_start )
223 #define save_argc (G.save_argc )
224 #define cmdcnt (G.cmdcnt )
225 #define rows (G.rows )
226 #define columns (G.columns )
227 #define crow (G.crow )
228 #define ccol (G.ccol )
229 #define offset (G.offset )
230 #define status_buffer (G.status_buffer )
231 #define have_status_msg (G.have_status_msg )
232 #define last_status_cksum (G.last_status_cksum )
233 #define current_filename (G.current_filename )
234 #define screen (G.screen )
235 #define screensize (G.screensize )
236 #define screenbegin (G.screenbegin )
237 #define tabstop (G.tabstop )
238 #define last_forward_char (G.last_forward_char )
239 #define erase_char (G.erase_char )
240 #define last_input_char (G.last_input_char )
241 #if ENABLE_FEATURE_VI_READONLY
242 #define readonly_mode (G.readonly_mode )
244 #define readonly_mode 0
246 #define adding2q (G.adding2q )
247 #define lmc_len (G.lmc_len )
249 #define ioq_start (G.ioq_start )
250 #define last_row (G.last_row )
251 #define my_pid (G.my_pid )
252 #define last_search_pattern (G.last_search_pattern)
254 #define edit_file__cur_line (G.edit_file__cur_line)
255 #define refresh__old_offset (G.refresh__old_offset)
256 #define format_edit_status__tot (G.format_edit_status__tot)
258 #define YDreg (G.YDreg )
259 #define Ureg (G.Ureg )
260 #define mark (G.mark )
261 #define context_start (G.context_start )
262 #define context_end (G.context_end )
263 #define restart (G.restart )
264 #define term_orig (G.term_orig )
265 #define term_vi (G.term_vi )
266 #define initial_cmds (G.initial_cmds )
267 #define readbuffer (G.readbuffer )
268 #define scr_out_buf (G.scr_out_buf )
269 #define last_modifying_cmd (G.last_modifying_cmd )
270 #define get_input_line__buf (G.get_input_line__buf)
272 #define INIT_G() do { \
273 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
274 last_file_modified = -1; \
275 /* "" but has space for 2 chars: */ \
276 IF_FEATURE_VI_SEARCH(last_search_pattern = xzalloc(2);) \
280 static int init_text_buffer(char *); // init from file or create new
281 static void edit_file(char *); // edit one file
282 static void do_cmd(int); // execute a command
283 static int next_tabstop(int);
284 static void sync_cursor(char *, int *, int *); // synchronize the screen cursor to dot
285 static char *begin_line(char *); // return pointer to cur line B-o-l
286 static char *end_line(char *); // return pointer to cur line E-o-l
287 static char *prev_line(char *); // return pointer to prev line B-o-l
288 static char *next_line(char *); // return pointer to next line B-o-l
289 static char *end_screen(void); // get pointer to last char on screen
290 static int count_lines(char *, char *); // count line from start to stop
291 static char *find_line(int); // find begining of line #li
292 static char *move_to_col(char *, int); // move "p" to column l
293 static void dot_left(void); // move dot left- dont leave line
294 static void dot_right(void); // move dot right- dont leave line
295 static void dot_begin(void); // move dot to B-o-l
296 static void dot_end(void); // move dot to E-o-l
297 static void dot_next(void); // move dot to next line B-o-l
298 static void dot_prev(void); // move dot to prev line B-o-l
299 static void dot_scroll(int, int); // move the screen up or down
300 static void dot_skip_over_ws(void); // move dot pat WS
301 static void dot_delete(void); // delete the char at 'dot'
302 static char *bound_dot(char *); // make sure text[0] <= P < "end"
303 static char *new_screen(int, int); // malloc virtual screen memory
304 static char *char_insert(char *, char); // insert the char c at 'p'
305 // might reallocate text[]! use p += stupid_insert(p, ...),
306 // and be careful to not use pointers into potentially freed text[]!
307 static uintptr_t stupid_insert(char *, char); // stupidly insert the char c at 'p'
308 static int find_range(char **, char **, char); // return pointers for an object
309 static int st_test(char *, int, int, char *); // helper for skip_thing()
310 static char *skip_thing(char *, int, int, int); // skip some object
311 static char *find_pair(char *, char); // find matching pair () [] {}
312 static char *text_hole_delete(char *, char *); // at "p", delete a 'size' byte hole
313 // might reallocate text[]! use p += text_hole_make(p, ...),
314 // and be careful to not use pointers into potentially freed text[]!
315 static uintptr_t text_hole_make(char *, int); // at "p", make a 'size' byte hole
316 static char *yank_delete(char *, char *, int, int); // yank text[] into register then delete
317 static void show_help(void); // display some help info
318 static void rawmode(void); // set "raw" mode on tty
319 static void cookmode(void); // return to "cooked" mode on tty
320 // sleep for 'h' 1/100 seconds, return 1/0 if stdin is (ready for read)/(not ready)
321 static int mysleep(int);
322 static int readit(void); // read (maybe cursor) key from stdin
323 static int get_one_char(void); // read 1 char from stdin
324 static int file_size(const char *); // what is the byte size of "fn"
325 #if !ENABLE_FEATURE_VI_READONLY
326 #define file_insert(fn, p, update_ro_status) file_insert(fn, p)
328 // file_insert might reallocate text[]!
329 static int file_insert(const char *, char *, int);
330 static int file_write(char *, char *, char *);
331 #if !ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
332 #define place_cursor(a, b, optimize) place_cursor(a, b)
334 static void place_cursor(int, int, int);
335 static void screen_erase(void);
336 static void clear_to_eol(void);
337 static void clear_to_eos(void);
338 static void go_bottom_and_clear_to_eol(void);
339 static void standout_start(void); // send "start reverse video" sequence
340 static void standout_end(void); // send "end reverse video" sequence
341 static void flash(int); // flash the terminal screen
342 static void show_status_line(void); // put a message on the bottom line
343 static void status_line(const char *, ...); // print to status buf
344 static void status_line_bold(const char *, ...);
345 static void not_implemented(const char *); // display "Not implemented" message
346 static int format_edit_status(void); // format file status on status line
347 static void redraw(int); // force a full screen refresh
348 static char* format_line(char* /*, int*/);
349 static void refresh(int); // update the terminal from screen[]
351 static void Indicate_Error(void); // use flash or beep to indicate error
352 #define indicate_error(c) Indicate_Error()
353 static void Hit_Return(void);
355 #if ENABLE_FEATURE_VI_SEARCH
356 static char *char_search(char *, const char *, int, int); // search for pattern starting at p
357 static int mycmp(const char *, const char *, int); // string cmp based in "ignorecase"
359 #if ENABLE_FEATURE_VI_COLON
360 static char *get_one_address(char *, int *); // get colon addr, if present
361 static char *get_address(char *, int *, int *); // get two colon addrs, if present
362 static void colon(char *); // execute the "colon" mode cmds
364 #if ENABLE_FEATURE_VI_USE_SIGNALS
365 static void winch_sig(int); // catch window size changes
366 static void suspend_sig(int); // catch ctrl-Z
367 static void catch_sig(int); // catch ctrl-C and alarm time-outs
369 #if ENABLE_FEATURE_VI_DOT_CMD
370 static void start_new_cmd_q(char); // new queue for command
371 static void end_cmd_q(void); // stop saving input chars
373 #define end_cmd_q() ((void)0)
375 #if ENABLE_FEATURE_VI_SETOPTS
376 static void showmatching(char *); // show the matching pair () [] {}
378 #if ENABLE_FEATURE_VI_YANKMARK || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) || ENABLE_FEATURE_VI_CRASHME
379 // might reallocate text[]! use p += string_insert(p, ...),
380 // and be careful to not use pointers into potentially freed text[]!
381 static uintptr_t string_insert(char *, const char *); // insert the string at 'p'
383 #if ENABLE_FEATURE_VI_YANKMARK
384 static char *text_yank(char *, char *, int); // save copy of "p" into a register
385 static char what_reg(void); // what is letter of current YDreg
386 static void check_context(char); // remember context for '' command
388 #if ENABLE_FEATURE_VI_CRASHME
389 static void crash_dummy();
390 static void crash_test();
391 static int crashme = 0;
395 static void write1(const char *out)
400 int vi_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
401 int vi_main(int argc, char **argv)
407 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
410 #if ENABLE_FEATURE_VI_CRASHME
411 srand((long) my_pid);
413 #ifdef NO_SUCH_APPLET_YET
414 /* If we aren't "vi", we are "view" */
415 if (ENABLE_FEATURE_VI_READONLY && applet_name[2]) {
416 SET_READONLY_MODE(readonly_mode);
420 vi_setops = VI_AUTOINDENT | VI_SHOWMATCH | VI_IGNORECASE;
421 // 1- process $HOME/.exrc file (not inplemented yet)
422 // 2- process EXINIT variable from environment
423 // 3- process command line args
424 #if ENABLE_FEATURE_VI_COLON
426 char *p = getenv("EXINIT");
428 initial_cmds[0] = xstrndup(p, MAX_INPUT_LEN);
431 while ((c = getopt(argc, argv, "hCRH" IF_FEATURE_VI_COLON("c:"))) != -1) {
433 #if ENABLE_FEATURE_VI_CRASHME
438 #if ENABLE_FEATURE_VI_READONLY
439 case 'R': // Read-only flag
440 SET_READONLY_MODE(readonly_mode);
443 #if ENABLE_FEATURE_VI_COLON
444 case 'c': // cmd line vi command
446 initial_cmds[initial_cmds[0] != 0] = xstrndup(optarg, MAX_INPUT_LEN);
458 // The argv array can be used by the ":next" and ":rewind" commands
460 fn_start = optind; // remember first file name for :next and :rew
463 //----- This is the main file handling loop --------------
465 edit_file(argv[optind]); /* param might be NULL */
466 if (++optind >= argc)
469 //-----------------------------------------------------------
474 /* read text from file or create an empty buf */
475 /* will also update current_filename */
476 static int init_text_buffer(char *fn)
479 int size = file_size(fn); // file size. -1 means does not exist.
481 /* allocate/reallocate text buffer */
483 text_size = size + 10240;
484 screenbegin = dot = end = text = xzalloc(text_size);
486 if (fn != current_filename) {
487 free(current_filename);
488 current_filename = xstrdup(fn);
491 // file dont exist. Start empty buf with dummy line
492 char_insert(text, '\n');
495 rc = file_insert(fn, text, 1);
498 last_file_modified = -1;
499 #if ENABLE_FEATURE_VI_YANKMARK
500 /* init the marks. */
501 memset(mark, 0, sizeof(mark));
506 #if ENABLE_FEATURE_VI_WIN_RESIZE
507 static void query_screen_dimensions(void)
509 # if ENABLE_FEATURE_VI_ASK_TERMINAL
510 if (!G.get_rowcol_error)
513 get_terminal_width_height(STDIN_FILENO, &columns, &rows);
514 if (rows > MAX_SCR_ROWS)
516 if (columns > MAX_SCR_COLS)
517 columns = MAX_SCR_COLS;
520 # define query_screen_dimensions() ((void)0)
523 static void edit_file(char *fn)
525 #if ENABLE_FEATURE_VI_YANKMARK
526 #define cur_line edit_file__cur_line
530 #if ENABLE_FEATURE_VI_USE_SIGNALS
534 editing = 1; // 0 = exit, 1 = one file, 2 = multiple files
539 query_screen_dimensions();
540 #if ENABLE_FEATURE_VI_ASK_TERMINAL
541 if (G.get_rowcol_error /* TODO? && no input on stdin */) {
543 write1("\033[999;999H" "\033[6n");
545 k = read_key(STDIN_FILENO, readbuffer, /*timeout_ms:*/ 100);
546 if ((int32_t)k == KEYCODE_CURSOR_POS) {
547 uint32_t rc = (k >> 32);
548 columns = (rc & 0x7fff);
549 rows = ((rc >> 16) & 0x7fff);
551 query_screen_dimensions();
554 new_screen(rows, columns); // get memory for virtual screen
555 init_text_buffer(fn);
557 #if ENABLE_FEATURE_VI_YANKMARK
558 YDreg = 26; // default Yank/Delete reg
559 Ureg = 27; // hold orig line for "U" cmd
560 mark[26] = mark[27] = text; // init "previous context"
563 last_forward_char = last_input_char = '\0';
567 #if ENABLE_FEATURE_VI_USE_SIGNALS
568 signal(SIGINT, catch_sig);
569 signal(SIGWINCH, winch_sig);
570 signal(SIGTSTP, suspend_sig);
571 sig = sigsetjmp(restart, 1);
573 screenbegin = dot = text;
577 cmd_mode = 0; // 0=command 1=insert 2='R'eplace
580 offset = 0; // no horizontal offset
582 #if ENABLE_FEATURE_VI_DOT_CMD
584 ioq = ioq_start = NULL;
589 #if ENABLE_FEATURE_VI_COLON
594 while ((p = initial_cmds[n]) != NULL) {
604 free(initial_cmds[n]);
605 initial_cmds[n] = NULL;
610 redraw(FALSE); // dont force every col re-draw
611 //------This is the main Vi cmd handling loop -----------------------
612 while (editing > 0) {
613 #if ENABLE_FEATURE_VI_CRASHME
615 if ((end - text) > 1) {
616 crash_dummy(); // generate a random command
619 string_insert(text, "\n\n##### Ran out of text to work on. #####\n\n"); // insert the string
625 last_input_char = c = get_one_char(); // get a cmd from user
626 #if ENABLE_FEATURE_VI_YANKMARK
627 // save a copy of the current line- for the 'U" command
628 if (begin_line(dot) != cur_line) {
629 cur_line = begin_line(dot);
630 text_yank(begin_line(dot), end_line(dot), Ureg);
633 #if ENABLE_FEATURE_VI_DOT_CMD
634 // These are commands that change text[].
635 // Remember the input for the "." command
636 if (!adding2q && ioq_start == NULL
637 && cmd_mode == 0 // command mode
638 && c > '\0' // exclude NUL and non-ASCII chars
639 && c < 0x7f // (Unicode and such)
640 && strchr(modifying_cmds, c)
645 do_cmd(c); // execute the user command
647 // poll to see if there is input already waiting. if we are
648 // not able to display output fast enough to keep up, skip
649 // the display update until we catch up with input.
650 if (!readbuffer[0] && mysleep(0) == 0) {
651 // no input pending - so update output
655 #if ENABLE_FEATURE_VI_CRASHME
657 crash_test(); // test editor variables
660 //-------------------------------------------------------------------
662 go_bottom_and_clear_to_eol();
667 //----- The Colon commands -------------------------------------
668 #if ENABLE_FEATURE_VI_COLON
669 static char *get_one_address(char *p, int *addr) // get colon addr, if present
673 IF_FEATURE_VI_YANKMARK(char c;)
674 IF_FEATURE_VI_SEARCH(char *pat;)
676 *addr = -1; // assume no addr
677 if (*p == '.') { // the current line
680 *addr = count_lines(text, q);
682 #if ENABLE_FEATURE_VI_YANKMARK
683 else if (*p == '\'') { // is this a mark addr
687 if (c >= 'a' && c <= 'z') {
690 q = mark[(unsigned char) c];
691 if (q != NULL) { // is mark valid
692 *addr = count_lines(text, q);
697 #if ENABLE_FEATURE_VI_SEARCH
698 else if (*p == '/') { // a search pattern
699 q = strchrnul(++p, '/');
700 pat = xstrndup(p, q - p); // save copy of pattern
704 q = char_search(dot, pat, FORWARD, FULL);
706 *addr = count_lines(text, q);
711 else if (*p == '$') { // the last line in file
713 q = begin_line(end - 1);
714 *addr = count_lines(text, q);
715 } else if (isdigit(*p)) { // specific line number
716 sscanf(p, "%d%n", addr, &st);
719 // unrecognized address - assume -1
725 static char *get_address(char *p, int *b, int *e) // get two colon addrs, if present
727 //----- get the address' i.e., 1,3 'a,'b -----
728 // get FIRST addr, if present
730 p++; // skip over leading spaces
731 if (*p == '%') { // alias for 1,$
734 *e = count_lines(text, end-1);
737 p = get_one_address(p, b);
740 if (*p == ',') { // is there a address separator
744 // get SECOND addr, if present
745 p = get_one_address(p, e);
749 p++; // skip over trailing spaces
753 #if ENABLE_FEATURE_VI_SET && ENABLE_FEATURE_VI_SETOPTS
754 static void setops(const char *args, const char *opname, int flg_no,
755 const char *short_opname, int opt)
757 const char *a = args + flg_no;
758 int l = strlen(opname) - 1; /* opname have + ' ' */
760 // maybe strncmp? we had tons of erroneous strncasecmp's...
761 if (strncasecmp(a, opname, l) == 0
762 || strncasecmp(a, short_opname, 2) == 0
772 // buf must be no longer than MAX_INPUT_LEN!
773 static void colon(char *buf)
775 char c, *orig_buf, *buf1, *q, *r;
776 char *fn, cmd[MAX_INPUT_LEN], args[MAX_INPUT_LEN];
777 int i, l, li, ch, b, e;
778 int useforce, forced = FALSE;
780 // :3154 // if (-e line 3154) goto it else stay put
781 // :4,33w! foo // write a portion of buffer to file "foo"
782 // :w // write all of buffer to current file
784 // :q! // quit- dont care about modified file
785 // :'a,'z!sort -u // filter block through sort
786 // :'f // goto mark "f"
787 // :'fl // list literal the mark "f" line
788 // :.r bar // read file "bar" into buffer before dot
789 // :/123/,/abc/d // delete lines from "123" line to "abc" line
790 // :/xyz/ // goto the "xyz" line
791 // :s/find/replace/ // substitute pattern "find" with "replace"
792 // :!<cmd> // run <cmd> then return
798 buf++; // move past the ':'
802 q = text; // assume 1,$ for the range
804 li = count_lines(text, end - 1);
805 fn = current_filename;
807 // look for optional address(es) :. :1 :1,9 :'q,'a :%
808 buf = get_address(buf, &b, &e);
810 // remember orig command line
813 // get the COMMAND into cmd[]
815 while (*buf != '\0') {
822 while (isblank(*buf))
826 buf1 = last_char_is(cmd, '!');
829 *buf1 = '\0'; // get rid of !
832 // if there is only one addr, then the addr
833 // is the line number of the single line the
834 // user wants. So, reset the end
835 // pointer to point at end of the "b" line
836 q = find_line(b); // what line is #b
841 // we were given two addrs. change the
842 // end pointer to the addr given by user.
843 r = find_line(e); // what line is #e
847 // ------------ now look for the command ------------
849 if (i == 0) { // :123CR goto line #123
851 dot = find_line(b); // what line is #b
855 #if ENABLE_FEATURE_ALLOW_EXEC
856 else if (cmd[0] == '!') { // run a cmd
858 // :!ls run the <cmd>
859 go_bottom_and_clear_to_eol();
861 retcode = system(orig_buf + 1); // run the cmd
863 printf("\nshell returned %i\n\n", retcode);
865 Hit_Return(); // let user see results
868 else if (cmd[0] == '=' && !cmd[1]) { // where is the address
869 if (b < 0) { // no addr given- use defaults
870 b = e = count_lines(text, dot);
872 status_line("%d", b);
873 } else if (strncmp(cmd, "delete", i) == 0) { // delete lines
874 if (b < 0) { // no addr given- use defaults
875 q = begin_line(dot); // assume .,. for the range
878 dot = yank_delete(q, r, 1, YANKDEL); // save, then delete lines
880 } else if (strncmp(cmd, "edit", i) == 0) { // Edit a file
881 // don't edit, if the current file has been modified
882 if (file_modified && !useforce) {
883 status_line_bold("No write since last change (:edit! overrides)");
887 // the user supplied a file name
889 } else if (current_filename && current_filename[0]) {
890 // no user supplied name- use the current filename
891 // fn = current_filename; was set by default
893 // no user file name, no current name- punt
894 status_line_bold("No current filename");
898 if (init_text_buffer(fn) < 0)
901 #if ENABLE_FEATURE_VI_YANKMARK
902 if (Ureg >= 0 && Ureg < 28 && reg[Ureg] != 0) {
903 free(reg[Ureg]); // free orig line reg- for 'U'
906 if (YDreg >= 0 && YDreg < 28 && reg[YDreg] != 0) {
907 free(reg[YDreg]); // free default yank/delete register
911 // how many lines in text[]?
912 li = count_lines(text, end - 1);
913 status_line("\"%s\"%s"
914 IF_FEATURE_VI_READONLY("%s")
915 " %dL, %dC", current_filename,
916 (file_size(fn) < 0 ? " [New file]" : ""),
917 IF_FEATURE_VI_READONLY(
918 ((readonly_mode) ? " [Readonly]" : ""),
921 } else if (strncmp(cmd, "file", i) == 0) { // what File is this
922 if (b != -1 || e != -1) {
923 status_line_bold("No address allowed on this command");
927 // user wants a new filename
928 free(current_filename);
929 current_filename = xstrdup(args);
931 // user wants file status info
932 last_status_cksum = 0; // force status update
934 } else if (strncmp(cmd, "features", i) == 0) { // what features are available
935 // print out values of all features
936 go_bottom_and_clear_to_eol();
941 } else if (strncmp(cmd, "list", i) == 0) { // literal print line
942 if (b < 0) { // no addr given- use defaults
943 q = begin_line(dot); // assume .,. for the range
946 go_bottom_and_clear_to_eol();
948 for (; q <= r; q++) {
952 c_is_no_print = (c & 0x80) && !Isprint(c);
959 } else if (c < ' ' || c == 127) {
970 #if ENABLE_FEATURE_VI_SET
974 } else if (strncmp(cmd, "quit", i) == 0 // Quit
975 || strncmp(cmd, "next", i) == 0 // edit next file
979 // force end of argv list
986 // don't exit if the file been modified
988 status_line_bold("No write since last change (:%s! overrides)",
989 (*cmd == 'q' ? "quit" : "next"));
992 // are there other file to edit
993 n = save_argc - optind - 1;
994 if (*cmd == 'q' && n > 0) {
995 status_line_bold("%d more file(s) to edit", n);
998 if (*cmd == 'n' && n <= 0) {
999 status_line_bold("No more files to edit");
1003 } else if (strncmp(cmd, "read", i) == 0) { // read file into text[]
1006 status_line_bold("No filename given");
1009 if (b < 0) { // no addr given- use defaults
1010 q = begin_line(dot); // assume "dot"
1012 // read after current line- unless user said ":0r foo"
1015 { // dance around potentially-reallocated text[]
1016 uintptr_t ofs = q - text;
1017 ch = file_insert(fn, q, 0);
1021 goto vc1; // nothing was inserted
1022 // how many lines in text[]?
1023 li = count_lines(q, q + ch - 1);
1024 status_line("\"%s\""
1025 IF_FEATURE_VI_READONLY("%s")
1027 IF_FEATURE_VI_READONLY((readonly_mode ? " [Readonly]" : ""),)
1030 // if the insert is before "dot" then we need to update
1033 /*file_modified++; - done by file_insert */
1035 } else if (strncmp(cmd, "rewind", i) == 0) { // rewind cmd line args
1036 if (file_modified && !useforce) {
1037 status_line_bold("No write since last change (:rewind! overrides)");
1039 // reset the filenames to edit
1040 optind = fn_start - 1;
1043 #if ENABLE_FEATURE_VI_SET
1044 } else if (strncmp(cmd, "set", i) == 0) { // set or clear features
1045 #if ENABLE_FEATURE_VI_SETOPTS
1048 i = 0; // offset into args
1049 // only blank is regarded as args delmiter. What about tab '\t' ?
1050 if (!args[0] || strcasecmp(args, "all") == 0) {
1051 // print out values of all options
1052 go_bottom_and_clear_to_eol();
1053 printf("----------------------------------------\r\n");
1054 #if ENABLE_FEATURE_VI_SETOPTS
1057 printf("autoindent ");
1063 printf("ignorecase ");
1066 printf("showmatch ");
1067 printf("tabstop=%d ", tabstop);
1072 #if ENABLE_FEATURE_VI_SETOPTS
1075 if (strncmp(argp, "no", 2) == 0)
1076 i = 2; // ":set noautoindent"
1077 setops(argp, "autoindent ", i, "ai", VI_AUTOINDENT);
1078 setops(argp, "flash ", i, "fl", VI_ERR_METHOD);
1079 setops(argp, "ignorecase ", i, "ic", VI_IGNORECASE);
1080 setops(argp, "showmatch ", i, "ic", VI_SHOWMATCH);
1082 if (strncmp(argp + i, "tabstop=%d ", 7) == 0) {
1083 sscanf(strchr(argp + i, '='), "tabstop=%d" + 7, &ch);
1084 if (ch > 0 && ch <= MAX_TABSTOP)
1087 while (*argp && *argp != ' ')
1088 argp++; // skip to arg delimiter (i.e. blank)
1089 while (*argp && *argp == ' ')
1090 argp++; // skip all delimiting blanks
1092 #endif /* FEATURE_VI_SETOPTS */
1093 #endif /* FEATURE_VI_SET */
1094 #if ENABLE_FEATURE_VI_SEARCH
1095 } else if (cmd[0] == 's') { // substitute a pattern with a replacement pattern
1099 // F points to the "find" pattern
1100 // R points to the "replace" pattern
1101 // replace the cmd line delimiters "/" with NULLs
1102 gflag = 0; // global replace flag
1103 c = orig_buf[1]; // what is the delimiter
1104 F = orig_buf + 2; // start of "find"
1105 R = strchr(F, c); // middle delimiter
1108 *R++ = '\0'; // terminate "find"
1109 buf1 = strchr(R, c);
1112 *buf1++ = '\0'; // terminate "replace"
1113 if (*buf1 == 'g') { // :s/foo/bar/g
1115 gflag++; // turn on gflag
1118 if (b < 0) { // maybe :s/foo/bar/
1119 q = begin_line(dot); // start with cur line
1120 b = count_lines(text, q); // cur line number
1123 e = b; // maybe :.s/foo/bar/
1124 for (i = b; i <= e; i++) { // so, :20,23 s \0 find \0 replace \0
1125 ls = q; // orig line start
1127 buf1 = char_search(q, F, FORWARD, LIMITED); // search cur line only for "find"
1130 // we found the "find" pattern - delete it
1131 text_hole_delete(buf1, buf1 + strlen(F) - 1);
1132 // inset the "replace" patern
1133 bias = string_insert(buf1, R); // insert the string
1136 /*q += bias; - recalculated anyway */
1137 // check for "global" :s/foo/bar/g
1139 if ((buf1 + strlen(R)) < end_line(ls)) {
1140 q = buf1 + strlen(R);
1141 goto vc4; // don't let q move past cur line
1147 #endif /* FEATURE_VI_SEARCH */
1148 } else if (strncmp(cmd, "version", i) == 0) { // show software version
1149 status_line(BB_VER " " BB_BT);
1150 } else if (strncmp(cmd, "write", i) == 0 // write text to file
1151 || strncmp(cmd, "wq", i) == 0
1152 || strncmp(cmd, "wn", i) == 0
1153 || (cmd[0] == 'x' && !cmd[1])
1155 // is there a file name to write to?
1159 #if ENABLE_FEATURE_VI_READONLY
1160 if (readonly_mode && !useforce) {
1161 status_line_bold("\"%s\" File is read only", fn);
1165 // how many lines in text[]?
1166 li = count_lines(q, r);
1168 // see if file exists- if not, its just a new file request
1170 // if "fn" is not write-able, chmod u+w
1171 // sprintf(syscmd, "chmod u+w %s", fn);
1175 l = file_write(fn, q, r);
1176 if (useforce && forced) {
1178 // sprintf(syscmd, "chmod u-w %s", fn);
1184 status_line_bold("\"%s\" %s", fn, strerror(errno));
1186 status_line("\"%s\" %dL, %dC", fn, li, l);
1187 if (q == text && r == end - 1 && l == ch) {
1189 last_file_modified = -1;
1191 if ((cmd[0] == 'x' || cmd[1] == 'q' || cmd[1] == 'n'
1192 || cmd[0] == 'X' || cmd[1] == 'Q' || cmd[1] == 'N'
1199 #if ENABLE_FEATURE_VI_READONLY
1202 #if ENABLE_FEATURE_VI_YANKMARK
1203 } else if (strncmp(cmd, "yank", i) == 0) { // yank lines
1204 if (b < 0) { // no addr given- use defaults
1205 q = begin_line(dot); // assume .,. for the range
1208 text_yank(q, r, YDreg);
1209 li = count_lines(q, r);
1210 status_line("Yank %d lines (%d chars) into [%c]",
1211 li, strlen(reg[YDreg]), what_reg());
1215 not_implemented(cmd);
1218 dot = bound_dot(dot); // make sure "dot" is valid
1220 #if ENABLE_FEATURE_VI_SEARCH
1222 status_line(":s expression missing delimiters");
1226 #endif /* FEATURE_VI_COLON */
1228 static void Hit_Return(void)
1233 write1("[Hit return to continue]");
1235 while ((c = get_one_char()) != '\n' && c != '\r')
1237 redraw(TRUE); // force redraw all
1240 static int next_tabstop(int col)
1242 return col + ((tabstop - 1) - (col % tabstop));
1245 //----- Synchronize the cursor to Dot --------------------------
1246 static NOINLINE void sync_cursor(char *d, int *row, int *col)
1248 char *beg_cur; // begin and end of "d" line
1252 beg_cur = begin_line(d); // first char of cur line
1254 if (beg_cur < screenbegin) {
1255 // "d" is before top line on screen
1256 // how many lines do we have to move
1257 cnt = count_lines(beg_cur, screenbegin);
1259 screenbegin = beg_cur;
1260 if (cnt > (rows - 1) / 2) {
1261 // we moved too many lines. put "dot" in middle of screen
1262 for (cnt = 0; cnt < (rows - 1) / 2; cnt++) {
1263 screenbegin = prev_line(screenbegin);
1267 char *end_scr; // begin and end of screen
1268 end_scr = end_screen(); // last char of screen
1269 if (beg_cur > end_scr) {
1270 // "d" is after bottom line on screen
1271 // how many lines do we have to move
1272 cnt = count_lines(end_scr, beg_cur);
1273 if (cnt > (rows - 1) / 2)
1274 goto sc1; // too many lines
1275 for (ro = 0; ro < cnt - 1; ro++) {
1276 // move screen begin the same amount
1277 screenbegin = next_line(screenbegin);
1278 // now, move the end of screen
1279 end_scr = next_line(end_scr);
1280 end_scr = end_line(end_scr);
1284 // "d" is on screen- find out which row
1286 for (ro = 0; ro < rows - 1; ro++) { // drive "ro" to correct row
1292 // find out what col "d" is on
1294 while (tp < d) { // drive "co" to correct column
1295 if (*tp == '\n') //vda || *tp == '\0')
1298 // handle tabs like real vi
1299 if (d == tp && cmd_mode) {
1302 co = next_tabstop(co);
1303 } else if ((unsigned char)*tp < ' ' || *tp == 0x7f) {
1304 co++; // display as ^X, use 2 columns
1310 // "co" is the column where "dot" is.
1311 // The screen has "columns" columns.
1312 // The currently displayed columns are 0+offset -- columns+ofset
1313 // |-------------------------------------------------------------|
1315 // offset | |------- columns ----------------|
1317 // If "co" is already in this range then we do not have to adjust offset
1318 // but, we do have to subtract the "offset" bias from "co".
1319 // If "co" is outside this range then we have to change "offset".
1320 // If the first char of a line is a tab the cursor will try to stay
1321 // in column 7, but we have to set offset to 0.
1323 if (co < 0 + offset) {
1326 if (co >= columns + offset) {
1327 offset = co - columns + 1;
1329 // if the first char of the line is a tab, and "dot" is sitting on it
1330 // force offset to 0.
1331 if (d == beg_cur && *d == '\t') {
1340 //----- Text Movement Routines ---------------------------------
1341 static char *begin_line(char *p) // return pointer to first char cur line
1344 p = memrchr(text, '\n', p - text);
1352 static char *end_line(char *p) // return pointer to NL of cur line
1355 p = memchr(p, '\n', end - p - 1);
1362 static char *dollar_line(char *p) // return pointer to just before NL line
1365 // Try to stay off of the Newline
1366 if (*p == '\n' && (p - begin_line(p)) > 0)
1371 static char *prev_line(char *p) // return pointer first char prev line
1373 p = begin_line(p); // goto begining of cur line
1374 if (p > text && p[-1] == '\n')
1375 p--; // step to prev line
1376 p = begin_line(p); // goto begining of prev line
1380 static char *next_line(char *p) // return pointer first char next line
1383 if (p < end - 1 && *p == '\n')
1384 p++; // step to next line
1388 //----- Text Information Routines ------------------------------
1389 static char *end_screen(void)
1394 // find new bottom line
1396 for (cnt = 0; cnt < rows - 2; cnt++)
1402 // count line from start to stop
1403 static int count_lines(char *start, char *stop)
1408 if (stop < start) { // start and stop are backwards- reverse them
1414 stop = end_line(stop);
1415 while (start <= stop && start <= end - 1) {
1416 start = end_line(start);
1424 static char *find_line(int li) // find begining of line #li
1428 for (q = text; li > 1; li--) {
1434 //----- Dot Movement Routines ----------------------------------
1435 static void dot_left(void)
1437 if (dot > text && dot[-1] != '\n')
1441 static void dot_right(void)
1443 if (dot < end - 1 && *dot != '\n')
1447 static void dot_begin(void)
1449 dot = begin_line(dot); // return pointer to first char cur line
1452 static void dot_end(void)
1454 dot = end_line(dot); // return pointer to last char cur line
1457 static char *move_to_col(char *p, int l)
1463 while (co < l && p < end) {
1464 if (*p == '\n') //vda || *p == '\0')
1467 co = next_tabstop(co);
1468 } else if (*p < ' ' || *p == 127) {
1469 co++; // display as ^X, use 2 columns
1477 static void dot_next(void)
1479 dot = next_line(dot);
1482 static void dot_prev(void)
1484 dot = prev_line(dot);
1487 static void dot_scroll(int cnt, int dir)
1491 for (; cnt > 0; cnt--) {
1494 // ctrl-Y scroll up one line
1495 screenbegin = prev_line(screenbegin);
1498 // ctrl-E scroll down one line
1499 screenbegin = next_line(screenbegin);
1502 // make sure "dot" stays on the screen so we dont scroll off
1503 if (dot < screenbegin)
1505 q = end_screen(); // find new bottom line
1507 dot = begin_line(q); // is dot is below bottom line?
1511 static void dot_skip_over_ws(void)
1514 while (isspace(*dot) && *dot != '\n' && dot < end - 1)
1518 static void dot_delete(void) // delete the char at 'dot'
1520 text_hole_delete(dot, dot);
1523 static char *bound_dot(char *p) // make sure text[0] <= P < "end"
1525 if (p >= end && end > text) {
1527 indicate_error('1');
1531 indicate_error('2');
1536 //----- Helper Utility Routines --------------------------------
1538 //----------------------------------------------------------------
1539 //----- Char Routines --------------------------------------------
1540 /* Chars that are part of a word-
1541 * 0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
1542 * Chars that are Not part of a word (stoppers)
1543 * !"#$%&'()*+,-./:;<=>?@[\]^`{|}~
1544 * Chars that are WhiteSpace
1545 * TAB NEWLINE VT FF RETURN SPACE
1546 * DO NOT COUNT NEWLINE AS WHITESPACE
1549 static char *new_screen(int ro, int co)
1554 screensize = ro * co + 8;
1555 screen = xmalloc(screensize);
1556 // initialize the new screen. assume this will be a empty file.
1558 // non-existent text[] lines start with a tilde (~).
1559 for (li = 1; li < ro - 1; li++) {
1560 screen[(li * co) + 0] = '~';
1565 #if ENABLE_FEATURE_VI_SEARCH
1566 static int mycmp(const char *s1, const char *s2, int len)
1568 if (ENABLE_FEATURE_VI_SETOPTS && ignorecase) {
1569 return strncasecmp(s1, s2, len);
1571 return strncmp(s1, s2, len);
1574 // search for pattern starting at p
1575 static char *char_search(char *p, const char *pat, int dir, int range)
1577 #ifndef REGEX_SEARCH
1582 if (dir == FORWARD) {
1583 stop = end - 1; // assume range is p - end-1
1584 if (range == LIMITED)
1585 stop = next_line(p); // range is to next line
1586 for (start = p; start < stop; start++) {
1587 if (mycmp(start, pat, len) == 0) {
1591 } else if (dir == BACK) {
1592 stop = text; // assume range is text - p
1593 if (range == LIMITED)
1594 stop = prev_line(p); // range is to prev line
1595 for (start = p - len; start >= stop; start--) {
1596 if (mycmp(start, pat, len) == 0) {
1601 // pattern not found
1603 #else /* REGEX_SEARCH */
1605 struct re_pattern_buffer preg;
1609 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1615 // assume a LIMITED forward search
1623 // count the number of chars to search over, forward or backward
1627 // RANGE could be negative if we are searching backwards
1630 q = re_compile_pattern(pat, strlen(pat), &preg);
1632 // The pattern was not compiled
1633 status_line_bold("bad search pattern: \"%s\": %s", pat, q);
1634 i = 0; // return p if pattern not compiled
1644 // search for the compiled pattern, preg, in p[]
1645 // range < 0- search backward
1646 // range > 0- search forward
1648 // re_search() < 0 not found or error
1649 // re_search() > 0 index of found pattern
1650 // struct pattern char int int int struct reg
1651 // re_search (*pattern_buffer, *string, size, start, range, *regs)
1652 i = re_search(&preg, q, size, 0, range, 0);
1655 i = 0; // return NULL if pattern not found
1658 if (dir == FORWARD) {
1664 #endif /* REGEX_SEARCH */
1666 #endif /* FEATURE_VI_SEARCH */
1668 static char *char_insert(char *p, char c) // insert the char c at 'p'
1670 if (c == 22) { // Is this an ctrl-V?
1671 p += stupid_insert(p, '^'); // use ^ to indicate literal next
1672 refresh(FALSE); // show the ^
1677 } else if (c == 27) { // Is this an ESC?
1680 end_cmd_q(); // stop adding to q
1681 last_status_cksum = 0; // force status update
1682 if ((p[-1] != '\n') && (dot > text)) {
1685 } else if (c == erase_char || c == 8 || c == 127) { // Is this a BS
1687 if ((p[-1] != '\n') && (dot>text)) {
1689 p = text_hole_delete(p, p); // shrink buffer 1 char
1692 // insert a char into text[]
1693 char *sp; // "save p"
1696 c = '\n'; // translate \r to \n
1697 sp = p; // remember addr of insert
1698 p += 1 + stupid_insert(p, c); // insert the char
1699 #if ENABLE_FEATURE_VI_SETOPTS
1700 if (showmatch && strchr(")]}", *sp) != NULL) {
1703 if (autoindent && c == '\n') { // auto indent the new line
1706 q = prev_line(p); // use prev line as template
1707 len = strspn(q, " \t"); // space or tab
1710 bias = text_hole_make(p, len);
1722 // might reallocate text[]! use p += stupid_insert(p, ...),
1723 // and be careful to not use pointers into potentially freed text[]!
1724 static uintptr_t stupid_insert(char *p, char c) // stupidly insert the char c at 'p'
1727 bias = text_hole_make(p, 1);
1730 //file_modified++; - done by text_hole_make()
1734 static int find_range(char **start, char **stop, char c)
1736 char *save_dot, *p, *q, *t;
1737 int cnt, multiline = 0;
1742 if (strchr("cdy><", c)) {
1743 // these cmds operate on whole lines
1744 p = q = begin_line(p);
1745 for (cnt = 1; cnt < cmdcnt; cnt++) {
1749 } else if (strchr("^%$0bBeEfth\b\177", c)) {
1750 // These cmds operate on char positions
1751 do_cmd(c); // execute movement cmd
1753 } else if (strchr("wW", c)) {
1754 do_cmd(c); // execute movement cmd
1755 // if we are at the next word's first char
1756 // step back one char
1757 // but check the possibilities when it is true
1758 if (dot > text && ((isspace(dot[-1]) && !isspace(dot[0]))
1759 || (ispunct(dot[-1]) && !ispunct(dot[0]))
1760 || (isalnum(dot[-1]) && !isalnum(dot[0]))))
1761 dot--; // move back off of next word
1762 if (dot > text && *dot == '\n')
1763 dot--; // stay off NL
1765 } else if (strchr("H-k{", c)) {
1766 // these operate on multi-lines backwards
1767 q = end_line(dot); // find NL
1768 do_cmd(c); // execute movement cmd
1771 } else if (strchr("L+j}\r\n", c)) {
1772 // these operate on multi-lines forwards
1773 p = begin_line(dot);
1774 do_cmd(c); // execute movement cmd
1775 dot_end(); // find NL
1778 // nothing -- this causes any other values of c to
1779 // represent the one-character range under the
1780 // cursor. this is correct for ' ' and 'l', but
1781 // perhaps no others.
1790 // backward char movements don't include start position
1791 if (q > p && strchr("^0bBh\b\177", c)) q--;
1794 for (t = p; t <= q; t++) {
1807 static int st_test(char *p, int type, int dir, char *tested)
1817 if (type == S_BEFORE_WS) {
1819 test = (!isspace(c) || c == '\n');
1821 if (type == S_TO_WS) {
1823 test = (!isspace(c) || c == '\n');
1825 if (type == S_OVER_WS) {
1829 if (type == S_END_PUNCT) {
1833 if (type == S_END_ALNUM) {
1835 test = (isalnum(c) || c == '_');
1841 static char *skip_thing(char *p, int linecnt, int dir, int type)
1845 while (st_test(p, type, dir, &c)) {
1846 // make sure we limit search to correct number of lines
1847 if (c == '\n' && --linecnt < 1)
1849 if (dir >= 0 && p >= end - 1)
1851 if (dir < 0 && p <= text)
1853 p += dir; // move to next char
1858 // find matching char of pair () [] {}
1859 static char *find_pair(char *p, const char c)
1866 dir = 1; // assume forward
1868 case '(': match = ')'; break;
1869 case '[': match = ']'; break;
1870 case '{': match = '}'; break;
1871 case ')': match = '('; dir = -1; break;
1872 case ']': match = '['; dir = -1; break;
1873 case '}': match = '{'; dir = -1; break;
1875 for (q = p + dir; text <= q && q < end; q += dir) {
1876 // look for match, count levels of pairs (( ))
1878 level++; // increase pair levels
1880 level--; // reduce pair level
1882 break; // found matching pair
1885 q = NULL; // indicate no match
1889 #if ENABLE_FEATURE_VI_SETOPTS
1890 // show the matching char of a pair, () [] {}
1891 static void showmatching(char *p)
1895 // we found half of a pair
1896 q = find_pair(p, *p); // get loc of matching char
1898 indicate_error('3'); // no matching char
1900 // "q" now points to matching pair
1901 save_dot = dot; // remember where we are
1902 dot = q; // go to new loc
1903 refresh(FALSE); // let the user see it
1904 mysleep(40); // give user some time
1905 dot = save_dot; // go back to old loc
1909 #endif /* FEATURE_VI_SETOPTS */
1911 // open a hole in text[]
1912 // might reallocate text[]! use p += text_hole_make(p, ...),
1913 // and be careful to not use pointers into potentially freed text[]!
1914 static uintptr_t text_hole_make(char *p, int size) // at "p", make a 'size' byte hole
1920 end += size; // adjust the new END
1921 if (end >= (text + text_size)) {
1923 text_size += end - (text + text_size) + 10240;
1924 new_text = xrealloc(text, text_size);
1925 bias = (new_text - text);
1926 screenbegin += bias;
1932 memmove(p + size, p, end - size - p);
1933 memset(p, ' ', size); // clear new hole
1938 // close a hole in text[]
1939 static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclusive
1944 // move forwards, from beginning
1948 if (q < p) { // they are backward- swap them
1952 hole_size = q - p + 1;
1954 if (src < text || src > end)
1956 if (dest < text || dest >= end)
1959 goto thd_atend; // just delete the end of the buffer
1960 memmove(dest, src, cnt);
1962 end = end - hole_size; // adjust the new END
1964 dest = end - 1; // make sure dest in below end-1
1966 dest = end = text; // keep pointers valid
1972 // copy text into register, then delete text.
1973 // if dist <= 0, do not include, or go past, a NewLine
1975 static char *yank_delete(char *start, char *stop, int dist, int yf)
1979 // make sure start <= stop
1981 // they are backwards, reverse them
1987 // we cannot cross NL boundaries
1991 // dont go past a NewLine
1992 for (; p + 1 <= stop; p++) {
1994 stop = p; // "stop" just before NewLine
2000 #if ENABLE_FEATURE_VI_YANKMARK
2001 text_yank(start, stop, YDreg);
2003 if (yf == YANKDEL) {
2004 p = text_hole_delete(start, stop);
2009 static void show_help(void)
2011 puts("These features are available:"
2012 #if ENABLE_FEATURE_VI_SEARCH
2013 "\n\tPattern searches with / and ?"
2015 #if ENABLE_FEATURE_VI_DOT_CMD
2016 "\n\tLast command repeat with \'.\'"
2018 #if ENABLE_FEATURE_VI_YANKMARK
2019 "\n\tLine marking with 'x"
2020 "\n\tNamed buffers with \"x"
2022 #if ENABLE_FEATURE_VI_READONLY
2023 "\n\tReadonly if vi is called as \"view\""
2024 "\n\tReadonly with -R command line arg"
2026 #if ENABLE_FEATURE_VI_SET
2027 "\n\tSome colon mode commands with \':\'"
2029 #if ENABLE_FEATURE_VI_SETOPTS
2030 "\n\tSettable options with \":set\""
2032 #if ENABLE_FEATURE_VI_USE_SIGNALS
2033 "\n\tSignal catching- ^C"
2034 "\n\tJob suspend and resume with ^Z"
2036 #if ENABLE_FEATURE_VI_WIN_RESIZE
2037 "\n\tAdapt to window re-sizes"
2042 #if ENABLE_FEATURE_VI_DOT_CMD
2043 static void start_new_cmd_q(char c)
2045 // get buffer for new cmd
2046 // if there is a current cmd count put it in the buffer first
2048 lmc_len = sprintf(last_modifying_cmd, "%d%c", cmdcnt, c);
2049 } else { // just save char c onto queue
2050 last_modifying_cmd[0] = c;
2056 static void end_cmd_q(void)
2058 #if ENABLE_FEATURE_VI_YANKMARK
2059 YDreg = 26; // go back to default Yank/Delete reg
2063 #endif /* FEATURE_VI_DOT_CMD */
2065 #if ENABLE_FEATURE_VI_YANKMARK \
2066 || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) \
2067 || ENABLE_FEATURE_VI_CRASHME
2068 // might reallocate text[]! use p += string_insert(p, ...),
2069 // and be careful to not use pointers into potentially freed text[]!
2070 static uintptr_t string_insert(char *p, const char *s) // insert the string at 'p'
2076 bias = text_hole_make(p, i);
2079 #if ENABLE_FEATURE_VI_YANKMARK
2082 for (cnt = 0; *s != '\0'; s++) {
2086 status_line("Put %d lines (%d chars) from [%c]", cnt, i, what_reg());
2093 #if ENABLE_FEATURE_VI_YANKMARK
2094 static char *text_yank(char *p, char *q, int dest) // copy text into a register
2097 if (cnt < 0) { // they are backwards- reverse them
2101 free(reg[dest]); // if already a yank register, free it
2102 reg[dest] = xstrndup(p, cnt + 1);
2106 static char what_reg(void)
2110 c = 'D'; // default to D-reg
2111 if (0 <= YDreg && YDreg <= 25)
2112 c = 'a' + (char) YDreg;
2120 static void check_context(char cmd)
2122 // A context is defined to be "modifying text"
2123 // Any modifying command establishes a new context.
2125 if (dot < context_start || dot > context_end) {
2126 if (strchr(modifying_cmds, cmd) != NULL) {
2127 // we are trying to modify text[]- make this the current context
2128 mark[27] = mark[26]; // move cur to prev
2129 mark[26] = dot; // move local to cur
2130 context_start = prev_line(prev_line(dot));
2131 context_end = next_line(next_line(dot));
2132 //loiter= start_loiter= now;
2137 static char *swap_context(char *p) // goto new context for '' command make this the current context
2141 // the current context is in mark[26]
2142 // the previous context is in mark[27]
2143 // only swap context if other context is valid
2144 if (text <= mark[27] && mark[27] <= end - 1) {
2146 mark[27] = mark[26];
2148 p = mark[26]; // where we are going- previous context
2149 context_start = prev_line(prev_line(prev_line(p)));
2150 context_end = next_line(next_line(next_line(p)));
2154 #endif /* FEATURE_VI_YANKMARK */
2156 //----- Set terminal attributes --------------------------------
2157 static void rawmode(void)
2159 tcgetattr(0, &term_orig);
2160 term_vi = term_orig;
2161 term_vi.c_lflag &= (~ICANON & ~ECHO); // leave ISIG ON- allow intr's
2162 term_vi.c_iflag &= (~IXON & ~ICRNL);
2163 term_vi.c_oflag &= (~ONLCR);
2164 term_vi.c_cc[VMIN] = 1;
2165 term_vi.c_cc[VTIME] = 0;
2166 erase_char = term_vi.c_cc[VERASE];
2167 tcsetattr_stdin_TCSANOW(&term_vi);
2170 static void cookmode(void)
2173 tcsetattr_stdin_TCSANOW(&term_orig);
2176 #if ENABLE_FEATURE_VI_USE_SIGNALS
2177 //----- Come here when we get a window resize signal ---------
2178 static void winch_sig(int sig UNUSED_PARAM)
2180 int save_errno = errno;
2181 // FIXME: do it in main loop!!!
2182 signal(SIGWINCH, winch_sig);
2183 query_screen_dimensions();
2184 new_screen(rows, columns); // get memory for virtual screen
2185 redraw(TRUE); // re-draw the screen
2189 //----- Come here when we get a continue signal -------------------
2190 static void cont_sig(int sig UNUSED_PARAM)
2192 int save_errno = errno;
2193 rawmode(); // terminal to "raw"
2194 last_status_cksum = 0; // force status update
2195 redraw(TRUE); // re-draw the screen
2197 signal(SIGTSTP, suspend_sig);
2198 signal(SIGCONT, SIG_DFL);
2199 //kill(my_pid, SIGCONT); // huh? why? we are already "continued"...
2203 //----- Come here when we get a Suspend signal -------------------
2204 static void suspend_sig(int sig UNUSED_PARAM)
2206 int save_errno = errno;
2207 go_bottom_and_clear_to_eol();
2208 cookmode(); // terminal to "cooked"
2210 signal(SIGCONT, cont_sig);
2211 signal(SIGTSTP, SIG_DFL);
2212 kill(my_pid, SIGTSTP);
2216 //----- Come here when we get a signal ---------------------------
2217 static void catch_sig(int sig)
2219 signal(SIGINT, catch_sig);
2220 siglongjmp(restart, sig);
2222 #endif /* FEATURE_VI_USE_SIGNALS */
2224 static int mysleep(int hund) // sleep for 'hund' 1/100 seconds or stdin ready
2226 struct pollfd pfd[1];
2228 pfd[0].fd = STDIN_FILENO;
2229 pfd[0].events = POLLIN;
2230 return safe_poll(pfd, 1, hund*10) > 0;
2233 //----- IO Routines --------------------------------------------
2234 static int readit(void) // read (maybe cursor) key from stdin
2239 c = read_key(STDIN_FILENO, readbuffer, /*timeout off:*/ -2);
2240 if (c == -1) { // EOF/error
2241 go_bottom_and_clear_to_eol();
2242 cookmode(); // terminal to "cooked"
2243 bb_error_msg_and_die("can't read user input");
2248 //----- IO Routines --------------------------------------------
2249 static int get_one_char(void)
2253 #if ENABLE_FEATURE_VI_DOT_CMD
2255 // we are not adding to the q.
2256 // but, we may be reading from a q
2258 // there is no current q, read from STDIN
2259 c = readit(); // get the users input
2261 // there is a queue to get chars from first
2262 // careful with correct sign expansion!
2263 c = (unsigned char)*ioq++;
2265 // the end of the q, read from STDIN
2267 ioq_start = ioq = 0;
2268 c = readit(); // get the users input
2272 // adding STDIN chars to q
2273 c = readit(); // get the users input
2274 if (lmc_len >= MAX_INPUT_LEN - 1) {
2275 status_line_bold("last_modifying_cmd overrun");
2277 // add new char to q
2278 last_modifying_cmd[lmc_len++] = c;
2282 c = readit(); // get the users input
2283 #endif /* FEATURE_VI_DOT_CMD */
2287 // Get input line (uses "status line" area)
2288 static char *get_input_line(const char *prompt)
2290 // char [MAX_INPUT_LEN]
2291 #define buf get_input_line__buf
2296 strcpy(buf, prompt);
2297 last_status_cksum = 0; // force status update
2298 go_bottom_and_clear_to_eol();
2299 write1(prompt); // write out the :, /, or ? prompt
2302 while (i < MAX_INPUT_LEN) {
2304 if (c == '\n' || c == '\r' || c == 27)
2305 break; // this is end of input
2306 if (c == erase_char || c == 8 || c == 127) {
2307 // user wants to erase prev char
2309 write1("\b \b"); // erase char on screen
2310 if (i <= 0) // user backs up before b-o-l, exit
2312 } else if (c > 0 && c < 256) { // exclude Unicode
2313 // (TODO: need to handle Unicode)
2324 static int file_size(const char *fn) // what is the byte size of "fn"
2330 if (fn && stat(fn, &st_buf) == 0) // see if file exists
2331 cnt = (int) st_buf.st_size;
2335 // might reallocate text[]!
2336 static int file_insert(const char *fn, char *p, int update_ro_status)
2340 struct stat statbuf;
2343 if (stat(fn, &statbuf) < 0) {
2344 status_line_bold("\"%s\" %s", fn, strerror(errno));
2347 if (!S_ISREG(statbuf.st_mode)) {
2348 // This is not a regular file
2349 status_line_bold("\"%s\" Not a regular file", fn);
2352 if (p < text || p > end) {
2353 status_line_bold("Trying to insert file outside of memory");
2357 // read file to buffer
2358 fd = open(fn, O_RDONLY);
2360 status_line_bold("\"%s\" %s", fn, strerror(errno));
2363 size = statbuf.st_size;
2364 p += text_hole_make(p, size);
2365 cnt = safe_read(fd, p, size);
2367 status_line_bold("\"%s\" %s", fn, strerror(errno));
2368 p = text_hole_delete(p, p + size - 1); // un-do buffer insert
2369 } else if (cnt < size) {
2370 // There was a partial read, shrink unused space text[]
2371 p = text_hole_delete(p + cnt, p + (size - cnt) - 1); // un-do buffer insert
2372 status_line_bold("can't read all of file \"%s\"", fn);
2378 #if ENABLE_FEATURE_VI_READONLY
2379 if (update_ro_status
2380 && ((access(fn, W_OK) < 0) ||
2381 /* root will always have access()
2382 * so we check fileperms too */
2383 !(statbuf.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH))
2386 SET_READONLY_FILE(readonly_mode);
2392 static int file_write(char *fn, char *first, char *last)
2394 int fd, cnt, charcnt;
2397 status_line_bold("No current filename");
2401 /* By popular request we do not open file with O_TRUNC,
2402 * but instead ftruncate() it _after_ successful write.
2403 * Might reduce amount of data lost on power fail etc.
2405 fd = open(fn, (O_WRONLY | O_CREAT), 0666);
2408 cnt = last - first + 1;
2409 charcnt = full_write(fd, first, cnt);
2410 ftruncate(fd, charcnt);
2411 if (charcnt == cnt) {
2413 //file_modified = FALSE;
2421 //----- Terminal Drawing ---------------------------------------
2422 // The terminal is made up of 'rows' line of 'columns' columns.
2423 // classically this would be 24 x 80.
2424 // screen coordinates
2430 // 23,0 ... 23,79 <- status line
2432 //----- Move the cursor to row x col (count from 0, not 1) -------
2433 static void place_cursor(int row, int col, int optimize)
2435 char cm1[sizeof(CMrc) + sizeof(int)*3 * 2];
2436 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
2438 SZ_UP = sizeof(CMup),
2439 SZ_DN = sizeof(CMdown),
2440 SEQ_SIZE = SZ_UP > SZ_DN ? SZ_UP : SZ_DN,
2442 char cm2[SEQ_SIZE * 5 + 32]; // bigger than worst case size
2446 if (row < 0) row = 0;
2447 if (row >= rows) row = rows - 1;
2448 if (col < 0) col = 0;
2449 if (col >= columns) col = columns - 1;
2451 //----- 1. Try the standard terminal ESC sequence
2452 sprintf(cm1, CMrc, row + 1, col + 1);
2455 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
2456 if (optimize && col < 16) {
2458 int Rrow = last_row;
2459 int diff = Rrow - row;
2461 if (diff < -5 || diff > 5)
2464 //----- find the minimum # of chars to move cursor -------------
2465 //----- 2. Try moving with discreet chars (Newline, [back]space, ...)
2468 // move to the correct row
2469 while (row < Rrow) {
2470 // the cursor has to move up
2474 while (row > Rrow) {
2475 // the cursor has to move down
2476 strcat(cm2, CMdown);
2480 // now move to the correct column
2481 strcat(cm2, "\r"); // start at col 0
2482 // just send out orignal source char to get to correct place
2483 screenp = &screen[row * columns]; // start of screen line
2484 strncat(cm2, screenp, col);
2486 // pick the shortest cursor motion to send out
2487 if (strlen(cm2) < strlen(cm)) {
2493 #endif /* FEATURE_VI_OPTIMIZE_CURSOR */
2497 //----- Erase from cursor to end of line -----------------------
2498 static void clear_to_eol(void)
2500 write1(Ceol); // Erase from cursor to end of line
2503 static void go_bottom_and_clear_to_eol(void)
2505 place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
2506 clear_to_eol(); // erase to end of line
2509 //----- Erase from cursor to end of screen -----------------------
2510 static void clear_to_eos(void)
2512 write1(Ceos); // Erase from cursor to end of screen
2515 //----- Start standout mode ------------------------------------
2516 static void standout_start(void) // send "start reverse video" sequence
2518 write1(SOs); // Start reverse video mode
2521 //----- End standout mode --------------------------------------
2522 static void standout_end(void) // send "end reverse video" sequence
2524 write1(SOn); // End reverse video mode
2527 //----- Flash the screen --------------------------------------
2528 static void flash(int h)
2530 standout_start(); // send "start reverse video" sequence
2533 standout_end(); // send "end reverse video" sequence
2537 static void Indicate_Error(void)
2539 #if ENABLE_FEATURE_VI_CRASHME
2541 return; // generate a random command
2544 write1(bell); // send out a bell character
2550 //----- Screen[] Routines --------------------------------------
2551 //----- Erase the Screen[] memory ------------------------------
2552 static void screen_erase(void)
2554 memset(screen, ' ', screensize); // clear new screen
2557 static int bufsum(char *buf, int count)
2560 char *e = buf + count;
2563 sum += (unsigned char) *buf++;
2567 //----- Draw the status line at bottom of the screen -------------
2568 static void show_status_line(void)
2570 int cnt = 0, cksum = 0;
2572 // either we already have an error or status message, or we
2574 if (!have_status_msg) {
2575 cnt = format_edit_status();
2576 cksum = bufsum(status_buffer, cnt);
2578 if (have_status_msg || ((cnt > 0 && last_status_cksum != cksum))) {
2579 last_status_cksum = cksum; // remember if we have seen this line
2580 go_bottom_and_clear_to_eol();
2581 write1(status_buffer);
2582 if (have_status_msg) {
2583 if (((int)strlen(status_buffer) - (have_status_msg - 1)) >
2585 have_status_msg = 0;
2588 have_status_msg = 0;
2590 place_cursor(crow, ccol, FALSE); // put cursor back in correct place
2595 //----- format the status buffer, the bottom line of screen ------
2596 // format status buffer, with STANDOUT mode
2597 static void status_line_bold(const char *format, ...)
2601 va_start(args, format);
2602 strcpy(status_buffer, SOs); // Terminal standout mode on
2603 vsprintf(status_buffer + sizeof(SOs)-1, format, args);
2604 strcat(status_buffer, SOn); // Terminal standout mode off
2607 have_status_msg = 1 + sizeof(SOs) + sizeof(SOn) - 2;
2610 // format status buffer
2611 static void status_line(const char *format, ...)
2615 va_start(args, format);
2616 vsprintf(status_buffer, format, args);
2619 have_status_msg = 1;
2622 // copy s to buf, convert unprintable
2623 static void print_literal(char *buf, const char *s)
2637 c_is_no_print = (c & 0x80) && !Isprint(c);
2638 if (c_is_no_print) {
2643 if (c < ' ' || c == 0x7f) {
2645 c |= '@'; /* 0x40 */
2651 if (c_is_no_print) {
2659 if (d - buf > MAX_INPUT_LEN - 10) // paranoia
2664 static void not_implemented(const char *s)
2666 char buf[MAX_INPUT_LEN];
2668 print_literal(buf, s);
2669 status_line_bold("\'%s\' is not implemented", buf);
2672 // show file status on status line
2673 static int format_edit_status(void)
2675 static const char cmd_mode_indicator[] ALIGN1 = "-IR-";
2677 #define tot format_edit_status__tot
2679 int cur, percent, ret, trunc_at;
2681 // file_modified is now a counter rather than a flag. this
2682 // helps reduce the amount of line counting we need to do.
2683 // (this will cause a mis-reporting of modified status
2684 // once every MAXINT editing operations.)
2686 // it would be nice to do a similar optimization here -- if
2687 // we haven't done a motion that could have changed which line
2688 // we're on, then we shouldn't have to do this count_lines()
2689 cur = count_lines(text, dot);
2691 // reduce counting -- the total lines can't have
2692 // changed if we haven't done any edits.
2693 if (file_modified != last_file_modified) {
2694 tot = cur + count_lines(dot, end - 1) - 1;
2695 last_file_modified = file_modified;
2698 // current line percent
2699 // ------------- ~~ ----------
2702 percent = (100 * cur) / tot;
2708 trunc_at = columns < STATUS_BUFFER_LEN-1 ?
2709 columns : STATUS_BUFFER_LEN-1;
2711 ret = snprintf(status_buffer, trunc_at+1,
2712 #if ENABLE_FEATURE_VI_READONLY
2713 "%c %s%s%s %d/%d %d%%",
2715 "%c %s%s %d/%d %d%%",
2717 cmd_mode_indicator[cmd_mode & 3],
2718 (current_filename != NULL ? current_filename : "No file"),
2719 #if ENABLE_FEATURE_VI_READONLY
2720 (readonly_mode ? " [Readonly]" : ""),
2722 (file_modified ? " [Modified]" : ""),
2725 if (ret >= 0 && ret < trunc_at)
2726 return ret; /* it all fit */
2728 return trunc_at; /* had to truncate */
2732 //----- Force refresh of all Lines -----------------------------
2733 static void redraw(int full_screen)
2735 place_cursor(0, 0, FALSE); // put cursor in correct place
2736 clear_to_eos(); // tell terminal to erase display
2737 screen_erase(); // erase the internal screen buffer
2738 last_status_cksum = 0; // force status update
2739 refresh(full_screen); // this will redraw the entire display
2743 //----- Format a text[] line into a buffer ---------------------
2744 static char* format_line(char *src /*, int li*/)
2749 char *dest = scr_out_buf; // [MAX_SCR_COLS + MAX_TABSTOP * 2]
2751 c = '~'; // char in col 0 in non-existent lines is '~'
2753 while (co < columns + tabstop) {
2754 // have we gone past the end?
2759 if ((c & 0x80) && !Isprint(c)) {
2762 if (c < ' ' || c == 0x7f) {
2766 while ((co % tabstop) != (tabstop - 1)) {
2774 c += '@'; // Ctrl-X -> 'X'
2779 // discard scrolled-off-to-the-left portion,
2780 // in tabstop-sized pieces
2781 if (ofs >= tabstop && co >= tabstop) {
2782 memmove(dest, dest + tabstop, co);
2789 // check "short line, gigantic offset" case
2792 // discard last scrolled off part
2795 // fill the rest with spaces
2797 memset(&dest[co], ' ', columns - co);
2801 //----- Refresh the changed screen lines -----------------------
2802 // Copy the source line from text[] into the buffer and note
2803 // if the current screenline is different from the new buffer.
2804 // If they differ then that line needs redrawing on the terminal.
2806 static void refresh(int full_screen)
2808 #define old_offset refresh__old_offset
2811 char *tp, *sp; // pointer into text[] and screen[]
2813 if (ENABLE_FEATURE_VI_WIN_RESIZE) {
2814 unsigned c = columns, r = rows;
2815 query_screen_dimensions();
2816 full_screen |= (c - columns) | (r - rows);
2818 sync_cursor(dot, &crow, &ccol); // where cursor will be (on "dot")
2819 tp = screenbegin; // index into text[] of top line
2821 // compare text[] to screen[] and mark screen[] lines that need updating
2822 for (li = 0; li < rows - 1; li++) {
2823 int cs, ce; // column start & end
2825 // format current text line
2826 out_buf = format_line(tp /*, li*/);
2828 // skip to the end of the current text[] line
2830 char *t = memchr(tp, '\n', end - tp);
2831 if (!t) t = end - 1;
2835 // see if there are any changes between vitual screen and out_buf
2836 changed = FALSE; // assume no change
2839 sp = &screen[li * columns]; // start of screen line
2841 // force re-draw of every single column from 0 - columns-1
2844 // compare newly formatted buffer with virtual screen
2845 // look forward for first difference between buf and screen
2846 for (; cs <= ce; cs++) {
2847 if (out_buf[cs] != sp[cs]) {
2848 changed = TRUE; // mark for redraw
2853 // look backward for last difference between out_buf and screen
2854 for (; ce >= cs; ce--) {
2855 if (out_buf[ce] != sp[ce]) {
2856 changed = TRUE; // mark for redraw
2860 // now, cs is index of first diff, and ce is index of last diff
2862 // if horz offset has changed, force a redraw
2863 if (offset != old_offset) {
2868 // make a sanity check of columns indexes
2870 if (ce > columns - 1) ce = columns - 1;
2871 if (cs > ce) { cs = 0; ce = columns - 1; }
2872 // is there a change between vitual screen and out_buf
2874 // copy changed part of buffer to virtual screen
2875 memcpy(sp+cs, out_buf+cs, ce-cs+1);
2877 // move cursor to column of first change
2878 //if (offset != old_offset) {
2879 // // place_cursor is still too stupid
2880 // // to handle offsets correctly
2881 // place_cursor(li, cs, FALSE);
2883 place_cursor(li, cs, TRUE);
2886 // write line out to terminal
2887 fwrite(&sp[cs], ce - cs + 1, 1, stdout);
2891 place_cursor(crow, ccol, TRUE);
2893 old_offset = offset;
2897 //---------------------------------------------------------------------
2898 //----- the Ascii Chart -----------------------------------------------
2900 // 00 nul 01 soh 02 stx 03 etx 04 eot 05 enq 06 ack 07 bel
2901 // 08 bs 09 ht 0a nl 0b vt 0c np 0d cr 0e so 0f si
2902 // 10 dle 11 dc1 12 dc2 13 dc3 14 dc4 15 nak 16 syn 17 etb
2903 // 18 can 19 em 1a sub 1b esc 1c fs 1d gs 1e rs 1f us
2904 // 20 sp 21 ! 22 " 23 # 24 $ 25 % 26 & 27 '
2905 // 28 ( 29 ) 2a * 2b + 2c , 2d - 2e . 2f /
2906 // 30 0 31 1 32 2 33 3 34 4 35 5 36 6 37 7
2907 // 38 8 39 9 3a : 3b ; 3c < 3d = 3e > 3f ?
2908 // 40 @ 41 A 42 B 43 C 44 D 45 E 46 F 47 G
2909 // 48 H 49 I 4a J 4b K 4c L 4d M 4e N 4f O
2910 // 50 P 51 Q 52 R 53 S 54 T 55 U 56 V 57 W
2911 // 58 X 59 Y 5a Z 5b [ 5c \ 5d ] 5e ^ 5f _
2912 // 60 ` 61 a 62 b 63 c 64 d 65 e 66 f 67 g
2913 // 68 h 69 i 6a j 6b k 6c l 6d m 6e n 6f o
2914 // 70 p 71 q 72 r 73 s 74 t 75 u 76 v 77 w
2915 // 78 x 79 y 7a z 7b { 7c | 7d } 7e ~ 7f del
2916 //---------------------------------------------------------------------
2918 //----- Execute a Vi Command -----------------------------------
2919 static void do_cmd(int c)
2921 const char *msg = msg; // for compiler
2922 char *p, *q, *save_dot;
2928 // c1 = c; // quiet the compiler
2929 // cnt = yf = 0; // quiet the compiler
2930 // msg = p = q = save_dot = buf; // quiet the compiler
2931 memset(buf, '\0', 12);
2935 /* if this is a cursor key, skip these checks */
2943 case KEYCODE_PAGEUP:
2944 case KEYCODE_PAGEDOWN:
2945 case KEYCODE_DELETE:
2949 if (cmd_mode == 2) {
2950 // flip-flop Insert/Replace mode
2951 if (c == KEYCODE_INSERT)
2953 // we are 'R'eplacing the current *dot with new char
2955 // don't Replace past E-o-l
2956 cmd_mode = 1; // convert to insert
2958 if (1 <= c || Isprint(c)) {
2960 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
2961 dot = char_insert(dot, c); // insert new char
2966 if (cmd_mode == 1) {
2967 // hitting "Insert" twice means "R" replace mode
2968 if (c == KEYCODE_INSERT) goto dc5;
2969 // insert the char c at "dot"
2970 if (1 <= c || Isprint(c)) {
2971 dot = char_insert(dot, c);
2986 #if ENABLE_FEATURE_VI_CRASHME
2987 case 0x14: // dc4 ctrl-T
2988 crashme = (crashme == 0) ? 1 : 0;
3017 //case 'u': // u- FIXME- there is no undo
3019 default: // unrecognized command
3022 not_implemented(buf);
3023 end_cmd_q(); // stop adding to q
3024 case 0x00: // nul- ignore
3026 case 2: // ctrl-B scroll up full screen
3027 case KEYCODE_PAGEUP: // Cursor Key Page Up
3028 dot_scroll(rows - 2, -1);
3030 case 4: // ctrl-D scroll down half screen
3031 dot_scroll((rows - 2) / 2, 1);
3033 case 5: // ctrl-E scroll down one line
3036 case 6: // ctrl-F scroll down full screen
3037 case KEYCODE_PAGEDOWN: // Cursor Key Page Down
3038 dot_scroll(rows - 2, 1);
3040 case 7: // ctrl-G show current status
3041 last_status_cksum = 0; // force status update
3043 case 'h': // h- move left
3044 case KEYCODE_LEFT: // cursor key Left
3045 case 8: // ctrl-H- move left (This may be ERASE char)
3046 case 0x7f: // DEL- move left (This may be ERASE char)
3052 case 10: // Newline ^J
3053 case 'j': // j- goto next line, same col
3054 case KEYCODE_DOWN: // cursor key Down
3058 dot_next(); // go to next B-o-l
3059 dot = move_to_col(dot, ccol + offset); // try stay in same col
3061 case 12: // ctrl-L force redraw whole screen
3062 case 18: // ctrl-R force redraw
3063 place_cursor(0, 0, FALSE); // put cursor in correct place
3064 clear_to_eos(); // tel terminal to erase display
3066 screen_erase(); // erase the internal screen buffer
3067 last_status_cksum = 0; // force status update
3068 refresh(TRUE); // this will redraw the entire display
3070 case 13: // Carriage Return ^M
3071 case '+': // +- goto next line
3078 case 21: // ctrl-U scroll up half screen
3079 dot_scroll((rows - 2) / 2, -1);
3081 case 25: // ctrl-Y scroll up one line
3087 cmd_mode = 0; // stop insrting
3089 last_status_cksum = 0; // force status update
3091 case ' ': // move right
3092 case 'l': // move right
3093 case KEYCODE_RIGHT: // Cursor Key Right
3099 #if ENABLE_FEATURE_VI_YANKMARK
3100 case '"': // "- name a register to use for Delete/Yank
3101 c1 = (get_one_char() | 0x20) - 'a'; // | 0x20 is tolower()
3102 if ((unsigned)c1 <= 25) { // a-z?
3108 case '\'': // '- goto a specific mark
3109 c1 = (get_one_char() | 0x20) - 'a';
3110 if ((unsigned)c1 <= 25) { // a-z?
3113 if (text <= q && q < end) {
3115 dot_begin(); // go to B-o-l
3118 } else if (c1 == '\'') { // goto previous context
3119 dot = swap_context(dot); // swap current and previous context
3120 dot_begin(); // go to B-o-l
3126 case 'm': // m- Mark a line
3127 // this is really stupid. If there are any inserts or deletes
3128 // between text[0] and dot then this mark will not point to the
3129 // correct location! It could be off by many lines!
3130 // Well..., at least its quick and dirty.
3131 c1 = (get_one_char() | 0x20) - 'a';
3132 if ((unsigned)c1 <= 25) { // a-z?
3133 // remember the line
3139 case 'P': // P- Put register before
3140 case 'p': // p- put register after
3143 status_line_bold("Nothing in register %c", what_reg());
3146 // are we putting whole lines or strings
3147 if (strchr(p, '\n') != NULL) {
3149 dot_begin(); // putting lines- Put above
3152 // are we putting after very last line?
3153 if (end_line(dot) == (end - 1)) {
3154 dot = end; // force dot to end of text[]
3156 dot_next(); // next line, then put before
3161 dot_right(); // move to right, can move to NL
3163 string_insert(dot, p); // insert the string
3164 end_cmd_q(); // stop adding to q
3166 case 'U': // U- Undo; replace current line with original version
3167 if (reg[Ureg] != 0) {
3168 p = begin_line(dot);
3170 p = text_hole_delete(p, q); // delete cur line
3171 p += string_insert(p, reg[Ureg]); // insert orig line
3176 #endif /* FEATURE_VI_YANKMARK */
3177 case '$': // $- goto end of line
3178 case KEYCODE_END: // Cursor Key End
3183 dot = end_line(dot);
3185 case '%': // %- find matching char of pair () [] {}
3186 for (q = dot; q < end && *q != '\n'; q++) {
3187 if (strchr("()[]{}", *q) != NULL) {
3188 // we found half of a pair
3189 p = find_pair(q, *q);
3201 case 'f': // f- forward to a user specified char
3202 last_forward_char = get_one_char(); // get the search char
3204 // dont separate these two commands. 'f' depends on ';'
3206 //**** fall through to ... ';'
3207 case ';': // ;- look at rest of line for last forward char
3211 if (last_forward_char == 0)
3214 while (q < end - 1 && *q != '\n' && *q != last_forward_char) {
3217 if (*q == last_forward_char)
3220 case ',': // repeat latest 'f' in opposite direction
3224 if (last_forward_char == 0)
3227 while (q >= text && *q != '\n' && *q != last_forward_char) {
3230 if (q >= text && *q == last_forward_char)
3234 case '-': // -- goto prev line
3241 #if ENABLE_FEATURE_VI_DOT_CMD
3242 case '.': // .- repeat the last modifying command
3243 // Stuff the last_modifying_cmd back into stdin
3244 // and let it be re-executed.
3246 last_modifying_cmd[lmc_len] = 0;
3247 ioq = ioq_start = xstrdup(last_modifying_cmd);
3251 #if ENABLE_FEATURE_VI_SEARCH
3252 case '?': // /- search for a pattern
3253 case '/': // /- search for a pattern
3256 q = get_input_line(buf); // get input line- use "status line"
3257 if (q[0] && !q[1]) {
3258 if (last_search_pattern[0])
3259 last_search_pattern[0] = c;
3260 goto dc3; // if no pat re-use old pat
3262 if (q[0]) { // strlen(q) > 1: new pat- save it and find
3263 // there is a new pat
3264 free(last_search_pattern);
3265 last_search_pattern = xstrdup(q);
3266 goto dc3; // now find the pattern
3268 // user changed mind and erased the "/"- do nothing
3270 case 'N': // N- backward search for last pattern
3274 dir = BACK; // assume BACKWARD search
3276 if (last_search_pattern[0] == '?') {
3280 goto dc4; // now search for pattern
3282 case 'n': // n- repeat search for last pattern
3283 // search rest of text[] starting at next char
3284 // if search fails return orignal "p" not the "p+1" address
3289 dir = FORWARD; // assume FORWARD search
3291 if (last_search_pattern[0] == '?') {
3296 q = char_search(p, last_search_pattern + 1, dir, FULL);
3298 dot = q; // good search, update "dot"
3302 // no pattern found between "dot" and "end"- continue at top
3307 q = char_search(p, last_search_pattern + 1, dir, FULL);
3308 if (q != NULL) { // found something
3309 dot = q; // found new pattern- goto it
3310 msg = "search hit BOTTOM, continuing at TOP";
3312 msg = "search hit TOP, continuing at BOTTOM";
3315 msg = "Pattern not found";
3319 status_line_bold("%s", msg);
3321 case '{': // {- move backward paragraph
3322 q = char_search(dot, "\n\n", BACK, FULL);
3323 if (q != NULL) { // found blank line
3324 dot = next_line(q); // move to next blank line
3327 case '}': // }- move forward paragraph
3328 q = char_search(dot, "\n\n", FORWARD, FULL);
3329 if (q != NULL) { // found blank line
3330 dot = next_line(q); // move to next blank line
3333 #endif /* FEATURE_VI_SEARCH */
3334 case '0': // 0- goto begining of line
3344 if (c == '0' && cmdcnt < 1) {
3345 dot_begin(); // this was a standalone zero
3347 cmdcnt = cmdcnt * 10 + (c - '0'); // this 0 is part of a number
3350 case ':': // :- the colon mode commands
3351 p = get_input_line(":"); // get input line- use "status line"
3352 #if ENABLE_FEATURE_VI_COLON
3353 colon(p); // execute the command
3356 p++; // move past the ':'
3360 if (strncmp(p, "quit", cnt) == 0
3361 || strncmp(p, "q!", cnt) == 0 // delete lines
3363 if (file_modified && p[1] != '!') {
3364 status_line_bold("No write since last change (:quit! overrides)");
3368 } else if (strncmp(p, "write", cnt) == 0
3369 || strncmp(p, "wq", cnt) == 0
3370 || strncmp(p, "wn", cnt) == 0
3371 || (p[0] == 'x' && !p[1])
3373 cnt = file_write(current_filename, text, end - 1);
3376 status_line_bold("Write error: %s", strerror(errno));
3379 last_file_modified = -1;
3380 status_line("\"%s\" %dL, %dC", current_filename, count_lines(text, end - 1), cnt);
3381 if (p[0] == 'x' || p[1] == 'q' || p[1] == 'n'
3382 || p[0] == 'X' || p[1] == 'Q' || p[1] == 'N'
3387 } else if (strncmp(p, "file", cnt) == 0) {
3388 last_status_cksum = 0; // force status update
3389 } else if (sscanf(p, "%d", &j) > 0) {
3390 dot = find_line(j); // go to line # j
3392 } else { // unrecognized cmd
3395 #endif /* !FEATURE_VI_COLON */
3397 case '<': // <- Left shift something
3398 case '>': // >- Right shift something
3399 cnt = count_lines(text, dot); // remember what line we are on
3400 c1 = get_one_char(); // get the type of thing to delete
3401 find_range(&p, &q, c1);
3402 yank_delete(p, q, 1, YANKONLY); // save copy before change
3405 i = count_lines(p, q); // # of lines we are shifting
3406 for ( ; i > 0; i--, p = next_line(p)) {
3408 // shift left- remove tab or 8 spaces
3410 // shrink buffer 1 char
3411 text_hole_delete(p, p);
3412 } else if (*p == ' ') {
3413 // we should be calculating columns, not just SPACE
3414 for (j = 0; *p == ' ' && j < tabstop; j++) {
3415 text_hole_delete(p, p);
3418 } else if (c == '>') {
3419 // shift right -- add tab or 8 spaces
3420 char_insert(p, '\t');
3423 dot = find_line(cnt); // what line were we on
3425 end_cmd_q(); // stop adding to q
3427 case 'A': // A- append at e-o-l
3428 dot_end(); // go to e-o-l
3429 //**** fall through to ... 'a'
3430 case 'a': // a- append after current char
3435 case 'B': // B- back a blank-delimited Word
3436 case 'E': // E- end of a blank-delimited word
3437 case 'W': // W- forward a blank-delimited word
3444 if (c == 'W' || isspace(dot[dir])) {
3445 dot = skip_thing(dot, 1, dir, S_TO_WS);
3446 dot = skip_thing(dot, 2, dir, S_OVER_WS);
3449 dot = skip_thing(dot, 1, dir, S_BEFORE_WS);
3451 case 'C': // C- Change to e-o-l
3452 case 'D': // D- delete to e-o-l
3454 dot = dollar_line(dot); // move to before NL
3455 // copy text into a register and delete
3456 dot = yank_delete(save_dot, dot, 0, YANKDEL); // delete to e-o-l
3458 goto dc_i; // start inserting
3459 #if ENABLE_FEATURE_VI_DOT_CMD
3461 end_cmd_q(); // stop adding to q
3464 case 'g': // 'gg' goto a line number (vim) (default: very first line)
3465 c1 = get_one_char();
3468 buf[1] = c1; // TODO: if Unicode?
3470 not_implemented(buf);
3476 case 'G': // G- goto to a line number (default= E-O-F)
3477 dot = end - 1; // assume E-O-F
3479 dot = find_line(cmdcnt); // what line is #cmdcnt
3483 case 'H': // H- goto top line on screen
3485 if (cmdcnt > (rows - 1)) {
3486 cmdcnt = (rows - 1);
3493 case 'I': // I- insert before first non-blank
3496 //**** fall through to ... 'i'
3497 case 'i': // i- insert before current char
3498 case KEYCODE_INSERT: // Cursor Key Insert
3500 cmd_mode = 1; // start insrting
3502 case 'J': // J- join current and next lines together
3506 dot_end(); // move to NL
3507 if (dot < end - 1) { // make sure not last char in text[]
3508 *dot++ = ' '; // replace NL with space
3510 while (isblank(*dot)) { // delete leading WS
3514 end_cmd_q(); // stop adding to q
3516 case 'L': // L- goto bottom line on screen
3518 if (cmdcnt > (rows - 1)) {
3519 cmdcnt = (rows - 1);
3527 case 'M': // M- goto middle line on screen
3529 for (cnt = 0; cnt < (rows-1) / 2; cnt++)
3530 dot = next_line(dot);
3532 case 'O': // O- open a empty line above
3534 p = begin_line(dot);
3535 if (p[-1] == '\n') {
3537 case 'o': // o- open a empty line below; Yes, I know it is in the middle of the "if (..."
3539 dot = char_insert(dot, '\n');
3542 dot = char_insert(dot, '\n'); // i\n ESC
3547 case 'R': // R- continuous Replace char
3551 case KEYCODE_DELETE:
3554 case 'X': // X- delete char before dot
3555 case 'x': // x- delete the current char
3556 case 's': // s- substitute the current char
3563 if (dot[dir] != '\n') {
3565 dot--; // delete prev char
3566 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
3569 goto dc_i; // start insrting
3570 end_cmd_q(); // stop adding to q
3572 case 'Z': // Z- if modified, {write}; exit
3573 // ZZ means to save file (if necessary), then exit
3574 c1 = get_one_char();
3579 if (file_modified) {
3580 if (ENABLE_FEATURE_VI_READONLY && readonly_mode) {
3581 status_line_bold("\"%s\" File is read only", current_filename);
3584 cnt = file_write(current_filename, text, end - 1);
3587 status_line_bold("Write error: %s", strerror(errno));
3588 } else if (cnt == (end - 1 - text + 1)) {
3595 case '^': // ^- move to first non-blank on line
3599 case 'b': // b- back a word
3600 case 'e': // e- end of word
3607 if ((dot + dir) < text || (dot + dir) > end - 1)
3610 if (isspace(*dot)) {
3611 dot = skip_thing(dot, (c == 'e') ? 2 : 1, dir, S_OVER_WS);
3613 if (isalnum(*dot) || *dot == '_') {
3614 dot = skip_thing(dot, 1, dir, S_END_ALNUM);
3615 } else if (ispunct(*dot)) {
3616 dot = skip_thing(dot, 1, dir, S_END_PUNCT);
3619 case 'c': // c- change something
3620 case 'd': // d- delete something
3621 #if ENABLE_FEATURE_VI_YANKMARK
3622 case 'y': // y- yank something
3623 case 'Y': // Y- Yank a line
3626 int yf, ml, whole = 0;
3627 yf = YANKDEL; // assume either "c" or "d"
3628 #if ENABLE_FEATURE_VI_YANKMARK
3629 if (c == 'y' || c == 'Y')
3634 c1 = get_one_char(); // get the type of thing to delete
3635 // determine range, and whether it spans lines
3636 ml = find_range(&p, &q, c1);
3637 if (c1 == 27) { // ESC- user changed mind and wants out
3638 c = c1 = 27; // Escape- do nothing
3639 } else if (strchr("wW", c1)) {
3641 // don't include trailing WS as part of word
3642 while (isblank(*q)) {
3643 if (q <= text || q[-1] == '\n')
3648 dot = yank_delete(p, q, ml, yf); // delete word
3649 } else if (strchr("^0bBeEft%$ lh\b\177", c1)) {
3650 // partial line copy text into a register and delete
3651 dot = yank_delete(p, q, ml, yf); // delete word
3652 } else if (strchr("cdykjHL+-{}\r\n", c1)) {
3653 // whole line copy text into a register and delete
3654 dot = yank_delete(p, q, ml, yf); // delete lines
3657 // could not recognize object
3658 c = c1 = 27; // error-
3664 dot = char_insert(dot, '\n');
3665 // on the last line of file don't move to prev line
3666 if (whole && dot != (end-1)) {
3669 } else if (c == 'd') {
3675 // if CHANGING, not deleting, start inserting after the delete
3677 strcpy(buf, "Change");
3678 goto dc_i; // start inserting
3681 strcpy(buf, "Delete");
3683 #if ENABLE_FEATURE_VI_YANKMARK
3684 if (c == 'y' || c == 'Y') {
3685 strcpy(buf, "Yank");
3689 for (cnt = 0; p <= q; p++) {
3693 status_line("%s %d lines (%d chars) using [%c]",
3694 buf, cnt, strlen(reg[YDreg]), what_reg());
3696 end_cmd_q(); // stop adding to q
3700 case 'k': // k- goto prev line, same col
3701 case KEYCODE_UP: // cursor key Up
3706 dot = move_to_col(dot, ccol + offset); // try stay in same col
3708 case 'r': // r- replace the current char with user input
3709 c1 = get_one_char(); // get the replacement char
3714 end_cmd_q(); // stop adding to q
3716 case 't': // t- move to char prior to next x
3717 last_forward_char = get_one_char();
3719 if (*dot == last_forward_char)
3721 last_forward_char = 0;
3723 case 'w': // w- forward a word
3727 if (isalnum(*dot) || *dot == '_') { // we are on ALNUM
3728 dot = skip_thing(dot, 1, FORWARD, S_END_ALNUM);
3729 } else if (ispunct(*dot)) { // we are on PUNCT
3730 dot = skip_thing(dot, 1, FORWARD, S_END_PUNCT);
3733 dot++; // move over word
3734 if (isspace(*dot)) {
3735 dot = skip_thing(dot, 2, FORWARD, S_OVER_WS);
3739 c1 = get_one_char(); // get the replacement char
3742 cnt = (rows - 2) / 2; // put dot at center
3744 cnt = rows - 2; // put dot at bottom
3745 screenbegin = begin_line(dot); // start dot at top
3746 dot_scroll(cnt, -1);
3748 case '|': // |- move to column "cmdcnt"
3749 dot = move_to_col(dot, cmdcnt - 1); // try to move to column
3751 case '~': // ~- flip the case of letters a-z -> A-Z
3755 if (islower(*dot)) {
3756 *dot = toupper(*dot);
3758 } else if (isupper(*dot)) {
3759 *dot = tolower(*dot);
3763 end_cmd_q(); // stop adding to q
3765 //----- The Cursor and Function Keys -----------------------------
3766 case KEYCODE_HOME: // Cursor Key Home
3769 // The Fn keys could point to do_macro which could translate them
3771 case KEYCODE_FUN1: // Function Key F1
3772 case KEYCODE_FUN2: // Function Key F2
3773 case KEYCODE_FUN3: // Function Key F3
3774 case KEYCODE_FUN4: // Function Key F4
3775 case KEYCODE_FUN5: // Function Key F5
3776 case KEYCODE_FUN6: // Function Key F6
3777 case KEYCODE_FUN7: // Function Key F7
3778 case KEYCODE_FUN8: // Function Key F8
3779 case KEYCODE_FUN9: // Function Key F9
3780 case KEYCODE_FUN10: // Function Key F10
3781 case KEYCODE_FUN11: // Function Key F11
3782 case KEYCODE_FUN12: // Function Key F12
3788 // if text[] just became empty, add back an empty line
3790 char_insert(text, '\n'); // start empty buf with dummy line
3793 // it is OK for dot to exactly equal to end, otherwise check dot validity
3795 dot = bound_dot(dot); // make sure "dot" is valid
3797 #if ENABLE_FEATURE_VI_YANKMARK
3798 check_context(c); // update the current context
3802 cmdcnt = 0; // cmd was not a number, reset cmdcnt
3803 cnt = dot - begin_line(dot);
3804 // Try to stay off of the Newline
3805 if (*dot == '\n' && cnt > 0 && cmd_mode == 0)
3809 /* NB! the CRASHME code is unmaintained, and doesn't currently build */
3810 #if ENABLE_FEATURE_VI_CRASHME
3811 static int totalcmds = 0;
3812 static int Mp = 85; // Movement command Probability
3813 static int Np = 90; // Non-movement command Probability
3814 static int Dp = 96; // Delete command Probability
3815 static int Ip = 97; // Insert command Probability
3816 static int Yp = 98; // Yank command Probability
3817 static int Pp = 99; // Put command Probability
3818 static int M = 0, N = 0, I = 0, D = 0, Y = 0, P = 0, U = 0;
3819 static const char chars[20] = "\t012345 abcdABCD-=.$";
3820 static const char *const words[20] = {
3821 "this", "is", "a", "test",
3822 "broadcast", "the", "emergency", "of",
3823 "system", "quick", "brown", "fox",
3824 "jumped", "over", "lazy", "dogs",
3825 "back", "January", "Febuary", "March"
3827 static const char *const lines[20] = {
3828 "You should have received a copy of the GNU General Public License\n",
3829 "char c, cm, *cmd, *cmd1;\n",
3830 "generate a command by percentages\n",
3831 "Numbers may be typed as a prefix to some commands.\n",
3832 "Quit, discarding changes!\n",
3833 "Forced write, if permission originally not valid.\n",
3834 "In general, any ex or ed command (such as substitute or delete).\n",
3835 "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
3836 "Please get w/ me and I will go over it with you.\n",
3837 "The following is a list of scheduled, committed changes.\n",
3838 "1. Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
3839 "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
3840 "Any question about transactions please contact Sterling Huxley.\n",
3841 "I will try to get back to you by Friday, December 31.\n",
3842 "This Change will be implemented on Friday.\n",
3843 "Let me know if you have problems accessing this;\n",
3844 "Sterling Huxley recently added you to the access list.\n",
3845 "Would you like to go to lunch?\n",
3846 "The last command will be automatically run.\n",
3847 "This is too much english for a computer geek.\n",
3849 static char *multilines[20] = {
3850 "You should have received a copy of the GNU General Public License\n",
3851 "char c, cm, *cmd, *cmd1;\n",
3852 "generate a command by percentages\n",
3853 "Numbers may be typed as a prefix to some commands.\n",
3854 "Quit, discarding changes!\n",
3855 "Forced write, if permission originally not valid.\n",
3856 "In general, any ex or ed command (such as substitute or delete).\n",
3857 "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
3858 "Please get w/ me and I will go over it with you.\n",
3859 "The following is a list of scheduled, committed changes.\n",
3860 "1. Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
3861 "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
3862 "Any question about transactions please contact Sterling Huxley.\n",
3863 "I will try to get back to you by Friday, December 31.\n",
3864 "This Change will be implemented on Friday.\n",
3865 "Let me know if you have problems accessing this;\n",
3866 "Sterling Huxley recently added you to the access list.\n",
3867 "Would you like to go to lunch?\n",
3868 "The last command will be automatically run.\n",
3869 "This is too much english for a computer geek.\n",
3872 // create a random command to execute
3873 static void crash_dummy()
3875 static int sleeptime; // how long to pause between commands
3876 char c, cm, *cmd, *cmd1;
3877 int i, cnt, thing, rbi, startrbi, percent;
3879 // "dot" movement commands
3880 cmd1 = " \n\r\002\004\005\006\025\0310^$-+wWeEbBhjklHL";
3882 // is there already a command running?
3883 if (readbuffer[0] > 0)
3886 readbuffer[0] = 'X';
3888 sleeptime = 0; // how long to pause between commands
3889 memset(readbuffer, '\0', sizeof(readbuffer));
3890 // generate a command by percentages
3891 percent = (int) lrand48() % 100; // get a number from 0-99
3892 if (percent < Mp) { // Movement commands
3893 // available commands
3896 } else if (percent < Np) { // non-movement commands
3897 cmd = "mz<>\'\""; // available commands
3899 } else if (percent < Dp) { // Delete commands
3900 cmd = "dx"; // available commands
3902 } else if (percent < Ip) { // Inset commands
3903 cmd = "iIaAsrJ"; // available commands
3905 } else if (percent < Yp) { // Yank commands
3906 cmd = "yY"; // available commands
3908 } else if (percent < Pp) { // Put commands
3909 cmd = "pP"; // available commands
3912 // We do not know how to handle this command, try again
3916 // randomly pick one of the available cmds from "cmd[]"
3917 i = (int) lrand48() % strlen(cmd);
3919 if (strchr(":\024", cm))
3920 goto cd0; // dont allow colon or ctrl-T commands
3921 readbuffer[rbi++] = cm; // put cmd into input buffer
3923 // now we have the command-
3924 // there are 1, 2, and multi char commands
3925 // find out which and generate the rest of command as necessary
3926 if (strchr("dmryz<>\'\"", cm)) { // 2-char commands
3927 cmd1 = " \n\r0$^-+wWeEbBhjklHL";
3928 if (cm == 'm' || cm == '\'' || cm == '\"') { // pick a reg[]
3929 cmd1 = "abcdefghijklmnopqrstuvwxyz";
3931 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
3933 readbuffer[rbi++] = c; // add movement to input buffer
3935 if (strchr("iIaAsc", cm)) { // multi-char commands
3937 // change some thing
3938 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
3940 readbuffer[rbi++] = c; // add movement to input buffer
3942 thing = (int) lrand48() % 4; // what thing to insert
3943 cnt = (int) lrand48() % 10; // how many to insert
3944 for (i = 0; i < cnt; i++) {
3945 if (thing == 0) { // insert chars
3946 readbuffer[rbi++] = chars[((int) lrand48() % strlen(chars))];
3947 } else if (thing == 1) { // insert words
3948 strcat(readbuffer, words[(int) lrand48() % 20]);
3949 strcat(readbuffer, " ");
3950 sleeptime = 0; // how fast to type
3951 } else if (thing == 2) { // insert lines
3952 strcat(readbuffer, lines[(int) lrand48() % 20]);
3953 sleeptime = 0; // how fast to type
3954 } else { // insert multi-lines
3955 strcat(readbuffer, multilines[(int) lrand48() % 20]);
3956 sleeptime = 0; // how fast to type
3959 strcat(readbuffer, "\033");
3961 readbuffer[0] = strlen(readbuffer + 1);
3965 mysleep(sleeptime); // sleep 1/100 sec
3968 // test to see if there are any errors
3969 static void crash_test()
3971 static time_t oldtim;
3978 strcat(msg, "end<text ");
3980 if (end > textend) {
3981 strcat(msg, "end>textend ");
3984 strcat(msg, "dot<text ");
3987 strcat(msg, "dot>end ");
3989 if (screenbegin < text) {
3990 strcat(msg, "screenbegin<text ");
3992 if (screenbegin > end - 1) {
3993 strcat(msg, "screenbegin>end-1 ");
3997 printf("\n\n%d: \'%c\' %s\n\n\n%s[Hit return to continue]%s",
3998 totalcmds, last_input_char, msg, SOs, SOn);
4000 while (safe_read(STDIN_FILENO, d, 1) > 0) {
4001 if (d[0] == '\n' || d[0] == '\r')
4006 if (tim >= (oldtim + 3)) {
4007 sprintf(status_buffer,
4008 "Tot=%d: M=%d N=%d I=%d D=%d Y=%d P=%d U=%d size=%d",
4009 totalcmds, M, N, I, D, Y, P, U, end - text + 1);