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 #define Isprint(c) isprint(c)
35 #define Isprint(c) (isprint(c) && (unsigned char)(c) < 0x7f)
40 /* 0x9b is Meta-ESC */
41 #if ENABLE_FEATURE_VI_8BIT
42 #define Isprint(c) ((unsigned char)(c) >= ' ' && (c) != 0x7f && (unsigned char)(c) != 0x9b)
44 #define Isprint(c) ((unsigned char)(c) >= ' ' && (unsigned char)(c) < 0x7f)
51 MAX_TABSTOP = 32, // sanity limit
52 // User input len. Need not be extra big.
53 // Lines in file being edited *can* be bigger than this.
55 // Sanity limits. We have only one buffer of this size.
56 MAX_SCR_COLS = CONFIG_FEATURE_VI_MAX_LEN,
57 MAX_SCR_ROWS = CONFIG_FEATURE_VI_MAX_LEN,
60 // Misc. non-Ascii keys that report an escape sequence
61 #define VI_K_UP (char)128 // cursor key Up
62 #define VI_K_DOWN (char)129 // cursor key Down
63 #define VI_K_RIGHT (char)130 // Cursor Key Right
64 #define VI_K_LEFT (char)131 // cursor key Left
65 #define VI_K_HOME (char)132 // Cursor Key Home
66 #define VI_K_END (char)133 // Cursor Key End
67 #define VI_K_INSERT (char)134 // Cursor Key Insert
68 #define VI_K_DELETE (char)135 // Cursor Key Insert
69 #define VI_K_PAGEUP (char)136 // Cursor Key Page Up
70 #define VI_K_PAGEDOWN (char)137 // Cursor Key Page Down
71 #define VI_K_FUN1 (char)138 // Function Key F1
72 #define VI_K_FUN2 (char)139 // Function Key F2
73 #define VI_K_FUN3 (char)140 // Function Key F3
74 #define VI_K_FUN4 (char)141 // Function Key F4
75 #define VI_K_FUN5 (char)142 // Function Key F5
76 #define VI_K_FUN6 (char)143 // Function Key F6
77 #define VI_K_FUN7 (char)144 // Function Key F7
78 #define VI_K_FUN8 (char)145 // Function Key F8
79 #define VI_K_FUN9 (char)146 // Function Key F9
80 #define VI_K_FUN10 (char)147 // Function Key F10
81 #define VI_K_FUN11 (char)148 // Function Key F11
82 #define VI_K_FUN12 (char)149 // Function Key F12
84 /* vt102 typical ESC sequence */
85 /* terminal standout start/normal ESC sequence */
86 static const char SOs[] ALIGN1 = "\033[7m";
87 static const char SOn[] ALIGN1 = "\033[0m";
88 /* terminal bell sequence */
89 static const char bell[] ALIGN1 = "\007";
90 /* Clear-end-of-line and Clear-end-of-screen ESC sequence */
91 static const char Ceol[] ALIGN1 = "\033[0K";
92 static const char Ceos[] ALIGN1 = "\033[0J";
93 /* Cursor motion arbitrary destination ESC sequence */
94 static const char CMrc[] ALIGN1 = "\033[%d;%dH";
95 /* Cursor motion up and down ESC sequence */
96 static const char CMup[] ALIGN1 = "\033[A";
97 static const char CMdown[] ALIGN1 = "\n";
103 FORWARD = 1, // code depends on "1" for array index
104 BACK = -1, // code depends on "-1" for array index
105 LIMITED = 0, // how much of text[] in char_search
106 FULL = 1, // how much of text[] in char_search
108 S_BEFORE_WS = 1, // used in skip_thing() for moving "dot"
109 S_TO_WS = 2, // used in skip_thing() for moving "dot"
110 S_OVER_WS = 3, // used in skip_thing() for moving "dot"
111 S_END_PUNCT = 4, // used in skip_thing() for moving "dot"
112 S_END_ALNUM = 5, // used in skip_thing() for moving "dot"
116 /* vi.c expects chars to be unsigned. */
117 /* busybox build system provides that, but it's better */
118 /* to audit and fix the source */
121 /* many references - keep near the top of globals */
122 char *text, *end; // pointers to the user data in memory
123 char *dot; // where all the action takes place
124 int text_size; // size of the allocated buffer
128 #define VI_AUTOINDENT 1
129 #define VI_SHOWMATCH 2
130 #define VI_IGNORECASE 4
131 #define VI_ERR_METHOD 8
132 #define autoindent (vi_setops & VI_AUTOINDENT)
133 #define showmatch (vi_setops & VI_SHOWMATCH )
134 #define ignorecase (vi_setops & VI_IGNORECASE)
135 /* indicate error with beep or flash */
136 #define err_method (vi_setops & VI_ERR_METHOD)
138 #if ENABLE_FEATURE_VI_READONLY
139 smallint readonly_mode;
140 #define SET_READONLY_FILE(flags) ((flags) |= 0x01)
141 #define SET_READONLY_MODE(flags) ((flags) |= 0x02)
142 #define UNSET_READONLY_FILE(flags) ((flags) &= 0xfe)
144 #define SET_READONLY_FILE(flags) ((void)0)
145 #define SET_READONLY_MODE(flags) ((void)0)
146 #define UNSET_READONLY_FILE(flags) ((void)0)
149 smallint editing; // >0 while we are editing a file
150 // [code audit says "can be 0 or 1 only"]
151 smallint cmd_mode; // 0=command 1=insert 2=replace
152 int file_modified; // buffer contents changed (counter, not flag!)
153 int last_file_modified; // = -1;
154 int fn_start; // index of first cmd line file name
155 int save_argc; // how many file names on cmd line
156 int cmdcnt; // repetition count
157 unsigned rows, columns; // the terminal screen is this size
158 int crow, ccol; // cursor is on Crow x Ccol
159 int offset; // chars scrolled off the screen to the left
160 int have_status_msg; // is default edit status needed?
161 // [don't make smallint!]
162 int last_status_cksum; // hash of current status line
163 char *current_filename;
164 char *screenbegin; // index into text[], of top line on the screen
165 char *screen; // pointer to the virtual screen buffer
166 int screensize; // and its size
168 char erase_char; // the users erase character
169 char last_input_char; // last char read from user
170 char last_forward_char; // last char searched for with 'f'
172 #if ENABLE_FEATURE_VI_DOT_CMD
173 smallint adding2q; // are we currently adding user input to q
174 int lmc_len; // length of last_modifying_cmd
175 char *ioq, *ioq_start; // pointer to string for get_one_char to "read"
177 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
178 int last_row; // where the cursor was last moved to
180 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
183 #if ENABLE_FEATURE_VI_DOT_CMD || ENABLE_FEATURE_VI_YANKMARK
184 char *modifying_cmds; // cmds that modify text[]
186 #if ENABLE_FEATURE_VI_SEARCH
187 char *last_search_pattern; // last pattern from a '/' or '?' search
191 #if ENABLE_FEATURE_VI_YANKMARK
192 char *edit_file__cur_line;
194 int refresh__old_offset;
195 int format_edit_status__tot;
197 /* a few references only */
198 #if ENABLE_FEATURE_VI_YANKMARK
199 int YDreg, Ureg; // default delete register and orig line for "U"
200 char *reg[28]; // named register a-z, "D", and "U" 0-25,26,27
201 char *mark[28]; // user marks points somewhere in text[]- a-z and previous context ''
202 char *context_start, *context_end;
204 #if ENABLE_FEATURE_VI_USE_SIGNALS
205 sigjmp_buf restart; // catch_sig()
207 struct termios term_orig, term_vi; // remember what the cooked mode was
208 #if ENABLE_FEATURE_VI_COLON
209 char *initial_cmds[3]; // currently 2 entries, NULL terminated
211 // Should be just enough to hold a key sequence,
212 // but CRASME mode uses it as generated command buffer too
213 #if ENABLE_FEATURE_VI_CRASHME
214 char readbuffer[128];
218 #define STATUS_BUFFER_LEN 200
219 char status_buffer[STATUS_BUFFER_LEN]; // messages to the user
220 #if ENABLE_FEATURE_VI_DOT_CMD
221 char last_modifying_cmd[MAX_INPUT_LEN]; // last modifying cmd for "."
223 char get_input_line__buf[MAX_INPUT_LEN]; /* former static */
225 char scr_out_buf[MAX_SCR_COLS + MAX_TABSTOP * 2];
227 #define G (*ptr_to_globals)
228 #define text (G.text )
229 #define text_size (G.text_size )
234 #define vi_setops (G.vi_setops )
235 #define editing (G.editing )
236 #define cmd_mode (G.cmd_mode )
237 #define file_modified (G.file_modified )
238 #define last_file_modified (G.last_file_modified )
239 #define fn_start (G.fn_start )
240 #define save_argc (G.save_argc )
241 #define cmdcnt (G.cmdcnt )
242 #define rows (G.rows )
243 #define columns (G.columns )
244 #define crow (G.crow )
245 #define ccol (G.ccol )
246 #define offset (G.offset )
247 #define status_buffer (G.status_buffer )
248 #define have_status_msg (G.have_status_msg )
249 #define last_status_cksum (G.last_status_cksum )
250 #define current_filename (G.current_filename )
251 #define screen (G.screen )
252 #define screensize (G.screensize )
253 #define screenbegin (G.screenbegin )
254 #define tabstop (G.tabstop )
255 #define erase_char (G.erase_char )
256 #define last_input_char (G.last_input_char )
257 #define last_forward_char (G.last_forward_char )
258 #if ENABLE_FEATURE_VI_READONLY
259 #define readonly_mode (G.readonly_mode )
261 #define readonly_mode 0
263 #define adding2q (G.adding2q )
264 #define lmc_len (G.lmc_len )
266 #define ioq_start (G.ioq_start )
267 #define last_row (G.last_row )
268 #define my_pid (G.my_pid )
269 #define modifying_cmds (G.modifying_cmds )
270 #define last_search_pattern (G.last_search_pattern)
271 #define chars_to_parse (G.chars_to_parse )
273 #define edit_file__cur_line (G.edit_file__cur_line)
274 #define refresh__old_offset (G.refresh__old_offset)
275 #define format_edit_status__tot (G.format_edit_status__tot)
277 #define YDreg (G.YDreg )
278 #define Ureg (G.Ureg )
279 #define mark (G.mark )
280 #define context_start (G.context_start )
281 #define context_end (G.context_end )
282 #define restart (G.restart )
283 #define term_orig (G.term_orig )
284 #define term_vi (G.term_vi )
285 #define initial_cmds (G.initial_cmds )
286 #define readbuffer (G.readbuffer )
287 #define scr_out_buf (G.scr_out_buf )
288 #define last_modifying_cmd (G.last_modifying_cmd )
289 #define get_input_line__buf (G.get_input_line__buf)
291 #define INIT_G() do { \
292 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
293 last_file_modified = -1; \
297 static int init_text_buffer(char *); // init from file or create new
298 static void edit_file(char *); // edit one file
299 static void do_cmd(char); // execute a command
300 static int next_tabstop(int);
301 static void sync_cursor(char *, int *, int *); // synchronize the screen cursor to dot
302 static char *begin_line(char *); // return pointer to cur line B-o-l
303 static char *end_line(char *); // return pointer to cur line E-o-l
304 static char *prev_line(char *); // return pointer to prev line B-o-l
305 static char *next_line(char *); // return pointer to next line B-o-l
306 static char *end_screen(void); // get pointer to last char on screen
307 static int count_lines(char *, char *); // count line from start to stop
308 static char *find_line(int); // find begining of line #li
309 static char *move_to_col(char *, int); // move "p" to column l
310 static void dot_left(void); // move dot left- dont leave line
311 static void dot_right(void); // move dot right- dont leave line
312 static void dot_begin(void); // move dot to B-o-l
313 static void dot_end(void); // move dot to E-o-l
314 static void dot_next(void); // move dot to next line B-o-l
315 static void dot_prev(void); // move dot to prev line B-o-l
316 static void dot_scroll(int, int); // move the screen up or down
317 static void dot_skip_over_ws(void); // move dot pat WS
318 static void dot_delete(void); // delete the char at 'dot'
319 static char *bound_dot(char *); // make sure text[0] <= P < "end"
320 static char *new_screen(int, int); // malloc virtual screen memory
321 static char *char_insert(char *, char); // insert the char c at 'p'
322 static char *stupid_insert(char *, char); // stupidly insert the char c at 'p'
323 static int find_range(char **, char **, char); // return pointers for an object
324 static int st_test(char *, int, int, char *); // helper for skip_thing()
325 static char *skip_thing(char *, int, int, int); // skip some object
326 static char *find_pair(char *, char); // find matching pair () [] {}
327 static char *text_hole_delete(char *, char *); // at "p", delete a 'size' byte hole
328 static char *text_hole_make(char *, int); // at "p", make a 'size' byte hole
329 static char *yank_delete(char *, char *, int, int); // yank text[] into register then delete
330 static void show_help(void); // display some help info
331 static void rawmode(void); // set "raw" mode on tty
332 static void cookmode(void); // return to "cooked" mode on tty
333 // sleep for 'h' 1/100 seconds, return 1/0 if stdin is (ready for read)/(not ready)
334 static int mysleep(int);
335 static char readit(void); // read (maybe cursor) key from stdin
336 static char get_one_char(void); // read 1 char from stdin
337 static int file_size(const char *); // what is the byte size of "fn"
338 #if ENABLE_FEATURE_VI_READONLY
339 static int file_insert(const char *, char *, int);
341 static int file_insert(const char *, char *);
343 static int file_write(char *, char *, char *);
344 #if !ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
345 #define place_cursor(a, b, optimize) place_cursor(a, b)
347 static void place_cursor(int, int, int);
348 static void screen_erase(void);
349 static void clear_to_eol(void);
350 static void clear_to_eos(void);
351 static void standout_start(void); // send "start reverse video" sequence
352 static void standout_end(void); // send "end reverse video" sequence
353 static void flash(int); // flash the terminal screen
354 static void show_status_line(void); // put a message on the bottom line
355 static void status_line(const char *, ...); // print to status buf
356 static void status_line_bold(const char *, ...);
357 static void not_implemented(const char *); // display "Not implemented" message
358 static int format_edit_status(void); // format file status on status line
359 static void redraw(int); // force a full screen refresh
360 static char* format_line(char* /*, int*/);
361 static void refresh(int); // update the terminal from screen[]
363 static void Indicate_Error(void); // use flash or beep to indicate error
364 #define indicate_error(c) Indicate_Error()
365 static void Hit_Return(void);
367 #if ENABLE_FEATURE_VI_SEARCH
368 static char *char_search(char *, const char *, int, int); // search for pattern starting at p
369 static int mycmp(const char *, const char *, int); // string cmp based in "ignorecase"
371 #if ENABLE_FEATURE_VI_COLON
372 static char *get_one_address(char *, int *); // get colon addr, if present
373 static char *get_address(char *, int *, int *); // get two colon addrs, if present
374 static void colon(char *); // execute the "colon" mode cmds
376 #if ENABLE_FEATURE_VI_USE_SIGNALS
377 static void winch_sig(int); // catch window size changes
378 static void suspend_sig(int); // catch ctrl-Z
379 static void catch_sig(int); // catch ctrl-C and alarm time-outs
381 #if ENABLE_FEATURE_VI_DOT_CMD
382 static void start_new_cmd_q(char); // new queue for command
383 static void end_cmd_q(void); // stop saving input chars
385 #define end_cmd_q() ((void)0)
387 #if ENABLE_FEATURE_VI_SETOPTS
388 static void showmatching(char *); // show the matching pair () [] {}
390 #if ENABLE_FEATURE_VI_YANKMARK || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) || ENABLE_FEATURE_VI_CRASHME
391 static char *string_insert(char *, char *); // insert the string at 'p'
393 #if ENABLE_FEATURE_VI_YANKMARK
394 static char *text_yank(char *, char *, int); // save copy of "p" into a register
395 static char what_reg(void); // what is letter of current YDreg
396 static void check_context(char); // remember context for '' command
398 #if ENABLE_FEATURE_VI_CRASHME
399 static void crash_dummy();
400 static void crash_test();
401 static int crashme = 0;
405 static void write1(const char *out)
410 int vi_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
411 int vi_main(int argc, char **argv)
417 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
420 #if ENABLE_FEATURE_VI_CRASHME
421 srand((long) my_pid);
423 #ifdef NO_SUCH_APPLET_YET
424 /* If we aren't "vi", we are "view" */
425 if (ENABLE_FEATURE_VI_READONLY && applet_name[2]) {
426 SET_READONLY_MODE(readonly_mode);
430 vi_setops = VI_AUTOINDENT | VI_SHOWMATCH | VI_IGNORECASE;
431 #if ENABLE_FEATURE_VI_DOT_CMD || ENABLE_FEATURE_VI_YANKMARK
432 modifying_cmds = (char *) "aAcCdDiIJoOpPrRsxX<>~"; // cmds modifying text[]
435 // 1- process $HOME/.exrc file (not inplemented yet)
436 // 2- process EXINIT variable from environment
437 // 3- process command line args
438 #if ENABLE_FEATURE_VI_COLON
440 char *p = getenv("EXINIT");
442 initial_cmds[0] = xstrndup(p, MAX_INPUT_LEN);
445 while ((c = getopt(argc, argv, "hCRH" USE_FEATURE_VI_COLON("c:"))) != -1) {
447 #if ENABLE_FEATURE_VI_CRASHME
452 #if ENABLE_FEATURE_VI_READONLY
453 case 'R': // Read-only flag
454 SET_READONLY_MODE(readonly_mode);
457 #if ENABLE_FEATURE_VI_COLON
458 case 'c': // cmd line vi command
460 initial_cmds[initial_cmds[0] != 0] = xstrndup(optarg, MAX_INPUT_LEN);
472 // The argv array can be used by the ":next" and ":rewind" commands
474 fn_start = optind; // remember first file name for :next and :rew
477 //----- This is the main file handling loop --------------
478 if (optind >= argc) {
481 for (; optind < argc; optind++) {
482 edit_file(argv[optind]);
485 //-----------------------------------------------------------
490 /* read text from file or create an empty buf */
491 /* will also update current_filename */
492 static int init_text_buffer(char *fn)
495 int size = file_size(fn); // file size. -1 means does not exist.
497 /* allocate/reallocate text buffer */
499 text_size = size + 10240;
500 screenbegin = dot = end = text = xzalloc(text_size);
502 if (fn != current_filename) {
503 free(current_filename);
504 current_filename = xstrdup(fn);
507 // file dont exist. Start empty buf with dummy line
508 char_insert(text, '\n');
511 rc = file_insert(fn, text
512 USE_FEATURE_VI_READONLY(, 1));
515 last_file_modified = -1;
516 #if ENABLE_FEATURE_VI_YANKMARK
517 /* init the marks. */
518 memset(mark, 0, sizeof(mark));
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 if (ENABLE_FEATURE_VI_WIN_RESIZE) {
540 get_terminal_width_height(0, &columns, &rows);
541 if (rows > MAX_SCR_ROWS) rows = MAX_SCR_ROWS;
542 if (columns > MAX_SCR_COLS) columns = MAX_SCR_COLS;
544 new_screen(rows, columns); // get memory for virtual screen
545 init_text_buffer(fn);
547 #if ENABLE_FEATURE_VI_YANKMARK
548 YDreg = 26; // default Yank/Delete reg
549 Ureg = 27; // hold orig line for "U" cmd
550 mark[26] = mark[27] = text; // init "previous context"
553 last_forward_char = last_input_char = '\0';
557 #if ENABLE_FEATURE_VI_USE_SIGNALS
559 signal(SIGWINCH, winch_sig);
560 signal(SIGTSTP, suspend_sig);
561 sig = sigsetjmp(restart, 1);
563 screenbegin = dot = text;
567 cmd_mode = 0; // 0=command 1=insert 2='R'eplace
570 offset = 0; // no horizontal offset
572 #if ENABLE_FEATURE_VI_DOT_CMD
574 ioq = ioq_start = NULL;
579 #if ENABLE_FEATURE_VI_COLON
584 while ((p = initial_cmds[n])) {
594 free(initial_cmds[n]);
595 initial_cmds[n] = NULL;
600 redraw(FALSE); // dont force every col re-draw
601 //------This is the main Vi cmd handling loop -----------------------
602 while (editing > 0) {
603 #if ENABLE_FEATURE_VI_CRASHME
605 if ((end - text) > 1) {
606 crash_dummy(); // generate a random command
609 dot = string_insert(text, "\n\n##### Ran out of text to work on. #####\n\n"); // insert the string
614 last_input_char = c = get_one_char(); // get a cmd from user
615 #if ENABLE_FEATURE_VI_YANKMARK
616 // save a copy of the current line- for the 'U" command
617 if (begin_line(dot) != cur_line) {
618 cur_line = begin_line(dot);
619 text_yank(begin_line(dot), end_line(dot), Ureg);
622 #if ENABLE_FEATURE_VI_DOT_CMD
623 // These are commands that change text[].
624 // Remember the input for the "." command
625 if (!adding2q && ioq_start == NULL
626 && strchr(modifying_cmds, c)
631 do_cmd(c); // execute the user command
633 // poll to see if there is input already waiting. if we are
634 // not able to display output fast enough to keep up, skip
635 // the display update until we catch up with input.
636 if (mysleep(0) == 0) {
637 // no input pending- so update output
641 #if ENABLE_FEATURE_VI_CRASHME
643 crash_test(); // test editor variables
646 //-------------------------------------------------------------------
648 place_cursor(rows, 0, FALSE); // go to bottom of screen
649 clear_to_eol(); // Erase to end of line
654 //----- The Colon commands -------------------------------------
655 #if ENABLE_FEATURE_VI_COLON
656 static char *get_one_address(char *p, int *addr) // get colon addr, if present
660 USE_FEATURE_VI_YANKMARK(char c;)
661 USE_FEATURE_VI_SEARCH(char *pat;)
663 *addr = -1; // assume no addr
664 if (*p == '.') { // the current line
667 *addr = count_lines(text, q);
669 #if ENABLE_FEATURE_VI_YANKMARK
670 else if (*p == '\'') { // is this a mark addr
674 if (c >= 'a' && c <= 'z') {
677 q = mark[(unsigned char) c];
678 if (q != NULL) { // is mark valid
679 *addr = count_lines(text, q); // count lines
684 #if ENABLE_FEATURE_VI_SEARCH
685 else if (*p == '/') { // a search pattern
686 q = strchrnul(++p, '/');
687 pat = xstrndup(p, q - p); // save copy of pattern
691 q = char_search(dot, pat, FORWARD, FULL);
693 *addr = count_lines(text, q);
698 else if (*p == '$') { // the last line in file
700 q = begin_line(end - 1);
701 *addr = count_lines(text, q);
702 } else if (isdigit(*p)) { // specific line number
703 sscanf(p, "%d%n", addr, &st);
706 // unrecognised address - assume -1
712 static char *get_address(char *p, int *b, int *e) // get two colon addrs, if present
714 //----- get the address' i.e., 1,3 'a,'b -----
715 // get FIRST addr, if present
717 p++; // skip over leading spaces
718 if (*p == '%') { // alias for 1,$
721 *e = count_lines(text, end-1);
724 p = get_one_address(p, b);
727 if (*p == ',') { // is there a address separator
731 // get SECOND addr, if present
732 p = get_one_address(p, e);
736 p++; // skip over trailing spaces
740 #if ENABLE_FEATURE_VI_SET && ENABLE_FEATURE_VI_SETOPTS
741 static void setops(const char *args, const char *opname, int flg_no,
742 const char *short_opname, int opt)
744 const char *a = args + flg_no;
745 int l = strlen(opname) - 1; /* opname have + ' ' */
747 if (strncasecmp(a, opname, l) == 0
748 || strncasecmp(a, short_opname, 2) == 0
758 // buf must be no longer than MAX_INPUT_LEN!
759 static void colon(char *buf)
761 char c, *orig_buf, *buf1, *q, *r;
762 char *fn, cmd[MAX_INPUT_LEN], args[MAX_INPUT_LEN];
763 int i, l, li, ch, b, e;
764 int useforce, forced = FALSE;
766 // :3154 // if (-e line 3154) goto it else stay put
767 // :4,33w! foo // write a portion of buffer to file "foo"
768 // :w // write all of buffer to current file
770 // :q! // quit- dont care about modified file
771 // :'a,'z!sort -u // filter block through sort
772 // :'f // goto mark "f"
773 // :'fl // list literal the mark "f" line
774 // :.r bar // read file "bar" into buffer before dot
775 // :/123/,/abc/d // delete lines from "123" line to "abc" line
776 // :/xyz/ // goto the "xyz" line
777 // :s/find/replace/ // substitute pattern "find" with "replace"
778 // :!<cmd> // run <cmd> then return
784 buf++; // move past the ':'
788 q = text; // assume 1,$ for the range
790 li = count_lines(text, end - 1);
791 fn = current_filename;
793 // look for optional address(es) :. :1 :1,9 :'q,'a :%
794 buf = get_address(buf, &b, &e);
796 // remember orig command line
799 // get the COMMAND into cmd[]
801 while (*buf != '\0') {
808 while (isblank(*buf))
812 buf1 = last_char_is(cmd, '!');
815 *buf1 = '\0'; // get rid of !
818 // if there is only one addr, then the addr
819 // is the line number of the single line the
820 // user wants. So, reset the end
821 // pointer to point at end of the "b" line
822 q = find_line(b); // what line is #b
827 // we were given two addrs. change the
828 // end pointer to the addr given by user.
829 r = find_line(e); // what line is #e
833 // ------------ now look for the command ------------
835 if (i == 0) { // :123CR goto line #123
837 dot = find_line(b); // what line is #b
841 #if ENABLE_FEATURE_ALLOW_EXEC
842 else if (strncmp(cmd, "!", 1) == 0) { // run a cmd
844 // :!ls run the <cmd>
845 place_cursor(rows - 1, 0, FALSE); // go to Status line
846 clear_to_eol(); // clear the line
848 retcode = system(orig_buf + 1); // run the cmd
850 printf("\nshell returned %i\n\n", retcode);
852 Hit_Return(); // let user see results
855 else if (strncmp(cmd, "=", i) == 0) { // where is the address
856 if (b < 0) { // no addr given- use defaults
857 b = e = count_lines(text, dot);
859 status_line("%d", b);
860 } else if (strncasecmp(cmd, "delete", i) == 0) { // delete lines
861 if (b < 0) { // no addr given- use defaults
862 q = begin_line(dot); // assume .,. for the range
865 dot = yank_delete(q, r, 1, YANKDEL); // save, then delete lines
867 } else if (strncasecmp(cmd, "edit", i) == 0) { // Edit a file
868 // don't edit, if the current file has been modified
869 if (file_modified && !useforce) {
870 status_line_bold("No write since last change (:edit! overrides)");
874 // the user supplied a file name
876 } else if (current_filename && current_filename[0]) {
877 // no user supplied name- use the current filename
878 // fn = current_filename; was set by default
880 // no user file name, no current name- punt
881 status_line_bold("No current filename");
885 if (init_text_buffer(fn) < 0)
888 #if ENABLE_FEATURE_VI_YANKMARK
889 if (Ureg >= 0 && Ureg < 28 && reg[Ureg] != 0) {
890 free(reg[Ureg]); // free orig line reg- for 'U'
893 if (YDreg >= 0 && YDreg < 28 && reg[YDreg] != 0) {
894 free(reg[YDreg]); // free default yank/delete register
898 // how many lines in text[]?
899 li = count_lines(text, end - 1);
900 status_line("\"%s\"%s"
901 USE_FEATURE_VI_READONLY("%s")
902 " %dL, %dC", current_filename,
903 (file_size(fn) < 0 ? " [New file]" : ""),
904 USE_FEATURE_VI_READONLY(
905 ((readonly_mode) ? " [Readonly]" : ""),
908 } else if (strncasecmp(cmd, "file", i) == 0) { // what File is this
909 if (b != -1 || e != -1) {
910 not_implemented("No address allowed on this command");
914 // user wants a new filename
915 free(current_filename);
916 current_filename = xstrdup(args);
918 // user wants file status info
919 last_status_cksum = 0; // force status update
921 } else if (strncasecmp(cmd, "features", i) == 0) { // what features are available
922 // print out values of all features
923 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
924 clear_to_eol(); // clear the line
929 } else if (strncasecmp(cmd, "list", i) == 0) { // literal print line
930 if (b < 0) { // no addr given- use defaults
931 q = begin_line(dot); // assume .,. for the range
934 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
935 clear_to_eol(); // clear the line
937 for (; q <= r; q++) {
941 c_is_no_print = (c & 0x80) && !Isprint(c);
948 } else if (c < ' ' || c == 127) {
959 #if ENABLE_FEATURE_VI_SET
963 } else if (strncasecmp(cmd, "quit", i) == 0 // Quit
964 || strncasecmp(cmd, "next", i) == 0 // edit next file
967 // force end of argv list
974 // don't exit if the file been modified
976 status_line_bold("No write since last change (:%s! overrides)",
977 (*cmd == 'q' ? "quit" : "next"));
980 // are there other file to edit
981 if (*cmd == 'q' && optind < save_argc - 1) {
982 status_line_bold("%d more file to edit", (save_argc - optind - 1));
985 if (*cmd == 'n' && optind >= save_argc - 1) {
986 status_line_bold("No more files to edit");
990 } else if (strncasecmp(cmd, "read", i) == 0) { // read file into text[]
993 status_line_bold("No filename given");
996 if (b < 0) { // no addr given- use defaults
997 q = begin_line(dot); // assume "dot"
999 // read after current line- unless user said ":0r foo"
1002 ch = file_insert(fn, q USE_FEATURE_VI_READONLY(, 0));
1004 goto vc1; // nothing was inserted
1005 // how many lines in text[]?
1006 li = count_lines(q, q + ch - 1);
1007 status_line("\"%s\""
1008 USE_FEATURE_VI_READONLY("%s")
1010 USE_FEATURE_VI_READONLY((readonly_mode ? " [Readonly]" : ""),)
1013 // if the insert is before "dot" then we need to update
1018 } else if (strncasecmp(cmd, "rewind", i) == 0) { // rewind cmd line args
1019 if (file_modified && !useforce) {
1020 status_line_bold("No write since last change (:rewind! overrides)");
1022 // reset the filenames to edit
1023 optind = fn_start - 1;
1026 #if ENABLE_FEATURE_VI_SET
1027 } else if (strncasecmp(cmd, "set", i) == 0) { // set or clear features
1028 #if ENABLE_FEATURE_VI_SETOPTS
1031 i = 0; // offset into args
1032 // only blank is regarded as args delmiter. What about tab '\t' ?
1033 if (!args[0] || strcasecmp(args, "all") == 0) {
1034 // print out values of all options
1035 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
1036 clear_to_eol(); // clear the line
1037 printf("----------------------------------------\r\n");
1038 #if ENABLE_FEATURE_VI_SETOPTS
1041 printf("autoindent ");
1047 printf("ignorecase ");
1050 printf("showmatch ");
1051 printf("tabstop=%d ", tabstop);
1056 #if ENABLE_FEATURE_VI_SETOPTS
1059 if (strncasecmp(argp, "no", 2) == 0)
1060 i = 2; // ":set noautoindent"
1061 setops(argp, "autoindent ", i, "ai", VI_AUTOINDENT);
1062 setops(argp, "flash ", i, "fl", VI_ERR_METHOD);
1063 setops(argp, "ignorecase ", i, "ic", VI_IGNORECASE);
1064 setops(argp, "showmatch ", i, "ic", VI_SHOWMATCH);
1066 if (strncasecmp(argp + i, "tabstop=%d ", 7) == 0) {
1067 sscanf(strchr(argp + i, '='), "tabstop=%d" + 7, &ch);
1068 if (ch > 0 && ch <= MAX_TABSTOP)
1071 while (*argp && *argp != ' ')
1072 argp++; // skip to arg delimiter (i.e. blank)
1073 while (*argp && *argp == ' ')
1074 argp++; // skip all delimiting blanks
1076 #endif /* FEATURE_VI_SETOPTS */
1077 #endif /* FEATURE_VI_SET */
1078 #if ENABLE_FEATURE_VI_SEARCH
1079 } else if (strncasecmp(cmd, "s", 1) == 0) { // substitute a pattern with a replacement pattern
1083 // F points to the "find" pattern
1084 // R points to the "replace" pattern
1085 // replace the cmd line delimiters "/" with NULLs
1086 gflag = 0; // global replace flag
1087 c = orig_buf[1]; // what is the delimiter
1088 F = orig_buf + 2; // start of "find"
1089 R = strchr(F, c); // middle delimiter
1090 if (!R) goto colon_s_fail;
1091 *R++ = '\0'; // terminate "find"
1092 buf1 = strchr(R, c);
1093 if (!buf1) goto colon_s_fail;
1094 *buf1++ = '\0'; // terminate "replace"
1095 if (*buf1 == 'g') { // :s/foo/bar/g
1097 gflag++; // turn on gflag
1100 if (b < 0) { // maybe :s/foo/bar/
1101 q = begin_line(dot); // start with cur line
1102 b = count_lines(text, q); // cur line number
1105 e = b; // maybe :.s/foo/bar/
1106 for (i = b; i <= e; i++) { // so, :20,23 s \0 find \0 replace \0
1107 ls = q; // orig line start
1109 buf1 = char_search(q, F, FORWARD, LIMITED); // search cur line only for "find"
1111 // we found the "find" pattern - delete it
1112 text_hole_delete(buf1, buf1 + strlen(F) - 1);
1113 // inset the "replace" patern
1114 string_insert(buf1, R); // insert the string
1115 // check for "global" :s/foo/bar/g
1117 if ((buf1 + strlen(R)) < end_line(ls)) {
1118 q = buf1 + strlen(R);
1119 goto vc4; // don't let q move past cur line
1125 #endif /* FEATURE_VI_SEARCH */
1126 } else if (strncasecmp(cmd, "version", i) == 0) { // show software version
1127 status_line(BB_VER " " BB_BT);
1128 } else if (strncasecmp(cmd, "write", i) == 0 // write text to file
1129 || strncasecmp(cmd, "wq", i) == 0
1130 || strncasecmp(cmd, "wn", i) == 0
1131 || strncasecmp(cmd, "x", i) == 0
1133 // is there a file name to write to?
1137 #if ENABLE_FEATURE_VI_READONLY
1138 if (readonly_mode && !useforce) {
1139 status_line_bold("\"%s\" File is read only", fn);
1143 // how many lines in text[]?
1144 li = count_lines(q, r);
1146 // see if file exists- if not, its just a new file request
1148 // if "fn" is not write-able, chmod u+w
1149 // sprintf(syscmd, "chmod u+w %s", fn);
1153 l = file_write(fn, q, r);
1154 if (useforce && forced) {
1156 // sprintf(syscmd, "chmod u-w %s", fn);
1162 status_line_bold("\"%s\" %s", fn, strerror(errno));
1164 status_line("\"%s\" %dL, %dC", fn, li, l);
1165 if (q == text && r == end - 1 && l == ch) {
1167 last_file_modified = -1;
1169 if ((cmd[0] == 'x' || cmd[1] == 'q' || cmd[1] == 'n' ||
1170 cmd[0] == 'X' || cmd[1] == 'Q' || cmd[1] == 'N')
1175 #if ENABLE_FEATURE_VI_READONLY
1178 #if ENABLE_FEATURE_VI_YANKMARK
1179 } else if (strncasecmp(cmd, "yank", i) == 0) { // yank lines
1180 if (b < 0) { // no addr given- use defaults
1181 q = begin_line(dot); // assume .,. for the range
1184 text_yank(q, r, YDreg);
1185 li = count_lines(q, r);
1186 status_line("Yank %d lines (%d chars) into [%c]",
1187 li, strlen(reg[YDreg]), what_reg());
1191 not_implemented(cmd);
1194 dot = bound_dot(dot); // make sure "dot" is valid
1196 #if ENABLE_FEATURE_VI_SEARCH
1198 status_line(":s expression missing delimiters");
1202 #endif /* FEATURE_VI_COLON */
1204 static void Hit_Return(void)
1209 write1("[Hit return to continue]");
1211 while ((c = get_one_char()) != '\n' && c != '\r')
1213 redraw(TRUE); // force redraw all
1216 static int next_tabstop(int col)
1218 return col + ((tabstop - 1) - (col % tabstop));
1221 //----- Synchronize the cursor to Dot --------------------------
1222 static void sync_cursor(char *d, int *row, int *col)
1224 char *beg_cur; // begin and end of "d" line
1228 beg_cur = begin_line(d); // first char of cur line
1230 if (beg_cur < screenbegin) {
1231 // "d" is before top line on screen
1232 // how many lines do we have to move
1233 cnt = count_lines(beg_cur, screenbegin);
1235 screenbegin = beg_cur;
1236 if (cnt > (rows - 1) / 2) {
1237 // we moved too many lines. put "dot" in middle of screen
1238 for (cnt = 0; cnt < (rows - 1) / 2; cnt++) {
1239 screenbegin = prev_line(screenbegin);
1243 char *end_scr; // begin and end of screen
1244 end_scr = end_screen(); // last char of screen
1245 if (beg_cur > end_scr) {
1246 // "d" is after bottom line on screen
1247 // how many lines do we have to move
1248 cnt = count_lines(end_scr, beg_cur);
1249 if (cnt > (rows - 1) / 2)
1250 goto sc1; // too many lines
1251 for (ro = 0; ro < cnt - 1; ro++) {
1252 // move screen begin the same amount
1253 screenbegin = next_line(screenbegin);
1254 // now, move the end of screen
1255 end_scr = next_line(end_scr);
1256 end_scr = end_line(end_scr);
1260 // "d" is on screen- find out which row
1262 for (ro = 0; ro < rows - 1; ro++) { // drive "ro" to correct row
1268 // find out what col "d" is on
1270 while (tp < d) { // drive "co" to correct column
1271 if (*tp == '\n') //vda || *tp == '\0')
1274 // handle tabs like real vi
1275 if (d == tp && cmd_mode) {
1278 co = next_tabstop(co);
1279 } else if ((unsigned char)*tp < ' ' || *tp == 0x7f) {
1280 co++; // display as ^X, use 2 columns
1286 // "co" is the column where "dot" is.
1287 // The screen has "columns" columns.
1288 // The currently displayed columns are 0+offset -- columns+ofset
1289 // |-------------------------------------------------------------|
1291 // offset | |------- columns ----------------|
1293 // If "co" is already in this range then we do not have to adjust offset
1294 // but, we do have to subtract the "offset" bias from "co".
1295 // If "co" is outside this range then we have to change "offset".
1296 // If the first char of a line is a tab the cursor will try to stay
1297 // in column 7, but we have to set offset to 0.
1299 if (co < 0 + offset) {
1302 if (co >= columns + offset) {
1303 offset = co - columns + 1;
1305 // if the first char of the line is a tab, and "dot" is sitting on it
1306 // force offset to 0.
1307 if (d == beg_cur && *d == '\t') {
1316 //----- Text Movement Routines ---------------------------------
1317 static char *begin_line(char *p) // return pointer to first char cur line
1320 p = memrchr(text, '\n', p - text);
1328 static char *end_line(char *p) // return pointer to NL of cur line
1331 p = memchr(p, '\n', end - p - 1);
1338 static char *dollar_line(char *p) // return pointer to just before NL line
1341 // Try to stay off of the Newline
1342 if (*p == '\n' && (p - begin_line(p)) > 0)
1347 static char *prev_line(char *p) // return pointer first char prev line
1349 p = begin_line(p); // goto begining of cur line
1350 if (p > text && p[-1] == '\n')
1351 p--; // step to prev line
1352 p = begin_line(p); // goto begining of prev line
1356 static char *next_line(char *p) // return pointer first char next line
1359 if (p < end - 1 && *p == '\n')
1360 p++; // step to next line
1364 //----- Text Information Routines ------------------------------
1365 static char *end_screen(void)
1370 // find new bottom line
1372 for (cnt = 0; cnt < rows - 2; cnt++)
1378 // count line from start to stop
1379 static int count_lines(char *start, char *stop)
1384 if (stop < start) { // start and stop are backwards- reverse them
1390 stop = end_line(stop);
1391 while (start <= stop && start <= end - 1) {
1392 start = end_line(start);
1400 static char *find_line(int li) // find begining of line #li
1404 for (q = text; li > 1; li--) {
1410 //----- Dot Movement Routines ----------------------------------
1411 static void dot_left(void)
1413 if (dot > text && dot[-1] != '\n')
1417 static void dot_right(void)
1419 if (dot < end - 1 && *dot != '\n')
1423 static void dot_begin(void)
1425 dot = begin_line(dot); // return pointer to first char cur line
1428 static void dot_end(void)
1430 dot = end_line(dot); // return pointer to last char cur line
1433 static char *move_to_col(char *p, int l)
1439 while (co < l && p < end) {
1440 if (*p == '\n') //vda || *p == '\0')
1443 co = next_tabstop(co);
1444 } else if (*p < ' ' || *p == 127) {
1445 co++; // display as ^X, use 2 columns
1453 static void dot_next(void)
1455 dot = next_line(dot);
1458 static void dot_prev(void)
1460 dot = prev_line(dot);
1463 static void dot_scroll(int cnt, int dir)
1467 for (; cnt > 0; cnt--) {
1470 // ctrl-Y scroll up one line
1471 screenbegin = prev_line(screenbegin);
1474 // ctrl-E scroll down one line
1475 screenbegin = next_line(screenbegin);
1478 // make sure "dot" stays on the screen so we dont scroll off
1479 if (dot < screenbegin)
1481 q = end_screen(); // find new bottom line
1483 dot = begin_line(q); // is dot is below bottom line?
1487 static void dot_skip_over_ws(void)
1490 while (isspace(*dot) && *dot != '\n' && dot < end - 1)
1494 static void dot_delete(void) // delete the char at 'dot'
1496 text_hole_delete(dot, dot);
1499 static char *bound_dot(char *p) // make sure text[0] <= P < "end"
1501 if (p >= end && end > text) {
1503 indicate_error('1');
1507 indicate_error('2');
1512 //----- Helper Utility Routines --------------------------------
1514 //----------------------------------------------------------------
1515 //----- Char Routines --------------------------------------------
1516 /* Chars that are part of a word-
1517 * 0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
1518 * Chars that are Not part of a word (stoppers)
1519 * !"#$%&'()*+,-./:;<=>?@[\]^`{|}~
1520 * Chars that are WhiteSpace
1521 * TAB NEWLINE VT FF RETURN SPACE
1522 * DO NOT COUNT NEWLINE AS WHITESPACE
1525 static char *new_screen(int ro, int co)
1530 screensize = ro * co + 8;
1531 screen = xmalloc(screensize);
1532 // initialize the new screen. assume this will be a empty file.
1534 // non-existent text[] lines start with a tilde (~).
1535 for (li = 1; li < ro - 1; li++) {
1536 screen[(li * co) + 0] = '~';
1541 #if ENABLE_FEATURE_VI_SEARCH
1542 static int mycmp(const char *s1, const char *s2, int len)
1546 i = strncmp(s1, s2, len);
1547 if (ENABLE_FEATURE_VI_SETOPTS && ignorecase) {
1548 i = strncasecmp(s1, s2, len);
1553 // search for pattern starting at p
1554 static char *char_search(char *p, const char *pat, int dir, int range)
1556 #ifndef REGEX_SEARCH
1561 if (dir == FORWARD) {
1562 stop = end - 1; // assume range is p - end-1
1563 if (range == LIMITED)
1564 stop = next_line(p); // range is to next line
1565 for (start = p; start < stop; start++) {
1566 if (mycmp(start, pat, len) == 0) {
1570 } else if (dir == BACK) {
1571 stop = text; // assume range is text - p
1572 if (range == LIMITED)
1573 stop = prev_line(p); // range is to prev line
1574 for (start = p - len; start >= stop; start--) {
1575 if (mycmp(start, pat, len) == 0) {
1580 // pattern not found
1582 #else /* REGEX_SEARCH */
1584 struct re_pattern_buffer preg;
1588 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1594 // assume a LIMITED forward search
1602 // count the number of chars to search over, forward or backward
1606 // RANGE could be negative if we are searching backwards
1609 q = re_compile_pattern(pat, strlen(pat), &preg);
1611 // The pattern was not compiled
1612 status_line_bold("bad search pattern: \"%s\": %s", pat, q);
1613 i = 0; // return p if pattern not compiled
1623 // search for the compiled pattern, preg, in p[]
1624 // range < 0- search backward
1625 // range > 0- search forward
1627 // re_search() < 0 not found or error
1628 // re_search() > 0 index of found pattern
1629 // struct pattern char int int int struct reg
1630 // re_search (*pattern_buffer, *string, size, start, range, *regs)
1631 i = re_search(&preg, q, size, 0, range, 0);
1634 i = 0; // return NULL if pattern not found
1637 if (dir == FORWARD) {
1643 #endif /* REGEX_SEARCH */
1645 #endif /* FEATURE_VI_SEARCH */
1647 static char *char_insert(char *p, char c) // insert the char c at 'p'
1649 if (c == 22) { // Is this an ctrl-V?
1650 p = stupid_insert(p, '^'); // use ^ to indicate literal next
1651 p--; // backup onto ^
1652 refresh(FALSE); // show the ^
1657 } else if (c == 27) { // Is this an ESC?
1660 end_cmd_q(); // stop adding to q
1661 last_status_cksum = 0; // force status update
1662 if ((p > text) && (p[-1] != '\n')) {
1665 } else if (c == erase_char || c == 8 || c == 127) { // Is this a BS
1667 if ((p > text) && (p[-1] != '\n')) {
1669 p = text_hole_delete(p, p); // shrink buffer 1 char
1672 // insert a char into text[]
1673 char *sp; // "save p"
1676 c = '\n'; // translate \r to \n
1677 sp = p; // remember addr of insert
1678 p = stupid_insert(p, c); // insert the char
1679 #if ENABLE_FEATURE_VI_SETOPTS
1680 if (showmatch && strchr(")]}", *sp) != NULL) {
1683 if (autoindent && c == '\n') { // auto indent the new line
1686 q = prev_line(p); // use prev line as templet
1687 for (; isblank(*q); q++) {
1688 p = stupid_insert(p, *q); // insert the char
1696 static char *stupid_insert(char *p, char c) // stupidly insert the char c at 'p'
1698 p = text_hole_make(p, 1);
1700 //file_modified++; - done by text_hole_make()
1704 static int find_range(char **start, char **stop, char c)
1706 char *save_dot, *p, *q, *t;
1707 int cnt, multiline = 0;
1712 if (strchr("cdy><", c)) {
1713 // these cmds operate on whole lines
1714 p = q = begin_line(p);
1715 for (cnt = 1; cnt < cmdcnt; cnt++) {
1719 } else if (strchr("^%$0bBeEfth\b\177", c)) {
1720 // These cmds operate on char positions
1721 do_cmd(c); // execute movement cmd
1723 } else if (strchr("wW", c)) {
1724 do_cmd(c); // execute movement cmd
1725 // if we are at the next word's first char
1726 // step back one char
1727 // but check the possibilities when it is true
1728 if (dot > text && ((isspace(dot[-1]) && !isspace(dot[0]))
1729 || (ispunct(dot[-1]) && !ispunct(dot[0]))
1730 || (isalnum(dot[-1]) && !isalnum(dot[0]))))
1731 dot--; // move back off of next word
1732 if (dot > text && *dot == '\n')
1733 dot--; // stay off NL
1735 } else if (strchr("H-k{", c)) {
1736 // these operate on multi-lines backwards
1737 q = end_line(dot); // find NL
1738 do_cmd(c); // execute movement cmd
1741 } else if (strchr("L+j}\r\n", c)) {
1742 // these operate on multi-lines forwards
1743 p = begin_line(dot);
1744 do_cmd(c); // execute movement cmd
1745 dot_end(); // find NL
1748 // nothing -- this causes any other values of c to
1749 // represent the one-character range under the
1750 // cursor. this is correct for ' ' and 'l', but
1751 // perhaps no others.
1760 // backward char movements don't include start position
1761 if (q > p && strchr("^0bBh\b\177", c)) q--;
1764 for (t = p; t <= q; t++) {
1777 static int st_test(char *p, int type, int dir, char *tested)
1787 if (type == S_BEFORE_WS) {
1789 test = ((!isspace(c)) || c == '\n');
1791 if (type == S_TO_WS) {
1793 test = ((!isspace(c)) || c == '\n');
1795 if (type == S_OVER_WS) {
1797 test = ((isspace(c)));
1799 if (type == S_END_PUNCT) {
1801 test = ((ispunct(c)));
1803 if (type == S_END_ALNUM) {
1805 test = ((isalnum(c)) || c == '_');
1811 static char *skip_thing(char *p, int linecnt, int dir, int type)
1815 while (st_test(p, type, dir, &c)) {
1816 // make sure we limit search to correct number of lines
1817 if (c == '\n' && --linecnt < 1)
1819 if (dir >= 0 && p >= end - 1)
1821 if (dir < 0 && p <= text)
1823 p += dir; // move to next char
1828 // find matching char of pair () [] {}
1829 static char *find_pair(char *p, const char c)
1836 dir = 1; // assume forward
1838 case '(': match = ')'; break;
1839 case '[': match = ']'; break;
1840 case '{': match = '}'; break;
1841 case ')': match = '('; dir = -1; break;
1842 case ']': match = '['; dir = -1; break;
1843 case '}': match = '{'; dir = -1; break;
1845 for (q = p + dir; text <= q && q < end; q += dir) {
1846 // look for match, count levels of pairs (( ))
1848 level++; // increase pair levels
1850 level--; // reduce pair level
1852 break; // found matching pair
1855 q = NULL; // indicate no match
1859 #if ENABLE_FEATURE_VI_SETOPTS
1860 // show the matching char of a pair, () [] {}
1861 static void showmatching(char *p)
1865 // we found half of a pair
1866 q = find_pair(p, *p); // get loc of matching char
1868 indicate_error('3'); // no matching char
1870 // "q" now points to matching pair
1871 save_dot = dot; // remember where we are
1872 dot = q; // go to new loc
1873 refresh(FALSE); // let the user see it
1874 mysleep(40); // give user some time
1875 dot = save_dot; // go back to old loc
1879 #endif /* FEATURE_VI_SETOPTS */
1881 // open a hole in text[]
1882 static char *text_hole_make(char *p, int size) // at "p", make a 'size' byte hole
1886 end += size; // adjust the new END
1887 if (end >= (text + text_size)) {
1889 text_size += end - (text + text_size) + 10240;
1890 new_text = xrealloc(text, text_size);
1891 screenbegin = new_text + (screenbegin - text);
1892 dot = new_text + (dot - text);
1893 end = new_text + (end - text);
1894 p = new_text + (p - text);
1897 memmove(p + size, p, end - p);
1898 memset(p, ' ', size); // clear new hole
1903 // close a hole in text[]
1904 static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclusive
1909 // move forwards, from beginning
1913 if (q < p) { // they are backward- swap them
1917 hole_size = q - p + 1;
1919 if (src < text || src > end)
1921 if (dest < text || dest >= end)
1924 goto thd_atend; // just delete the end of the buffer
1925 memmove(dest, src, cnt);
1927 end = end - hole_size; // adjust the new END
1929 dest = end - 1; // make sure dest in below end-1
1931 dest = end = text; // keep pointers valid
1937 // copy text into register, then delete text.
1938 // if dist <= 0, do not include, or go past, a NewLine
1940 static char *yank_delete(char *start, char *stop, int dist, int yf)
1944 // make sure start <= stop
1946 // they are backwards, reverse them
1952 // we cannot cross NL boundaries
1956 // dont go past a NewLine
1957 for (; p + 1 <= stop; p++) {
1959 stop = p; // "stop" just before NewLine
1965 #if ENABLE_FEATURE_VI_YANKMARK
1966 text_yank(start, stop, YDreg);
1968 if (yf == YANKDEL) {
1969 p = text_hole_delete(start, stop);
1974 static void show_help(void)
1976 puts("These features are available:"
1977 #if ENABLE_FEATURE_VI_SEARCH
1978 "\n\tPattern searches with / and ?"
1980 #if ENABLE_FEATURE_VI_DOT_CMD
1981 "\n\tLast command repeat with \'.\'"
1983 #if ENABLE_FEATURE_VI_YANKMARK
1984 "\n\tLine marking with 'x"
1985 "\n\tNamed buffers with \"x"
1987 #if ENABLE_FEATURE_VI_READONLY
1988 "\n\tReadonly if vi is called as \"view\""
1989 "\n\tReadonly with -R command line arg"
1991 #if ENABLE_FEATURE_VI_SET
1992 "\n\tSome colon mode commands with \':\'"
1994 #if ENABLE_FEATURE_VI_SETOPTS
1995 "\n\tSettable options with \":set\""
1997 #if ENABLE_FEATURE_VI_USE_SIGNALS
1998 "\n\tSignal catching- ^C"
1999 "\n\tJob suspend and resume with ^Z"
2001 #if ENABLE_FEATURE_VI_WIN_RESIZE
2002 "\n\tAdapt to window re-sizes"
2007 #if ENABLE_FEATURE_VI_DOT_CMD
2008 static void start_new_cmd_q(char c)
2010 // get buffer for new cmd
2011 // if there is a current cmd count put it in the buffer first
2013 lmc_len = sprintf(last_modifying_cmd, "%d%c", cmdcnt, c);
2014 else { // just save char c onto queue
2015 last_modifying_cmd[0] = c;
2021 static void end_cmd_q(void)
2023 #if ENABLE_FEATURE_VI_YANKMARK
2024 YDreg = 26; // go back to default Yank/Delete reg
2028 #endif /* FEATURE_VI_DOT_CMD */
2030 #if ENABLE_FEATURE_VI_YANKMARK \
2031 || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) \
2032 || ENABLE_FEATURE_VI_CRASHME
2033 static char *string_insert(char *p, char *s) // insert the string at 'p'
2038 text_hole_make(p, i);
2040 for (cnt = 0; *s != '\0'; s++) {
2044 #if ENABLE_FEATURE_VI_YANKMARK
2045 status_line("Put %d lines (%d chars) from [%c]", cnt, i, what_reg());
2051 #if ENABLE_FEATURE_VI_YANKMARK
2052 static char *text_yank(char *p, char *q, int dest) // copy text into a register
2057 if (q < p) { // they are backwards- reverse them
2064 free(t); // if already a yank register, free it
2065 t = xmalloc(cnt + 1); // get a new register
2066 memset(t, '\0', cnt + 1); // clear new text[]
2067 strncpy(t, p, cnt); // copy text[] into bufer
2072 static char what_reg(void)
2076 c = 'D'; // default to D-reg
2077 if (0 <= YDreg && YDreg <= 25)
2078 c = 'a' + (char) YDreg;
2086 static void check_context(char cmd)
2088 // A context is defined to be "modifying text"
2089 // Any modifying command establishes a new context.
2091 if (dot < context_start || dot > context_end) {
2092 if (strchr(modifying_cmds, cmd) != NULL) {
2093 // we are trying to modify text[]- make this the current context
2094 mark[27] = mark[26]; // move cur to prev
2095 mark[26] = dot; // move local to cur
2096 context_start = prev_line(prev_line(dot));
2097 context_end = next_line(next_line(dot));
2098 //loiter= start_loiter= now;
2103 static char *swap_context(char *p) // goto new context for '' command make this the current context
2107 // the current context is in mark[26]
2108 // the previous context is in mark[27]
2109 // only swap context if other context is valid
2110 if (text <= mark[27] && mark[27] <= end - 1) {
2112 mark[27] = mark[26];
2114 p = mark[26]; // where we are going- previous context
2115 context_start = prev_line(prev_line(prev_line(p)));
2116 context_end = next_line(next_line(next_line(p)));
2120 #endif /* FEATURE_VI_YANKMARK */
2122 //----- Set terminal attributes --------------------------------
2123 static void rawmode(void)
2125 tcgetattr(0, &term_orig);
2126 term_vi = term_orig;
2127 term_vi.c_lflag &= (~ICANON & ~ECHO); // leave ISIG ON- allow intr's
2128 term_vi.c_iflag &= (~IXON & ~ICRNL);
2129 term_vi.c_oflag &= (~ONLCR);
2130 term_vi.c_cc[VMIN] = 1;
2131 term_vi.c_cc[VTIME] = 0;
2132 erase_char = term_vi.c_cc[VERASE];
2133 tcsetattr(0, TCSANOW, &term_vi);
2136 static void cookmode(void)
2139 tcsetattr(0, TCSANOW, &term_orig);
2142 //----- Come here when we get a window resize signal ---------
2143 #if ENABLE_FEATURE_VI_USE_SIGNALS
2144 static void winch_sig(int sig ATTRIBUTE_UNUSED)
2146 // FIXME: do it in main loop!!!
2147 signal(SIGWINCH, winch_sig);
2148 if (ENABLE_FEATURE_VI_WIN_RESIZE) {
2149 get_terminal_width_height(0, &columns, &rows);
2150 if (rows > MAX_SCR_ROWS) rows = MAX_SCR_ROWS;
2151 if (columns > MAX_SCR_COLS) columns = MAX_SCR_COLS;
2153 new_screen(rows, columns); // get memory for virtual screen
2154 redraw(TRUE); // re-draw the screen
2157 //----- Come here when we get a continue signal -------------------
2158 static void cont_sig(int sig ATTRIBUTE_UNUSED)
2160 rawmode(); // terminal to "raw"
2161 last_status_cksum = 0; // force status update
2162 redraw(TRUE); // re-draw the screen
2164 signal(SIGTSTP, suspend_sig);
2165 signal(SIGCONT, SIG_DFL);
2166 kill(my_pid, SIGCONT);
2169 //----- Come here when we get a Suspend signal -------------------
2170 static void suspend_sig(int sig ATTRIBUTE_UNUSED)
2172 place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
2173 clear_to_eol(); // Erase to end of line
2174 cookmode(); // terminal to "cooked"
2176 signal(SIGCONT, cont_sig);
2177 signal(SIGTSTP, SIG_DFL);
2178 kill(my_pid, SIGTSTP);
2181 //----- Come here when we get a signal ---------------------------
2182 static void catch_sig(int sig)
2184 signal(SIGINT, catch_sig);
2186 siglongjmp(restart, sig);
2188 #endif /* FEATURE_VI_USE_SIGNALS */
2190 static int mysleep(int hund) // sleep for 'h' 1/100 seconds
2192 struct pollfd pfd[1];
2195 pfd[0].events = POLLIN;
2196 return safe_poll(pfd, 1, hund*10) > 0;
2199 //----- IO Routines --------------------------------------------
2200 static char readit(void) // read (maybe cursor) key from stdin
2209 static const struct esc_cmds esccmds[] = {
2210 {"OA" , VI_K_UP }, // cursor key Up
2211 {"OB" , VI_K_DOWN }, // cursor key Down
2212 {"OC" , VI_K_RIGHT }, // Cursor Key Right
2213 {"OD" , VI_K_LEFT }, // cursor key Left
2214 {"OH" , VI_K_HOME }, // Cursor Key Home
2215 {"OF" , VI_K_END }, // Cursor Key End
2216 {"[A" , VI_K_UP }, // cursor key Up
2217 {"[B" , VI_K_DOWN }, // cursor key Down
2218 {"[C" , VI_K_RIGHT }, // Cursor Key Right
2219 {"[D" , VI_K_LEFT }, // cursor key Left
2220 {"[H" , VI_K_HOME }, // Cursor Key Home
2221 {"[F" , VI_K_END }, // Cursor Key End
2222 {"[1~" , VI_K_HOME }, // Cursor Key Home
2223 {"[2~" , VI_K_INSERT }, // Cursor Key Insert
2224 {"[3~" , VI_K_DELETE }, // Cursor Key Delete
2225 {"[4~" , VI_K_END }, // Cursor Key End
2226 {"[5~" , VI_K_PAGEUP }, // Cursor Key Page Up
2227 {"[6~" , VI_K_PAGEDOWN}, // Cursor Key Page Down
2228 {"OP" , VI_K_FUN1 }, // Function Key F1
2229 {"OQ" , VI_K_FUN2 }, // Function Key F2
2230 {"OR" , VI_K_FUN3 }, // Function Key F3
2231 {"OS" , VI_K_FUN4 }, // Function Key F4
2232 // careful: these have no terminating NUL!
2233 {"[11~", VI_K_FUN1 }, // Function Key F1
2234 {"[12~", VI_K_FUN2 }, // Function Key F2
2235 {"[13~", VI_K_FUN3 }, // Function Key F3
2236 {"[14~", VI_K_FUN4 }, // Function Key F4
2237 {"[15~", VI_K_FUN5 }, // Function Key F5
2238 {"[17~", VI_K_FUN6 }, // Function Key F6
2239 {"[18~", VI_K_FUN7 }, // Function Key F7
2240 {"[19~", VI_K_FUN8 }, // Function Key F8
2241 {"[20~", VI_K_FUN9 }, // Function Key F9
2242 {"[21~", VI_K_FUN10 }, // Function Key F10
2243 {"[23~", VI_K_FUN11 }, // Function Key F11
2244 {"[24~", VI_K_FUN12 }, // Function Key F12
2246 enum { ESCCMDS_COUNT = ARRAY_SIZE(esccmds) };
2250 // get input from User- are there already input chars in Q?
2252 // the Q is empty, wait for a typed char
2253 n = safe_read(STDIN_FILENO, readbuffer, sizeof(readbuffer));
2255 if (errno == EBADF || errno == EFAULT || errno == EINVAL
2257 editing = 0; // want to exit
2262 if (readbuffer[0] == 27) {
2263 // This is an ESC char. Is this Esc sequence?
2264 // Could be bare Esc key. See if there are any
2265 // more chars to read after the ESC. This would
2266 // be a Function or Cursor Key sequence.
2267 struct pollfd pfd[1];
2269 pfd[0].events = POLLIN;
2270 // keep reading while there are input chars, and room in buffer
2271 // for a complete ESC sequence (assuming 8 chars is enough)
2272 while ((safe_poll(pfd, 1, 0) > 0)
2273 && ((size_t)n <= (sizeof(readbuffer) - 8))
2275 // read the rest of the ESC string
2276 int r = safe_read(STDIN_FILENO, readbuffer + n, sizeof(readbuffer) - n);
2284 if (c == 27 && n > 1) {
2285 // Maybe cursor or function key?
2286 const struct esc_cmds *eindex;
2288 for (eindex = esccmds; eindex < &esccmds[ESCCMDS_COUNT]; eindex++) {
2289 int cnt = strnlen(eindex->seq, 4);
2292 if (strncmp(eindex->seq, readbuffer + 1, cnt) != 0)
2294 c = eindex->val; // magic char value
2295 n = cnt + 1; // squeeze out the ESC sequence
2298 // defined ESC sequence not found
2302 // remove key sequence from Q
2303 chars_to_parse -= n;
2304 memmove(readbuffer, readbuffer + n, sizeof(readbuffer) - n);
2308 //----- IO Routines --------------------------------------------
2309 static char get_one_char(void)
2313 #if ENABLE_FEATURE_VI_DOT_CMD
2315 // we are not adding to the q.
2316 // but, we may be reading from a q
2318 // there is no current q, read from STDIN
2319 c = readit(); // get the users input
2321 // there is a queue to get chars from first
2324 // the end of the q, read from STDIN
2326 ioq_start = ioq = 0;
2327 c = readit(); // get the users input
2331 // adding STDIN chars to q
2332 c = readit(); // get the users input
2333 if (lmc_len >= MAX_INPUT_LEN - 1) {
2334 status_line_bold("last_modifying_cmd overrun");
2336 // add new char to q
2337 last_modifying_cmd[lmc_len++] = c;
2341 c = readit(); // get the users input
2342 #endif /* FEATURE_VI_DOT_CMD */
2346 // Get input line (uses "status line" area)
2347 static char *get_input_line(const char *prompt)
2349 // char [MAX_INPUT_LEN]
2350 #define buf get_input_line__buf
2355 strcpy(buf, prompt);
2356 last_status_cksum = 0; // force status update
2357 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
2358 clear_to_eol(); // clear the line
2359 write1(prompt); // write out the :, /, or ? prompt
2362 while (i < MAX_INPUT_LEN) {
2364 if (c == '\n' || c == '\r' || c == 27)
2365 break; // this is end of input
2366 if (c == erase_char || c == 8 || c == 127) {
2367 // user wants to erase prev char
2369 write1("\b \b"); // erase char on screen
2370 if (i <= 0) // user backs up before b-o-l, exit
2383 static int file_size(const char *fn) // what is the byte size of "fn"
2389 if (fn && fn[0] && stat(fn, &st_buf) == 0) // see if file exists
2390 cnt = (int) st_buf.st_size;
2394 static int file_insert(const char *fn, char *p
2395 USE_FEATURE_VI_READONLY(, int update_ro_status))
2399 struct stat statbuf;
2402 if (stat(fn, &statbuf) < 0) {
2403 status_line_bold("\"%s\" %s", fn, strerror(errno));
2406 if (!S_ISREG(statbuf.st_mode)) {
2407 // This is not a regular file
2408 status_line_bold("\"%s\" Not a regular file", fn);
2411 if (p < text || p > end) {
2412 status_line_bold("Trying to insert file outside of memory");
2416 // read file to buffer
2417 fd = open(fn, O_RDONLY);
2419 status_line_bold("\"%s\" %s", fn, strerror(errno));
2422 size = statbuf.st_size;
2423 p = text_hole_make(p, size);
2424 cnt = safe_read(fd, p, size);
2426 status_line_bold("\"%s\" %s", fn, strerror(errno));
2427 p = text_hole_delete(p, p + size - 1); // un-do buffer insert
2428 } else if (cnt < size) {
2429 // There was a partial read, shrink unused space text[]
2430 p = text_hole_delete(p + cnt, p + (size - cnt) - 1); // un-do buffer insert
2431 status_line_bold("cannot read all of file \"%s\"", fn);
2437 #if ENABLE_FEATURE_VI_READONLY
2438 if (update_ro_status
2439 && ((access(fn, W_OK) < 0) ||
2440 /* root will always have access()
2441 * so we check fileperms too */
2442 !(statbuf.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH))
2445 SET_READONLY_FILE(readonly_mode);
2451 static int file_write(char *fn, char *first, char *last)
2453 int fd, cnt, charcnt;
2456 status_line_bold("No current filename");
2460 /* By popular request we do not open file with O_TRUNC,
2461 * but instead ftruncate() it _after_ successful write.
2462 * Might reduce amount of data lost on power fail etc.
2464 fd = open(fn, (O_WRONLY | O_CREAT), 0666);
2467 cnt = last - first + 1;
2468 charcnt = full_write(fd, first, cnt);
2469 ftruncate(fd, charcnt);
2470 if (charcnt == cnt) {
2472 //file_modified = FALSE;
2480 //----- Terminal Drawing ---------------------------------------
2481 // The terminal is made up of 'rows' line of 'columns' columns.
2482 // classically this would be 24 x 80.
2483 // screen coordinates
2489 // 23,0 ... 23,79 <- status line
2491 //----- Move the cursor to row x col (count from 0, not 1) -------
2492 static void place_cursor(int row, int col, int optimize)
2494 char cm1[sizeof(CMrc) + sizeof(int)*3 * 2];
2497 if (row < 0) row = 0;
2498 if (row >= rows) row = rows - 1;
2499 if (col < 0) col = 0;
2500 if (col >= columns) col = columns - 1;
2502 //----- 1. Try the standard terminal ESC sequence
2503 sprintf(cm1, CMrc, row + 1, col + 1);
2506 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
2507 if (optimize && col < 16) {
2509 SZ_UP = sizeof(CMup),
2510 SZ_DN = sizeof(CMdown),
2511 SEQ_SIZE = SZ_UP > SZ_DN ? SZ_UP : SZ_DN,
2513 char cm2[SEQ_SIZE * 5 + 32]; // bigger than worst case size
2515 int Rrow = last_row;
2516 int diff = Rrow - row;
2518 if (diff < -5 || diff > 5)
2521 //----- find the minimum # of chars to move cursor -------------
2522 //----- 2. Try moving with discreet chars (Newline, [back]space, ...)
2525 // move to the correct row
2526 while (row < Rrow) {
2527 // the cursor has to move up
2531 while (row > Rrow) {
2532 // the cursor has to move down
2533 strcat(cm2, CMdown);
2537 // now move to the correct column
2538 strcat(cm2, "\r"); // start at col 0
2539 // just send out orignal source char to get to correct place
2540 screenp = &screen[row * columns]; // start of screen line
2541 strncat(cm2, screenp, col);
2543 // pick the shortest cursor motion to send out
2544 if (strlen(cm2) < strlen(cm)) {
2550 #endif /* FEATURE_VI_OPTIMIZE_CURSOR */
2554 //----- Erase from cursor to end of line -----------------------
2555 static void clear_to_eol(void)
2557 write1(Ceol); // Erase from cursor to end of line
2560 //----- Erase from cursor to end of screen -----------------------
2561 static void clear_to_eos(void)
2563 write1(Ceos); // Erase from cursor to end of screen
2566 //----- Start standout mode ------------------------------------
2567 static void standout_start(void) // send "start reverse video" sequence
2569 write1(SOs); // Start reverse video mode
2572 //----- End standout mode --------------------------------------
2573 static void standout_end(void) // send "end reverse video" sequence
2575 write1(SOn); // End reverse video mode
2578 //----- Flash the screen --------------------------------------
2579 static void flash(int h)
2581 standout_start(); // send "start reverse video" sequence
2584 standout_end(); // send "end reverse video" sequence
2588 static void Indicate_Error(void)
2590 #if ENABLE_FEATURE_VI_CRASHME
2592 return; // generate a random command
2595 write1(bell); // send out a bell character
2601 //----- Screen[] Routines --------------------------------------
2602 //----- Erase the Screen[] memory ------------------------------
2603 static void screen_erase(void)
2605 memset(screen, ' ', screensize); // clear new screen
2608 static int bufsum(char *buf, int count)
2611 char *e = buf + count;
2614 sum += (unsigned char) *buf++;
2618 //----- Draw the status line at bottom of the screen -------------
2619 static void show_status_line(void)
2621 int cnt = 0, cksum = 0;
2623 // either we already have an error or status message, or we
2625 if (!have_status_msg) {
2626 cnt = format_edit_status();
2627 cksum = bufsum(status_buffer, cnt);
2629 if (have_status_msg || ((cnt > 0 && last_status_cksum != cksum))) {
2630 last_status_cksum = cksum; // remember if we have seen this line
2631 place_cursor(rows - 1, 0, FALSE); // put cursor on status line
2632 write1(status_buffer);
2634 if (have_status_msg) {
2635 if (((int)strlen(status_buffer) - (have_status_msg - 1)) >
2637 have_status_msg = 0;
2640 have_status_msg = 0;
2642 place_cursor(crow, ccol, FALSE); // put cursor back in correct place
2647 //----- format the status buffer, the bottom line of screen ------
2648 // format status buffer, with STANDOUT mode
2649 static void status_line_bold(const char *format, ...)
2653 va_start(args, format);
2654 strcpy(status_buffer, SOs); // Terminal standout mode on
2655 vsprintf(status_buffer + sizeof(SOs)-1, format, args);
2656 strcat(status_buffer, SOn); // Terminal standout mode off
2659 have_status_msg = 1 + sizeof(SOs) + sizeof(SOn) - 2;
2662 // format status buffer
2663 static void status_line(const char *format, ...)
2667 va_start(args, format);
2668 vsprintf(status_buffer, format, args);
2671 have_status_msg = 1;
2674 // copy s to buf, convert unprintable
2675 static void print_literal(char *buf, const char *s)
2688 c_is_no_print = (c & 0x80) && !Isprint(c);
2689 if (c_is_no_print) {
2693 if (c < ' ' || c == 127) {
2706 if (strlen(buf) > MAX_INPUT_LEN - 10) // paranoia
2711 static void not_implemented(const char *s)
2713 char buf[MAX_INPUT_LEN];
2715 print_literal(buf, s);
2716 status_line_bold("\'%s\' is not implemented", buf);
2719 // show file status on status line
2720 static int format_edit_status(void)
2722 static const char cmd_mode_indicator[] ALIGN1 = "-IR-";
2724 #define tot format_edit_status__tot
2726 int cur, percent, ret, trunc_at;
2728 // file_modified is now a counter rather than a flag. this
2729 // helps reduce the amount of line counting we need to do.
2730 // (this will cause a mis-reporting of modified status
2731 // once every MAXINT editing operations.)
2733 // it would be nice to do a similar optimization here -- if
2734 // we haven't done a motion that could have changed which line
2735 // we're on, then we shouldn't have to do this count_lines()
2736 cur = count_lines(text, dot);
2738 // reduce counting -- the total lines can't have
2739 // changed if we haven't done any edits.
2740 if (file_modified != last_file_modified) {
2741 tot = cur + count_lines(dot, end - 1) - 1;
2742 last_file_modified = file_modified;
2745 // current line percent
2746 // ------------- ~~ ----------
2749 percent = (100 * cur) / tot;
2755 trunc_at = columns < STATUS_BUFFER_LEN-1 ?
2756 columns : STATUS_BUFFER_LEN-1;
2758 ret = snprintf(status_buffer, trunc_at+1,
2759 #if ENABLE_FEATURE_VI_READONLY
2760 "%c %s%s%s %d/%d %d%%",
2762 "%c %s%s %d/%d %d%%",
2764 cmd_mode_indicator[cmd_mode & 3],
2765 (current_filename != NULL ? current_filename : "No file"),
2766 #if ENABLE_FEATURE_VI_READONLY
2767 (readonly_mode ? " [Readonly]" : ""),
2769 (file_modified ? " [Modified]" : ""),
2772 if (ret >= 0 && ret < trunc_at)
2773 return ret; /* it all fit */
2775 return trunc_at; /* had to truncate */
2779 //----- Force refresh of all Lines -----------------------------
2780 static void redraw(int full_screen)
2782 place_cursor(0, 0, FALSE); // put cursor in correct place
2783 clear_to_eos(); // tell terminal to erase display
2784 screen_erase(); // erase the internal screen buffer
2785 last_status_cksum = 0; // force status update
2786 refresh(full_screen); // this will redraw the entire display
2790 //----- Format a text[] line into a buffer ---------------------
2791 static char* format_line(char *src /*, int li*/)
2796 char *dest = scr_out_buf; // [MAX_SCR_COLS + MAX_TABSTOP * 2]
2798 c = '~'; // char in col 0 in non-existent lines is '~'
2800 while (co < columns + tabstop) {
2801 // have we gone past the end?
2806 if ((c & 0x80) && !Isprint(c)) {
2809 if (c < ' ' || c == 0x7f) {
2813 while ((co % tabstop) != (tabstop - 1)) {
2821 c += '@'; // Ctrl-X -> 'X'
2826 // discard scrolled-off-to-the-left portion,
2827 // in tabstop-sized pieces
2828 if (ofs >= tabstop && co >= tabstop) {
2829 memmove(dest, dest + tabstop, co);
2836 // check "short line, gigantic offset" case
2839 // discard last scrolled off part
2842 // fill the rest with spaces
2844 memset(&dest[co], ' ', columns - co);
2848 //----- Refresh the changed screen lines -----------------------
2849 // Copy the source line from text[] into the buffer and note
2850 // if the current screenline is different from the new buffer.
2851 // If they differ then that line needs redrawing on the terminal.
2853 static void refresh(int full_screen)
2855 #define old_offset refresh__old_offset
2858 char *tp, *sp; // pointer into text[] and screen[]
2860 if (ENABLE_FEATURE_VI_WIN_RESIZE) {
2861 unsigned c = columns, r = rows;
2862 get_terminal_width_height(0, &columns, &rows);
2863 if (rows > MAX_SCR_ROWS) rows = MAX_SCR_ROWS;
2864 if (columns > MAX_SCR_COLS) columns = MAX_SCR_COLS;
2865 full_screen |= (c - columns) | (r - rows);
2867 sync_cursor(dot, &crow, &ccol); // where cursor will be (on "dot")
2868 tp = screenbegin; // index into text[] of top line
2870 // compare text[] to screen[] and mark screen[] lines that need updating
2871 for (li = 0; li < rows - 1; li++) {
2872 int cs, ce; // column start & end
2874 // format current text line
2875 out_buf = format_line(tp /*, li*/);
2877 // skip to the end of the current text[] line
2879 char *t = memchr(tp, '\n', end - tp);
2880 if (!t) t = end - 1;
2884 // see if there are any changes between vitual screen and out_buf
2885 changed = FALSE; // assume no change
2888 sp = &screen[li * columns]; // start of screen line
2890 // force re-draw of every single column from 0 - columns-1
2893 // compare newly formatted buffer with virtual screen
2894 // look forward for first difference between buf and screen
2895 for (; cs <= ce; cs++) {
2896 if (out_buf[cs] != sp[cs]) {
2897 changed = TRUE; // mark for redraw
2902 // look backward for last difference between out_buf and screen
2903 for (; ce >= cs; ce--) {
2904 if (out_buf[ce] != sp[ce]) {
2905 changed = TRUE; // mark for redraw
2909 // now, cs is index of first diff, and ce is index of last diff
2911 // if horz offset has changed, force a redraw
2912 if (offset != old_offset) {
2917 // make a sanity check of columns indexes
2919 if (ce > columns - 1) ce = columns - 1;
2920 if (cs > ce) { cs = 0; ce = columns - 1; }
2921 // is there a change between vitual screen and out_buf
2923 // copy changed part of buffer to virtual screen
2924 memcpy(sp+cs, out_buf+cs, ce-cs+1);
2926 // move cursor to column of first change
2927 //if (offset != old_offset) {
2928 // // place_cursor is still too stupid
2929 // // to handle offsets correctly
2930 // place_cursor(li, cs, FALSE);
2932 place_cursor(li, cs, TRUE);
2935 // write line out to terminal
2936 fwrite(&sp[cs], ce - cs + 1, 1, stdout);
2940 place_cursor(crow, ccol, TRUE);
2942 old_offset = offset;
2946 //---------------------------------------------------------------------
2947 //----- the Ascii Chart -----------------------------------------------
2949 // 00 nul 01 soh 02 stx 03 etx 04 eot 05 enq 06 ack 07 bel
2950 // 08 bs 09 ht 0a nl 0b vt 0c np 0d cr 0e so 0f si
2951 // 10 dle 11 dc1 12 dc2 13 dc3 14 dc4 15 nak 16 syn 17 etb
2952 // 18 can 19 em 1a sub 1b esc 1c fs 1d gs 1e rs 1f us
2953 // 20 sp 21 ! 22 " 23 # 24 $ 25 % 26 & 27 '
2954 // 28 ( 29 ) 2a * 2b + 2c , 2d - 2e . 2f /
2955 // 30 0 31 1 32 2 33 3 34 4 35 5 36 6 37 7
2956 // 38 8 39 9 3a : 3b ; 3c < 3d = 3e > 3f ?
2957 // 40 @ 41 A 42 B 43 C 44 D 45 E 46 F 47 G
2958 // 48 H 49 I 4a J 4b K 4c L 4d M 4e N 4f O
2959 // 50 P 51 Q 52 R 53 S 54 T 55 U 56 V 57 W
2960 // 58 X 59 Y 5a Z 5b [ 5c \ 5d ] 5e ^ 5f _
2961 // 60 ` 61 a 62 b 63 c 64 d 65 e 66 f 67 g
2962 // 68 h 69 i 6a j 6b k 6c l 6d m 6e n 6f o
2963 // 70 p 71 q 72 r 73 s 74 t 75 u 76 v 77 w
2964 // 78 x 79 y 7a z 7b { 7c | 7d } 7e ~ 7f del
2965 //---------------------------------------------------------------------
2967 //----- Execute a Vi Command -----------------------------------
2968 static void do_cmd(char c)
2970 const char *msg = msg; // for compiler
2971 char c1, *p, *q, *save_dot;
2973 int dir = dir; // for compiler
2976 // c1 = c; // quiet the compiler
2977 // cnt = yf = 0; // quiet the compiler
2978 // msg = p = q = save_dot = buf; // quiet the compiler
2979 memset(buf, '\0', 12);
2983 /* if this is a cursor key, skip these checks */
2996 if (cmd_mode == 2) {
2997 // flip-flop Insert/Replace mode
2998 if (c == VI_K_INSERT)
3000 // we are 'R'eplacing the current *dot with new char
3002 // don't Replace past E-o-l
3003 cmd_mode = 1; // convert to insert
3005 if (1 <= c || Isprint(c)) {
3007 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
3008 dot = char_insert(dot, c); // insert new char
3013 if (cmd_mode == 1) {
3014 // hitting "Insert" twice means "R" replace mode
3015 if (c == VI_K_INSERT) goto dc5;
3016 // insert the char c at "dot"
3017 if (1 <= c || Isprint(c)) {
3018 dot = char_insert(dot, c);
3033 #if ENABLE_FEATURE_VI_CRASHME
3034 case 0x14: // dc4 ctrl-T
3035 crashme = (crashme == 0) ? 1 : 0;
3064 //case 'u': // u- FIXME- there is no undo
3066 default: // unrecognised command
3074 not_implemented(buf);
3075 end_cmd_q(); // stop adding to q
3076 case 0x00: // nul- ignore
3078 case 2: // ctrl-B scroll up full screen
3079 case VI_K_PAGEUP: // Cursor Key Page Up
3080 dot_scroll(rows - 2, -1);
3082 case 4: // ctrl-D scroll down half screen
3083 dot_scroll((rows - 2) / 2, 1);
3085 case 5: // ctrl-E scroll down one line
3088 case 6: // ctrl-F scroll down full screen
3089 case VI_K_PAGEDOWN: // Cursor Key Page Down
3090 dot_scroll(rows - 2, 1);
3092 case 7: // ctrl-G show current status
3093 last_status_cksum = 0; // force status update
3095 case 'h': // h- move left
3096 case VI_K_LEFT: // cursor key Left
3097 case 8: // ctrl-H- move left (This may be ERASE char)
3098 case 0x7f: // DEL- move left (This may be ERASE char)
3104 case 10: // Newline ^J
3105 case 'j': // j- goto next line, same col
3106 case VI_K_DOWN: // cursor key Down
3110 dot_next(); // go to next B-o-l
3111 dot = move_to_col(dot, ccol + offset); // try stay in same col
3113 case 12: // ctrl-L force redraw whole screen
3114 case 18: // ctrl-R force redraw
3115 place_cursor(0, 0, FALSE); // put cursor in correct place
3116 clear_to_eos(); // tel terminal to erase display
3118 screen_erase(); // erase the internal screen buffer
3119 last_status_cksum = 0; // force status update
3120 refresh(TRUE); // this will redraw the entire display
3122 case 13: // Carriage Return ^M
3123 case '+': // +- goto next line
3130 case 21: // ctrl-U scroll up half screen
3131 dot_scroll((rows - 2) / 2, -1);
3133 case 25: // ctrl-Y scroll up one line
3139 cmd_mode = 0; // stop insrting
3141 last_status_cksum = 0; // force status update
3143 case ' ': // move right
3144 case 'l': // move right
3145 case VI_K_RIGHT: // Cursor Key Right
3151 #if ENABLE_FEATURE_VI_YANKMARK
3152 case '"': // "- name a register to use for Delete/Yank
3153 c1 = get_one_char();
3161 case '\'': // '- goto a specific mark
3162 c1 = get_one_char();
3167 q = mark[(unsigned char) c1];
3168 if (text <= q && q < end) {
3170 dot_begin(); // go to B-o-l
3173 } else if (c1 == '\'') { // goto previous context
3174 dot = swap_context(dot); // swap current and previous context
3175 dot_begin(); // go to B-o-l
3181 case 'm': // m- Mark a line
3182 // this is really stupid. If there are any inserts or deletes
3183 // between text[0] and dot then this mark will not point to the
3184 // correct location! It could be off by many lines!
3185 // Well..., at least its quick and dirty.
3186 c1 = get_one_char();
3190 // remember the line
3191 mark[(int) c1] = dot;
3196 case 'P': // P- Put register before
3197 case 'p': // p- put register after
3200 status_line_bold("Nothing in register %c", what_reg());
3203 // are we putting whole lines or strings
3204 if (strchr(p, '\n') != NULL) {
3206 dot_begin(); // putting lines- Put above
3209 // are we putting after very last line?
3210 if (end_line(dot) == (end - 1)) {
3211 dot = end; // force dot to end of text[]
3213 dot_next(); // next line, then put before
3218 dot_right(); // move to right, can move to NL
3220 dot = string_insert(dot, p); // insert the string
3221 end_cmd_q(); // stop adding to q
3223 case 'U': // U- Undo; replace current line with original version
3224 if (reg[Ureg] != 0) {
3225 p = begin_line(dot);
3227 p = text_hole_delete(p, q); // delete cur line
3228 p = string_insert(p, reg[Ureg]); // insert orig line
3233 #endif /* FEATURE_VI_YANKMARK */
3234 case '$': // $- goto end of line
3235 case VI_K_END: // Cursor Key End
3239 dot = end_line(dot);
3241 case '%': // %- find matching char of pair () [] {}
3242 for (q = dot; q < end && *q != '\n'; q++) {
3243 if (strchr("()[]{}", *q) != NULL) {
3244 // we found half of a pair
3245 p = find_pair(q, *q);
3257 case 'f': // f- forward to a user specified char
3258 last_forward_char = get_one_char(); // get the search char
3260 // dont separate these two commands. 'f' depends on ';'
3262 //**** fall through to ... ';'
3263 case ';': // ;- look at rest of line for last forward char
3267 if (last_forward_char == 0)
3270 while (q < end - 1 && *q != '\n' && *q != last_forward_char) {
3273 if (*q == last_forward_char)
3276 case ',': // repeat latest 'f' in opposite direction
3280 if (last_forward_char == 0)
3283 while (q >= text && *q != '\n' && *q != last_forward_char) {
3286 if (q >= text && *q == last_forward_char)
3290 case '-': // -- goto prev line
3297 #if ENABLE_FEATURE_VI_DOT_CMD
3298 case '.': // .- repeat the last modifying command
3299 // Stuff the last_modifying_cmd back into stdin
3300 // and let it be re-executed.
3302 last_modifying_cmd[lmc_len] = 0;
3303 ioq = ioq_start = xstrdup(last_modifying_cmd);
3307 #if ENABLE_FEATURE_VI_SEARCH
3308 case '?': // /- search for a pattern
3309 case '/': // /- search for a pattern
3312 q = get_input_line(buf); // get input line- use "status line"
3313 if (q[0] && !q[1]) {
3314 if (last_search_pattern[0])
3315 last_search_pattern[0] = c;
3316 goto dc3; // if no pat re-use old pat
3318 if (q[0]) { // strlen(q) > 1: new pat- save it and find
3319 // there is a new pat
3320 free(last_search_pattern);
3321 last_search_pattern = xstrdup(q);
3322 goto dc3; // now find the pattern
3324 // user changed mind and erased the "/"- do nothing
3326 case 'N': // N- backward search for last pattern
3330 dir = BACK; // assume BACKWARD search
3332 if (last_search_pattern[0] == '?') {
3336 goto dc4; // now search for pattern
3338 case 'n': // n- repeat search for last pattern
3339 // search rest of text[] starting at next char
3340 // if search fails return orignal "p" not the "p+1" address
3345 if (last_search_pattern == 0) {
3346 msg = "No previous regular expression";
3349 if (last_search_pattern[0] == '/') {
3350 dir = FORWARD; // assume FORWARD search
3353 if (last_search_pattern[0] == '?') {
3358 q = char_search(p, last_search_pattern + 1, dir, FULL);
3360 dot = q; // good search, update "dot"
3364 // no pattern found between "dot" and "end"- continue at top
3369 q = char_search(p, last_search_pattern + 1, dir, FULL);
3370 if (q != NULL) { // found something
3371 dot = q; // found new pattern- goto it
3372 msg = "search hit BOTTOM, continuing at TOP";
3374 msg = "search hit TOP, continuing at BOTTOM";
3377 msg = "Pattern not found";
3381 status_line_bold("%s", msg);
3383 case '{': // {- move backward paragraph
3384 q = char_search(dot, "\n\n", BACK, FULL);
3385 if (q != NULL) { // found blank line
3386 dot = next_line(q); // move to next blank line
3389 case '}': // }- move forward paragraph
3390 q = char_search(dot, "\n\n", FORWARD, FULL);
3391 if (q != NULL) { // found blank line
3392 dot = next_line(q); // move to next blank line
3395 #endif /* FEATURE_VI_SEARCH */
3396 case '0': // 0- goto begining of line
3406 if (c == '0' && cmdcnt < 1) {
3407 dot_begin(); // this was a standalone zero
3409 cmdcnt = cmdcnt * 10 + (c - '0'); // this 0 is part of a number
3412 case ':': // :- the colon mode commands
3413 p = get_input_line(":"); // get input line- use "status line"
3414 #if ENABLE_FEATURE_VI_COLON
3415 colon(p); // execute the command
3418 p++; // move past the ':'
3422 if (strncasecmp(p, "quit", cnt) == 0
3423 || strncasecmp(p, "q!", cnt) == 0 // delete lines
3425 if (file_modified && p[1] != '!') {
3426 status_line_bold("No write since last change (:quit! overrides)");
3430 } else if (strncasecmp(p, "write", cnt) == 0
3431 || strncasecmp(p, "wq", cnt) == 0
3432 || strncasecmp(p, "wn", cnt) == 0
3433 || strncasecmp(p, "x", cnt) == 0
3435 cnt = file_write(current_filename, text, end - 1);
3438 status_line_bold("Write error: %s", strerror(errno));
3441 last_file_modified = -1;
3442 status_line("\"%s\" %dL, %dC", current_filename, count_lines(text, end - 1), cnt);
3443 if (p[0] == 'x' || p[1] == 'q' || p[1] == 'n'
3444 || p[0] == 'X' || p[1] == 'Q' || p[1] == 'N'
3449 } else if (strncasecmp(p, "file", cnt) == 0) {
3450 last_status_cksum = 0; // force status update
3451 } else if (sscanf(p, "%d", &j) > 0) {
3452 dot = find_line(j); // go to line # j
3454 } else { // unrecognised cmd
3457 #endif /* !FEATURE_VI_COLON */
3459 case '<': // <- Left shift something
3460 case '>': // >- Right shift something
3461 cnt = count_lines(text, dot); // remember what line we are on
3462 c1 = get_one_char(); // get the type of thing to delete
3463 find_range(&p, &q, c1);
3464 yank_delete(p, q, 1, YANKONLY); // save copy before change
3467 i = count_lines(p, q); // # of lines we are shifting
3468 for ( ; i > 0; i--, p = next_line(p)) {
3470 // shift left- remove tab or 8 spaces
3472 // shrink buffer 1 char
3473 text_hole_delete(p, p);
3474 } else if (*p == ' ') {
3475 // we should be calculating columns, not just SPACE
3476 for (j = 0; *p == ' ' && j < tabstop; j++) {
3477 text_hole_delete(p, p);
3480 } else if (c == '>') {
3481 // shift right -- add tab or 8 spaces
3482 char_insert(p, '\t');
3485 dot = find_line(cnt); // what line were we on
3487 end_cmd_q(); // stop adding to q
3489 case 'A': // A- append at e-o-l
3490 dot_end(); // go to e-o-l
3491 //**** fall through to ... 'a'
3492 case 'a': // a- append after current char
3497 case 'B': // B- back a blank-delimited Word
3498 case 'E': // E- end of a blank-delimited word
3499 case 'W': // W- forward a blank-delimited word
3506 if (c == 'W' || isspace(dot[dir])) {
3507 dot = skip_thing(dot, 1, dir, S_TO_WS);
3508 dot = skip_thing(dot, 2, dir, S_OVER_WS);
3511 dot = skip_thing(dot, 1, dir, S_BEFORE_WS);
3513 case 'C': // C- Change to e-o-l
3514 case 'D': // D- delete to e-o-l
3516 dot = dollar_line(dot); // move to before NL
3517 // copy text into a register and delete
3518 dot = yank_delete(save_dot, dot, 0, YANKDEL); // delete to e-o-l
3520 goto dc_i; // start inserting
3521 #if ENABLE_FEATURE_VI_DOT_CMD
3523 end_cmd_q(); // stop adding to q
3526 case 'g': // 'gg' goto a line number (from vim)
3527 // (default to first line in file)
3528 c1 = get_one_char();
3533 not_implemented(buf);
3539 case 'G': // G- goto to a line number (default= E-O-F)
3540 dot = end - 1; // assume E-O-F
3542 dot = find_line(cmdcnt); // what line is #cmdcnt
3546 case 'H': // H- goto top line on screen
3548 if (cmdcnt > (rows - 1)) {
3549 cmdcnt = (rows - 1);
3556 case 'I': // I- insert before first non-blank
3559 //**** fall through to ... 'i'
3560 case 'i': // i- insert before current char
3561 case VI_K_INSERT: // Cursor Key Insert
3563 cmd_mode = 1; // start insrting
3565 case 'J': // J- join current and next lines together
3569 dot_end(); // move to NL
3570 if (dot < end - 1) { // make sure not last char in text[]
3571 *dot++ = ' '; // replace NL with space
3573 while (isblank(*dot)) { // delete leading WS
3577 end_cmd_q(); // stop adding to q
3579 case 'L': // L- goto bottom line on screen
3581 if (cmdcnt > (rows - 1)) {
3582 cmdcnt = (rows - 1);
3590 case 'M': // M- goto middle line on screen
3592 for (cnt = 0; cnt < (rows-1) / 2; cnt++)
3593 dot = next_line(dot);
3595 case 'O': // O- open a empty line above
3597 p = begin_line(dot);
3598 if (p[-1] == '\n') {
3600 case 'o': // o- open a empty line below; Yes, I know it is in the middle of the "if (..."
3602 dot = char_insert(dot, '\n');
3605 dot = char_insert(dot, '\n'); // i\n ESC
3610 case 'R': // R- continuous Replace char
3617 case 'X': // X- delete char before dot
3618 case 'x': // x- delete the current char
3619 case 's': // s- substitute the current char
3626 if (dot[dir] != '\n') {
3628 dot--; // delete prev char
3629 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
3632 goto dc_i; // start insrting
3633 end_cmd_q(); // stop adding to q
3635 case 'Z': // Z- if modified, {write}; exit
3636 // ZZ means to save file (if necessary), then exit
3637 c1 = get_one_char();
3642 if (file_modified) {
3643 if (ENABLE_FEATURE_VI_READONLY && readonly_mode) {
3644 status_line_bold("\"%s\" File is read only", current_filename);
3647 cnt = file_write(current_filename, text, end - 1);
3650 status_line_bold("Write error: %s", strerror(errno));
3651 } else if (cnt == (end - 1 - text + 1)) {
3658 case '^': // ^- move to first non-blank on line
3662 case 'b': // b- back a word
3663 case 'e': // e- end of word
3670 if ((dot + dir) < text || (dot + dir) > end - 1)
3673 if (isspace(*dot)) {
3674 dot = skip_thing(dot, (c == 'e') ? 2 : 1, dir, S_OVER_WS);
3676 if (isalnum(*dot) || *dot == '_') {
3677 dot = skip_thing(dot, 1, dir, S_END_ALNUM);
3678 } else if (ispunct(*dot)) {
3679 dot = skip_thing(dot, 1, dir, S_END_PUNCT);
3682 case 'c': // c- change something
3683 case 'd': // d- delete something
3684 #if ENABLE_FEATURE_VI_YANKMARK
3685 case 'y': // y- yank something
3686 case 'Y': // Y- Yank a line
3689 int yf, ml, whole = 0;
3690 yf = YANKDEL; // assume either "c" or "d"
3691 #if ENABLE_FEATURE_VI_YANKMARK
3692 if (c == 'y' || c == 'Y')
3697 c1 = get_one_char(); // get the type of thing to delete
3698 // determine range, and whether it spans lines
3699 ml = find_range(&p, &q, c1);
3700 if (c1 == 27) { // ESC- user changed mind and wants out
3701 c = c1 = 27; // Escape- do nothing
3702 } else if (strchr("wW", c1)) {
3704 // don't include trailing WS as part of word
3705 while (isblank(*q)) {
3706 if (q <= text || q[-1] == '\n')
3711 dot = yank_delete(p, q, ml, yf); // delete word
3712 } else if (strchr("^0bBeEft%$ lh\b\177", c1)) {
3713 // partial line copy text into a register and delete
3714 dot = yank_delete(p, q, ml, yf); // delete word
3715 } else if (strchr("cdykjHL+-{}\r\n", c1)) {
3716 // whole line copy text into a register and delete
3717 dot = yank_delete(p, q, ml, yf); // delete lines
3720 // could not recognize object
3721 c = c1 = 27; // error-
3727 dot = char_insert(dot, '\n');
3728 // on the last line of file don't move to prev line
3729 if (whole && dot != (end-1)) {
3732 } else if (c == 'd') {
3738 // if CHANGING, not deleting, start inserting after the delete
3740 strcpy(buf, "Change");
3741 goto dc_i; // start inserting
3744 strcpy(buf, "Delete");
3746 #if ENABLE_FEATURE_VI_YANKMARK
3747 if (c == 'y' || c == 'Y') {
3748 strcpy(buf, "Yank");
3752 for (cnt = 0; p <= q; p++) {
3756 status_line("%s %d lines (%d chars) using [%c]",
3757 buf, cnt, strlen(reg[YDreg]), what_reg());
3759 end_cmd_q(); // stop adding to q
3763 case 'k': // k- goto prev line, same col
3764 case VI_K_UP: // cursor key Up
3769 dot = move_to_col(dot, ccol + offset); // try stay in same col
3771 case 'r': // r- replace the current char with user input
3772 c1 = get_one_char(); // get the replacement char
3777 end_cmd_q(); // stop adding to q
3779 case 't': // t- move to char prior to next x
3780 last_forward_char = get_one_char();
3782 if (*dot == last_forward_char)
3784 last_forward_char= 0;
3786 case 'w': // w- forward a word
3790 if (isalnum(*dot) || *dot == '_') { // we are on ALNUM
3791 dot = skip_thing(dot, 1, FORWARD, S_END_ALNUM);
3792 } else if (ispunct(*dot)) { // we are on PUNCT
3793 dot = skip_thing(dot, 1, FORWARD, S_END_PUNCT);
3796 dot++; // move over word
3797 if (isspace(*dot)) {
3798 dot = skip_thing(dot, 2, FORWARD, S_OVER_WS);
3802 c1 = get_one_char(); // get the replacement char
3805 cnt = (rows - 2) / 2; // put dot at center
3807 cnt = rows - 2; // put dot at bottom
3808 screenbegin = begin_line(dot); // start dot at top
3809 dot_scroll(cnt, -1);
3811 case '|': // |- move to column "cmdcnt"
3812 dot = move_to_col(dot, cmdcnt - 1); // try to move to column
3814 case '~': // ~- flip the case of letters a-z -> A-Z
3818 if (islower(*dot)) {
3819 *dot = toupper(*dot);
3821 } else if (isupper(*dot)) {
3822 *dot = tolower(*dot);
3826 end_cmd_q(); // stop adding to q
3828 //----- The Cursor and Function Keys -----------------------------
3829 case VI_K_HOME: // Cursor Key Home
3832 // The Fn keys could point to do_macro which could translate them
3833 case VI_K_FUN1: // Function Key F1
3834 case VI_K_FUN2: // Function Key F2
3835 case VI_K_FUN3: // Function Key F3
3836 case VI_K_FUN4: // Function Key F4
3837 case VI_K_FUN5: // Function Key F5
3838 case VI_K_FUN6: // Function Key F6
3839 case VI_K_FUN7: // Function Key F7
3840 case VI_K_FUN8: // Function Key F8
3841 case VI_K_FUN9: // Function Key F9
3842 case VI_K_FUN10: // Function Key F10
3843 case VI_K_FUN11: // Function Key F11
3844 case VI_K_FUN12: // Function Key F12
3849 // if text[] just became empty, add back an empty line
3851 char_insert(text, '\n'); // start empty buf with dummy line
3854 // it is OK for dot to exactly equal to end, otherwise check dot validity
3856 dot = bound_dot(dot); // make sure "dot" is valid
3858 #if ENABLE_FEATURE_VI_YANKMARK
3859 check_context(c); // update the current context
3863 cmdcnt = 0; // cmd was not a number, reset cmdcnt
3864 cnt = dot - begin_line(dot);
3865 // Try to stay off of the Newline
3866 if (*dot == '\n' && cnt > 0 && cmd_mode == 0)
3870 /* NB! the CRASHME code is unmaintained, and doesn't currently build */
3871 #if ENABLE_FEATURE_VI_CRASHME
3872 static int totalcmds = 0;
3873 static int Mp = 85; // Movement command Probability
3874 static int Np = 90; // Non-movement command Probability
3875 static int Dp = 96; // Delete command Probability
3876 static int Ip = 97; // Insert command Probability
3877 static int Yp = 98; // Yank command Probability
3878 static int Pp = 99; // Put command Probability
3879 static int M = 0, N = 0, I = 0, D = 0, Y = 0, P = 0, U = 0;
3880 static const char chars[20] = "\t012345 abcdABCD-=.$";
3881 static const char *const words[20] = {
3882 "this", "is", "a", "test",
3883 "broadcast", "the", "emergency", "of",
3884 "system", "quick", "brown", "fox",
3885 "jumped", "over", "lazy", "dogs",
3886 "back", "January", "Febuary", "March"
3888 static const char *const lines[20] = {
3889 "You should have received a copy of the GNU General Public License\n",
3890 "char c, cm, *cmd, *cmd1;\n",
3891 "generate a command by percentages\n",
3892 "Numbers may be typed as a prefix to some commands.\n",
3893 "Quit, discarding changes!\n",
3894 "Forced write, if permission originally not valid.\n",
3895 "In general, any ex or ed command (such as substitute or delete).\n",
3896 "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
3897 "Please get w/ me and I will go over it with you.\n",
3898 "The following is a list of scheduled, committed changes.\n",
3899 "1. Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
3900 "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
3901 "Any question about transactions please contact Sterling Huxley.\n",
3902 "I will try to get back to you by Friday, December 31.\n",
3903 "This Change will be implemented on Friday.\n",
3904 "Let me know if you have problems accessing this;\n",
3905 "Sterling Huxley recently added you to the access list.\n",
3906 "Would you like to go to lunch?\n",
3907 "The last command will be automatically run.\n",
3908 "This is too much english for a computer geek.\n",
3910 static char *multilines[20] = {
3911 "You should have received a copy of the GNU General Public License\n",
3912 "char c, cm, *cmd, *cmd1;\n",
3913 "generate a command by percentages\n",
3914 "Numbers may be typed as a prefix to some commands.\n",
3915 "Quit, discarding changes!\n",
3916 "Forced write, if permission originally not valid.\n",
3917 "In general, any ex or ed command (such as substitute or delete).\n",
3918 "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
3919 "Please get w/ me and I will go over it with you.\n",
3920 "The following is a list of scheduled, committed changes.\n",
3921 "1. Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
3922 "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
3923 "Any question about transactions please contact Sterling Huxley.\n",
3924 "I will try to get back to you by Friday, December 31.\n",
3925 "This Change will be implemented on Friday.\n",
3926 "Let me know if you have problems accessing this;\n",
3927 "Sterling Huxley recently added you to the access list.\n",
3928 "Would you like to go to lunch?\n",
3929 "The last command will be automatically run.\n",
3930 "This is too much english for a computer geek.\n",
3933 // create a random command to execute
3934 static void crash_dummy()
3936 static int sleeptime; // how long to pause between commands
3937 char c, cm, *cmd, *cmd1;
3938 int i, cnt, thing, rbi, startrbi, percent;
3940 // "dot" movement commands
3941 cmd1 = " \n\r\002\004\005\006\025\0310^$-+wWeEbBhjklHL";
3943 // is there already a command running?
3944 if (chars_to_parse > 0)
3948 sleeptime = 0; // how long to pause between commands
3949 memset(readbuffer, '\0', sizeof(readbuffer));
3950 // generate a command by percentages
3951 percent = (int) lrand48() % 100; // get a number from 0-99
3952 if (percent < Mp) { // Movement commands
3953 // available commands
3956 } else if (percent < Np) { // non-movement commands
3957 cmd = "mz<>\'\""; // available commands
3959 } else if (percent < Dp) { // Delete commands
3960 cmd = "dx"; // available commands
3962 } else if (percent < Ip) { // Inset commands
3963 cmd = "iIaAsrJ"; // available commands
3965 } else if (percent < Yp) { // Yank commands
3966 cmd = "yY"; // available commands
3968 } else if (percent < Pp) { // Put commands
3969 cmd = "pP"; // available commands
3972 // We do not know how to handle this command, try again
3976 // randomly pick one of the available cmds from "cmd[]"
3977 i = (int) lrand48() % strlen(cmd);
3979 if (strchr(":\024", cm))
3980 goto cd0; // dont allow colon or ctrl-T commands
3981 readbuffer[rbi++] = cm; // put cmd into input buffer
3983 // now we have the command-
3984 // there are 1, 2, and multi char commands
3985 // find out which and generate the rest of command as necessary
3986 if (strchr("dmryz<>\'\"", cm)) { // 2-char commands
3987 cmd1 = " \n\r0$^-+wWeEbBhjklHL";
3988 if (cm == 'm' || cm == '\'' || cm == '\"') { // pick a reg[]
3989 cmd1 = "abcdefghijklmnopqrstuvwxyz";
3991 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
3993 readbuffer[rbi++] = c; // add movement to input buffer
3995 if (strchr("iIaAsc", cm)) { // multi-char commands
3997 // change some thing
3998 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
4000 readbuffer[rbi++] = c; // add movement to input buffer
4002 thing = (int) lrand48() % 4; // what thing to insert
4003 cnt = (int) lrand48() % 10; // how many to insert
4004 for (i = 0; i < cnt; i++) {
4005 if (thing == 0) { // insert chars
4006 readbuffer[rbi++] = chars[((int) lrand48() % strlen(chars))];
4007 } else if (thing == 1) { // insert words
4008 strcat(readbuffer, words[(int) lrand48() % 20]);
4009 strcat(readbuffer, " ");
4010 sleeptime = 0; // how fast to type
4011 } else if (thing == 2) { // insert lines
4012 strcat(readbuffer, lines[(int) lrand48() % 20]);
4013 sleeptime = 0; // how fast to type
4014 } else { // insert multi-lines
4015 strcat(readbuffer, multilines[(int) lrand48() % 20]);
4016 sleeptime = 0; // how fast to type
4019 strcat(readbuffer, "\033");
4021 chars_to_parse = strlen(readbuffer);
4025 mysleep(sleeptime); // sleep 1/100 sec
4028 // test to see if there are any errors
4029 static void crash_test()
4031 static time_t oldtim;
4038 strcat(msg, "end<text ");
4040 if (end > textend) {
4041 strcat(msg, "end>textend ");
4044 strcat(msg, "dot<text ");
4047 strcat(msg, "dot>end ");
4049 if (screenbegin < text) {
4050 strcat(msg, "screenbegin<text ");
4052 if (screenbegin > end - 1) {
4053 strcat(msg, "screenbegin>end-1 ");
4057 printf("\n\n%d: \'%c\' %s\n\n\n%s[Hit return to continue]%s",
4058 totalcmds, last_input_char, msg, SOs, SOn);
4060 while (safe_read(STDIN_FILENO, d, 1) > 0) {
4061 if (d[0] == '\n' || d[0] == '\r')
4066 if (tim >= (oldtim + 3)) {
4067 sprintf(status_buffer,
4068 "Tot=%d: M=%d N=%d I=%d D=%d Y=%d P=%d U=%d size=%d",
4069 totalcmds, M, N, I, D, Y, P, U, end - text + 1);