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 /* vt102 typical ESC sequence */
61 /* terminal standout start/normal ESC sequence */
62 static const char SOs[] ALIGN1 = "\033[7m";
63 static const char SOn[] ALIGN1 = "\033[0m";
64 /* terminal bell sequence */
65 static const char bell[] ALIGN1 = "\007";
66 /* Clear-end-of-line and Clear-end-of-screen ESC sequence */
67 static const char Ceol[] ALIGN1 = "\033[0K";
68 static const char Ceos[] ALIGN1 = "\033[0J";
69 /* Cursor motion arbitrary destination ESC sequence */
70 static const char CMrc[] ALIGN1 = "\033[%d;%dH";
71 /* Cursor motion up and down ESC sequence */
72 static const char CMup[] ALIGN1 = "\033[A";
73 static const char CMdown[] ALIGN1 = "\n";
75 #if ENABLE_FEATURE_VI_DOT_CMD || ENABLE_FEATURE_VI_YANKMARK
76 // cmds modifying text[]
77 // vda: removed "aAiIs" as they switch us into insert mode
78 // and remembering input for replay after them makes no sense
79 static const char modifying_cmds[] = "cCdDJoOpPrRxX<>~";
85 FORWARD = 1, // code depends on "1" for array index
86 BACK = -1, // code depends on "-1" for array index
87 LIMITED = 0, // how much of text[] in char_search
88 FULL = 1, // how much of text[] in char_search
90 S_BEFORE_WS = 1, // used in skip_thing() for moving "dot"
91 S_TO_WS = 2, // used in skip_thing() for moving "dot"
92 S_OVER_WS = 3, // used in skip_thing() for moving "dot"
93 S_END_PUNCT = 4, // used in skip_thing() for moving "dot"
94 S_END_ALNUM = 5, // used in skip_thing() for moving "dot"
98 /* vi.c expects chars to be unsigned. */
99 /* busybox build system provides that, but it's better */
100 /* to audit and fix the source */
103 /* many references - keep near the top of globals */
104 char *text, *end; // pointers to the user data in memory
105 char *dot; // where all the action takes place
106 int text_size; // size of the allocated buffer
110 #define VI_AUTOINDENT 1
111 #define VI_SHOWMATCH 2
112 #define VI_IGNORECASE 4
113 #define VI_ERR_METHOD 8
114 #define autoindent (vi_setops & VI_AUTOINDENT)
115 #define showmatch (vi_setops & VI_SHOWMATCH )
116 #define ignorecase (vi_setops & VI_IGNORECASE)
117 /* indicate error with beep or flash */
118 #define err_method (vi_setops & VI_ERR_METHOD)
120 #if ENABLE_FEATURE_VI_READONLY
121 smallint readonly_mode;
122 #define SET_READONLY_FILE(flags) ((flags) |= 0x01)
123 #define SET_READONLY_MODE(flags) ((flags) |= 0x02)
124 #define UNSET_READONLY_FILE(flags) ((flags) &= 0xfe)
126 #define SET_READONLY_FILE(flags) ((void)0)
127 #define SET_READONLY_MODE(flags) ((void)0)
128 #define UNSET_READONLY_FILE(flags) ((void)0)
131 smallint editing; // >0 while we are editing a file
132 // [code audit says "can be 0, 1 or 2 only"]
133 smallint cmd_mode; // 0=command 1=insert 2=replace
134 int file_modified; // buffer contents changed (counter, not flag!)
135 int last_file_modified; // = -1;
136 int fn_start; // index of first cmd line file name
137 int save_argc; // how many file names on cmd line
138 int cmdcnt; // repetition count
139 unsigned rows, columns; // the terminal screen is this size
140 int crow, ccol; // cursor is on Crow x Ccol
141 int offset; // chars scrolled off the screen to the left
142 int have_status_msg; // is default edit status needed?
143 // [don't make smallint!]
144 int last_status_cksum; // hash of current status line
145 char *current_filename;
146 char *screenbegin; // index into text[], of top line on the screen
147 char *screen; // pointer to the virtual screen buffer
148 int screensize; // and its size
150 int last_forward_char; // last char searched for with 'f' (int because of Unicode)
151 char erase_char; // the users erase character
152 char last_input_char; // last char read from user
154 #if ENABLE_FEATURE_VI_DOT_CMD
155 smallint adding2q; // are we currently adding user input to q
156 int lmc_len; // length of last_modifying_cmd
157 char *ioq, *ioq_start; // pointer to string for get_one_char to "read"
159 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
160 int last_row; // where the cursor was last moved to
162 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
165 #if ENABLE_FEATURE_VI_SEARCH
166 char *last_search_pattern; // last pattern from a '/' or '?' search
170 #if ENABLE_FEATURE_VI_YANKMARK
171 char *edit_file__cur_line;
173 int refresh__old_offset;
174 int format_edit_status__tot;
176 /* a few references only */
177 #if ENABLE_FEATURE_VI_YANKMARK
178 int YDreg, Ureg; // default delete register and orig line for "U"
179 char *reg[28]; // named register a-z, "D", and "U" 0-25,26,27
180 char *mark[28]; // user marks points somewhere in text[]- a-z and previous context ''
181 char *context_start, *context_end;
183 #if ENABLE_FEATURE_VI_USE_SIGNALS
184 sigjmp_buf restart; // catch_sig()
186 struct termios term_orig, term_vi; // remember what the cooked mode was
187 #if ENABLE_FEATURE_VI_COLON
188 char *initial_cmds[3]; // currently 2 entries, NULL terminated
190 // Should be just enough to hold a key sequence,
191 // but CRASHME mode uses it as generated command buffer too
192 #if ENABLE_FEATURE_VI_CRASHME
193 char readbuffer[128];
195 char readbuffer[KEYCODE_BUFFER_SIZE];
197 #define STATUS_BUFFER_LEN 200
198 char status_buffer[STATUS_BUFFER_LEN]; // messages to the user
199 #if ENABLE_FEATURE_VI_DOT_CMD
200 char last_modifying_cmd[MAX_INPUT_LEN]; // last modifying cmd for "."
202 char get_input_line__buf[MAX_INPUT_LEN]; /* former static */
204 char scr_out_buf[MAX_SCR_COLS + MAX_TABSTOP * 2];
206 #define G (*ptr_to_globals)
207 #define text (G.text )
208 #define text_size (G.text_size )
213 #define vi_setops (G.vi_setops )
214 #define editing (G.editing )
215 #define cmd_mode (G.cmd_mode )
216 #define file_modified (G.file_modified )
217 #define last_file_modified (G.last_file_modified )
218 #define fn_start (G.fn_start )
219 #define save_argc (G.save_argc )
220 #define cmdcnt (G.cmdcnt )
221 #define rows (G.rows )
222 #define columns (G.columns )
223 #define crow (G.crow )
224 #define ccol (G.ccol )
225 #define offset (G.offset )
226 #define status_buffer (G.status_buffer )
227 #define have_status_msg (G.have_status_msg )
228 #define last_status_cksum (G.last_status_cksum )
229 #define current_filename (G.current_filename )
230 #define screen (G.screen )
231 #define screensize (G.screensize )
232 #define screenbegin (G.screenbegin )
233 #define tabstop (G.tabstop )
234 #define last_forward_char (G.last_forward_char )
235 #define erase_char (G.erase_char )
236 #define last_input_char (G.last_input_char )
237 #if ENABLE_FEATURE_VI_READONLY
238 #define readonly_mode (G.readonly_mode )
240 #define readonly_mode 0
242 #define adding2q (G.adding2q )
243 #define lmc_len (G.lmc_len )
245 #define ioq_start (G.ioq_start )
246 #define last_row (G.last_row )
247 #define my_pid (G.my_pid )
248 #define last_search_pattern (G.last_search_pattern)
250 #define edit_file__cur_line (G.edit_file__cur_line)
251 #define refresh__old_offset (G.refresh__old_offset)
252 #define format_edit_status__tot (G.format_edit_status__tot)
254 #define YDreg (G.YDreg )
255 #define Ureg (G.Ureg )
256 #define mark (G.mark )
257 #define context_start (G.context_start )
258 #define context_end (G.context_end )
259 #define restart (G.restart )
260 #define term_orig (G.term_orig )
261 #define term_vi (G.term_vi )
262 #define initial_cmds (G.initial_cmds )
263 #define readbuffer (G.readbuffer )
264 #define scr_out_buf (G.scr_out_buf )
265 #define last_modifying_cmd (G.last_modifying_cmd )
266 #define get_input_line__buf (G.get_input_line__buf)
268 #define INIT_G() do { \
269 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
270 last_file_modified = -1; \
271 /* "" but has space for 2 chars: */ \
272 IF_FEATURE_VI_SEARCH(last_search_pattern = xzalloc(2);) \
276 static int init_text_buffer(char *); // init from file or create new
277 static void edit_file(char *); // edit one file
278 static void do_cmd(int); // execute a command
279 static int next_tabstop(int);
280 static void sync_cursor(char *, int *, int *); // synchronize the screen cursor to dot
281 static char *begin_line(char *); // return pointer to cur line B-o-l
282 static char *end_line(char *); // return pointer to cur line E-o-l
283 static char *prev_line(char *); // return pointer to prev line B-o-l
284 static char *next_line(char *); // return pointer to next line B-o-l
285 static char *end_screen(void); // get pointer to last char on screen
286 static int count_lines(char *, char *); // count line from start to stop
287 static char *find_line(int); // find begining of line #li
288 static char *move_to_col(char *, int); // move "p" to column l
289 static void dot_left(void); // move dot left- dont leave line
290 static void dot_right(void); // move dot right- dont leave line
291 static void dot_begin(void); // move dot to B-o-l
292 static void dot_end(void); // move dot to E-o-l
293 static void dot_next(void); // move dot to next line B-o-l
294 static void dot_prev(void); // move dot to prev line B-o-l
295 static void dot_scroll(int, int); // move the screen up or down
296 static void dot_skip_over_ws(void); // move dot pat WS
297 static void dot_delete(void); // delete the char at 'dot'
298 static char *bound_dot(char *); // make sure text[0] <= P < "end"
299 static char *new_screen(int, int); // malloc virtual screen memory
300 static char *char_insert(char *, char); // insert the char c at 'p'
301 // might reallocate text[]! use p += stupid_insert(p, ...),
302 // and be careful to not use pointers into potentially freed text[]!
303 static uintptr_t stupid_insert(char *, char); // stupidly insert the char c at 'p'
304 static int find_range(char **, char **, char); // return pointers for an object
305 static int st_test(char *, int, int, char *); // helper for skip_thing()
306 static char *skip_thing(char *, int, int, int); // skip some object
307 static char *find_pair(char *, char); // find matching pair () [] {}
308 static char *text_hole_delete(char *, char *); // at "p", delete a 'size' byte hole
309 // might reallocate text[]! use p += text_hole_make(p, ...),
310 // and be careful to not use pointers into potentially freed text[]!
311 static uintptr_t text_hole_make(char *, int); // at "p", make a 'size' byte hole
312 static char *yank_delete(char *, char *, int, int); // yank text[] into register then delete
313 static void show_help(void); // display some help info
314 static void rawmode(void); // set "raw" mode on tty
315 static void cookmode(void); // return to "cooked" mode on tty
316 // sleep for 'h' 1/100 seconds, return 1/0 if stdin is (ready for read)/(not ready)
317 static int mysleep(int);
318 static int readit(void); // read (maybe cursor) key from stdin
319 static int get_one_char(void); // read 1 char from stdin
320 static int file_size(const char *); // what is the byte size of "fn"
321 #if !ENABLE_FEATURE_VI_READONLY
322 #define file_insert(fn, p, update_ro_status) file_insert(fn, p)
324 // file_insert might reallocate text[]!
325 static int file_insert(const char *, char *, int);
326 static int file_write(char *, char *, char *);
327 #if !ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
328 #define place_cursor(a, b, optimize) place_cursor(a, b)
330 static void place_cursor(int, int, int);
331 static void screen_erase(void);
332 static void clear_to_eol(void);
333 static void clear_to_eos(void);
334 static void go_bottom_and_clear_to_eol(void);
335 static void standout_start(void); // send "start reverse video" sequence
336 static void standout_end(void); // send "end reverse video" sequence
337 static void flash(int); // flash the terminal screen
338 static void show_status_line(void); // put a message on the bottom line
339 static void status_line(const char *, ...); // print to status buf
340 static void status_line_bold(const char *, ...);
341 static void not_implemented(const char *); // display "Not implemented" message
342 static int format_edit_status(void); // format file status on status line
343 static void redraw(int); // force a full screen refresh
344 static char* format_line(char* /*, int*/);
345 static void refresh(int); // update the terminal from screen[]
347 static void Indicate_Error(void); // use flash or beep to indicate error
348 #define indicate_error(c) Indicate_Error()
349 static void Hit_Return(void);
351 #if ENABLE_FEATURE_VI_SEARCH
352 static char *char_search(char *, const char *, int, int); // search for pattern starting at p
353 static int mycmp(const char *, const char *, int); // string cmp based in "ignorecase"
355 #if ENABLE_FEATURE_VI_COLON
356 static char *get_one_address(char *, int *); // get colon addr, if present
357 static char *get_address(char *, int *, int *); // get two colon addrs, if present
358 static void colon(char *); // execute the "colon" mode cmds
360 #if ENABLE_FEATURE_VI_USE_SIGNALS
361 static void winch_sig(int); // catch window size changes
362 static void suspend_sig(int); // catch ctrl-Z
363 static void catch_sig(int); // catch ctrl-C and alarm time-outs
365 #if ENABLE_FEATURE_VI_DOT_CMD
366 static void start_new_cmd_q(char); // new queue for command
367 static void end_cmd_q(void); // stop saving input chars
369 #define end_cmd_q() ((void)0)
371 #if ENABLE_FEATURE_VI_SETOPTS
372 static void showmatching(char *); // show the matching pair () [] {}
374 #if ENABLE_FEATURE_VI_YANKMARK || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) || ENABLE_FEATURE_VI_CRASHME
375 // might reallocate text[]! use p += string_insert(p, ...),
376 // and be careful to not use pointers into potentially freed text[]!
377 static uintptr_t string_insert(char *, const char *); // insert the string at 'p'
379 #if ENABLE_FEATURE_VI_YANKMARK
380 static char *text_yank(char *, char *, int); // save copy of "p" into a register
381 static char what_reg(void); // what is letter of current YDreg
382 static void check_context(char); // remember context for '' command
384 #if ENABLE_FEATURE_VI_CRASHME
385 static void crash_dummy();
386 static void crash_test();
387 static int crashme = 0;
391 static void write1(const char *out)
396 int vi_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
397 int vi_main(int argc, char **argv)
403 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
406 #if ENABLE_FEATURE_VI_CRASHME
407 srand((long) my_pid);
409 #ifdef NO_SUCH_APPLET_YET
410 /* If we aren't "vi", we are "view" */
411 if (ENABLE_FEATURE_VI_READONLY && applet_name[2]) {
412 SET_READONLY_MODE(readonly_mode);
416 vi_setops = VI_AUTOINDENT | VI_SHOWMATCH | VI_IGNORECASE;
417 // 1- process $HOME/.exrc file (not inplemented yet)
418 // 2- process EXINIT variable from environment
419 // 3- process command line args
420 #if ENABLE_FEATURE_VI_COLON
422 char *p = getenv("EXINIT");
424 initial_cmds[0] = xstrndup(p, MAX_INPUT_LEN);
427 while ((c = getopt(argc, argv, "hCRH" IF_FEATURE_VI_COLON("c:"))) != -1) {
429 #if ENABLE_FEATURE_VI_CRASHME
434 #if ENABLE_FEATURE_VI_READONLY
435 case 'R': // Read-only flag
436 SET_READONLY_MODE(readonly_mode);
439 #if ENABLE_FEATURE_VI_COLON
440 case 'c': // cmd line vi command
442 initial_cmds[initial_cmds[0] != 0] = xstrndup(optarg, MAX_INPUT_LEN);
454 // The argv array can be used by the ":next" and ":rewind" commands
456 fn_start = optind; // remember first file name for :next and :rew
459 //----- This is the main file handling loop --------------
460 if (optind >= argc) {
463 for (; optind < argc; optind++) {
464 edit_file(argv[optind]);
467 //-----------------------------------------------------------
472 /* read text from file or create an empty buf */
473 /* will also update current_filename */
474 static int init_text_buffer(char *fn)
477 int size = file_size(fn); // file size. -1 means does not exist.
479 /* allocate/reallocate text buffer */
481 text_size = size + 10240;
482 screenbegin = dot = end = text = xzalloc(text_size);
484 if (fn != current_filename) {
485 free(current_filename);
486 current_filename = xstrdup(fn);
489 // file dont exist. Start empty buf with dummy line
490 char_insert(text, '\n');
493 rc = file_insert(fn, text, 1);
496 last_file_modified = -1;
497 #if ENABLE_FEATURE_VI_YANKMARK
498 /* init the marks. */
499 memset(mark, 0, sizeof(mark));
504 static void edit_file(char *fn)
506 #if ENABLE_FEATURE_VI_YANKMARK
507 #define cur_line edit_file__cur_line
511 #if ENABLE_FEATURE_VI_USE_SIGNALS
515 editing = 1; // 0 = exit, 1 = one file, 2 = multiple files
520 if (ENABLE_FEATURE_VI_WIN_RESIZE) {
521 get_terminal_width_height(0, &columns, &rows);
522 if (rows > MAX_SCR_ROWS) rows = MAX_SCR_ROWS;
523 if (columns > MAX_SCR_COLS) columns = MAX_SCR_COLS;
525 new_screen(rows, columns); // get memory for virtual screen
526 init_text_buffer(fn);
528 #if ENABLE_FEATURE_VI_YANKMARK
529 YDreg = 26; // default Yank/Delete reg
530 Ureg = 27; // hold orig line for "U" cmd
531 mark[26] = mark[27] = text; // init "previous context"
534 last_forward_char = last_input_char = '\0';
538 #if ENABLE_FEATURE_VI_USE_SIGNALS
540 signal(SIGWINCH, winch_sig);
541 signal(SIGTSTP, suspend_sig);
542 sig = sigsetjmp(restart, 1);
544 screenbegin = dot = text;
548 cmd_mode = 0; // 0=command 1=insert 2='R'eplace
551 offset = 0; // no horizontal offset
553 #if ENABLE_FEATURE_VI_DOT_CMD
555 ioq = ioq_start = NULL;
560 #if ENABLE_FEATURE_VI_COLON
565 while ((p = initial_cmds[n])) {
575 free(initial_cmds[n]);
576 initial_cmds[n] = NULL;
581 redraw(FALSE); // dont force every col re-draw
582 //------This is the main Vi cmd handling loop -----------------------
583 while (editing > 0) {
584 #if ENABLE_FEATURE_VI_CRASHME
586 if ((end - text) > 1) {
587 crash_dummy(); // generate a random command
590 string_insert(text, "\n\n##### Ran out of text to work on. #####\n\n"); // insert the string
596 last_input_char = c = get_one_char(); // get a cmd from user
597 #if ENABLE_FEATURE_VI_YANKMARK
598 // save a copy of the current line- for the 'U" command
599 if (begin_line(dot) != cur_line) {
600 cur_line = begin_line(dot);
601 text_yank(begin_line(dot), end_line(dot), Ureg);
604 #if ENABLE_FEATURE_VI_DOT_CMD
605 // These are commands that change text[].
606 // Remember the input for the "." command
607 if (!adding2q && ioq_start == NULL
608 && cmd_mode == 0 // command mode
609 && c > '\0' // exclude NUL and non-ASCII chars
610 && c < 0x7f // (Unicode and such)
611 && strchr(modifying_cmds, c)
616 do_cmd(c); // execute the user command
618 // poll to see if there is input already waiting. if we are
619 // not able to display output fast enough to keep up, skip
620 // the display update until we catch up with input.
621 if (!readbuffer[0] && mysleep(0) == 0) {
622 // no input pending - so update output
626 #if ENABLE_FEATURE_VI_CRASHME
628 crash_test(); // test editor variables
631 //-------------------------------------------------------------------
633 go_bottom_and_clear_to_eol();
638 //----- The Colon commands -------------------------------------
639 #if ENABLE_FEATURE_VI_COLON
640 static char *get_one_address(char *p, int *addr) // get colon addr, if present
644 IF_FEATURE_VI_YANKMARK(char c;)
645 IF_FEATURE_VI_SEARCH(char *pat;)
647 *addr = -1; // assume no addr
648 if (*p == '.') { // the current line
651 *addr = count_lines(text, q);
653 #if ENABLE_FEATURE_VI_YANKMARK
654 else if (*p == '\'') { // is this a mark addr
658 if (c >= 'a' && c <= 'z') {
661 q = mark[(unsigned char) c];
662 if (q != NULL) { // is mark valid
663 *addr = count_lines(text, q);
668 #if ENABLE_FEATURE_VI_SEARCH
669 else if (*p == '/') { // a search pattern
670 q = strchrnul(++p, '/');
671 pat = xstrndup(p, q - p); // save copy of pattern
675 q = char_search(dot, pat, FORWARD, FULL);
677 *addr = count_lines(text, q);
682 else if (*p == '$') { // the last line in file
684 q = begin_line(end - 1);
685 *addr = count_lines(text, q);
686 } else if (isdigit(*p)) { // specific line number
687 sscanf(p, "%d%n", addr, &st);
690 // unrecognized address - assume -1
696 static char *get_address(char *p, int *b, int *e) // get two colon addrs, if present
698 //----- get the address' i.e., 1,3 'a,'b -----
699 // get FIRST addr, if present
701 p++; // skip over leading spaces
702 if (*p == '%') { // alias for 1,$
705 *e = count_lines(text, end-1);
708 p = get_one_address(p, b);
711 if (*p == ',') { // is there a address separator
715 // get SECOND addr, if present
716 p = get_one_address(p, e);
720 p++; // skip over trailing spaces
724 #if ENABLE_FEATURE_VI_SET && ENABLE_FEATURE_VI_SETOPTS
725 static void setops(const char *args, const char *opname, int flg_no,
726 const char *short_opname, int opt)
728 const char *a = args + flg_no;
729 int l = strlen(opname) - 1; /* opname have + ' ' */
731 // maybe strncmp? we had tons of erroneous strncasecmp's...
732 if (strncasecmp(a, opname, l) == 0
733 || strncasecmp(a, short_opname, 2) == 0
743 // buf must be no longer than MAX_INPUT_LEN!
744 static void colon(char *buf)
746 char c, *orig_buf, *buf1, *q, *r;
747 char *fn, cmd[MAX_INPUT_LEN], args[MAX_INPUT_LEN];
748 int i, l, li, ch, b, e;
749 int useforce, forced = FALSE;
751 // :3154 // if (-e line 3154) goto it else stay put
752 // :4,33w! foo // write a portion of buffer to file "foo"
753 // :w // write all of buffer to current file
755 // :q! // quit- dont care about modified file
756 // :'a,'z!sort -u // filter block through sort
757 // :'f // goto mark "f"
758 // :'fl // list literal the mark "f" line
759 // :.r bar // read file "bar" into buffer before dot
760 // :/123/,/abc/d // delete lines from "123" line to "abc" line
761 // :/xyz/ // goto the "xyz" line
762 // :s/find/replace/ // substitute pattern "find" with "replace"
763 // :!<cmd> // run <cmd> then return
769 buf++; // move past the ':'
773 q = text; // assume 1,$ for the range
775 li = count_lines(text, end - 1);
776 fn = current_filename;
778 // look for optional address(es) :. :1 :1,9 :'q,'a :%
779 buf = get_address(buf, &b, &e);
781 // remember orig command line
784 // get the COMMAND into cmd[]
786 while (*buf != '\0') {
793 while (isblank(*buf))
797 buf1 = last_char_is(cmd, '!');
800 *buf1 = '\0'; // get rid of !
803 // if there is only one addr, then the addr
804 // is the line number of the single line the
805 // user wants. So, reset the end
806 // pointer to point at end of the "b" line
807 q = find_line(b); // what line is #b
812 // we were given two addrs. change the
813 // end pointer to the addr given by user.
814 r = find_line(e); // what line is #e
818 // ------------ now look for the command ------------
820 if (i == 0) { // :123CR goto line #123
822 dot = find_line(b); // what line is #b
826 #if ENABLE_FEATURE_ALLOW_EXEC
827 else if (cmd[0] == '!') { // run a cmd
829 // :!ls run the <cmd>
830 go_bottom_and_clear_to_eol();
832 retcode = system(orig_buf + 1); // run the cmd
834 printf("\nshell returned %i\n\n", retcode);
836 Hit_Return(); // let user see results
839 else if (cmd[0] == '=' && !cmd[1]) { // where is the address
840 if (b < 0) { // no addr given- use defaults
841 b = e = count_lines(text, dot);
843 status_line("%d", b);
844 } else if (strncmp(cmd, "delete", i) == 0) { // delete lines
845 if (b < 0) { // no addr given- use defaults
846 q = begin_line(dot); // assume .,. for the range
849 dot = yank_delete(q, r, 1, YANKDEL); // save, then delete lines
851 } else if (strncmp(cmd, "edit", i) == 0) { // Edit a file
852 // don't edit, if the current file has been modified
853 if (file_modified && !useforce) {
854 status_line_bold("No write since last change (:edit! overrides)");
858 // the user supplied a file name
860 } else if (current_filename && current_filename[0]) {
861 // no user supplied name- use the current filename
862 // fn = current_filename; was set by default
864 // no user file name, no current name- punt
865 status_line_bold("No current filename");
869 if (init_text_buffer(fn) < 0)
872 #if ENABLE_FEATURE_VI_YANKMARK
873 if (Ureg >= 0 && Ureg < 28 && reg[Ureg] != 0) {
874 free(reg[Ureg]); // free orig line reg- for 'U'
877 if (YDreg >= 0 && YDreg < 28 && reg[YDreg] != 0) {
878 free(reg[YDreg]); // free default yank/delete register
882 // how many lines in text[]?
883 li = count_lines(text, end - 1);
884 status_line("\"%s\"%s"
885 IF_FEATURE_VI_READONLY("%s")
886 " %dL, %dC", current_filename,
887 (file_size(fn) < 0 ? " [New file]" : ""),
888 IF_FEATURE_VI_READONLY(
889 ((readonly_mode) ? " [Readonly]" : ""),
892 } else if (strncmp(cmd, "file", i) == 0) { // what File is this
893 if (b != -1 || e != -1) {
894 not_implemented("No address allowed on this command");
898 // user wants a new filename
899 free(current_filename);
900 current_filename = xstrdup(args);
902 // user wants file status info
903 last_status_cksum = 0; // force status update
905 } else if (strncmp(cmd, "features", i) == 0) { // what features are available
906 // print out values of all features
907 go_bottom_and_clear_to_eol();
912 } else if (strncmp(cmd, "list", i) == 0) { // literal print line
913 if (b < 0) { // no addr given- use defaults
914 q = begin_line(dot); // assume .,. for the range
917 go_bottom_and_clear_to_eol();
919 for (; q <= r; q++) {
923 c_is_no_print = (c & 0x80) && !Isprint(c);
930 } else if (c < ' ' || c == 127) {
941 #if ENABLE_FEATURE_VI_SET
945 } else if (strncmp(cmd, "quit", i) == 0 // Quit
946 || strncmp(cmd, "next", i) == 0 // edit next file
949 // force end of argv list
956 // don't exit if the file been modified
958 status_line_bold("No write since last change (:%s! overrides)",
959 (*cmd == 'q' ? "quit" : "next"));
962 // are there other file to edit
963 if (*cmd == 'q' && optind < save_argc - 1) {
964 status_line_bold("%d more file to edit", (save_argc - optind - 1));
967 if (*cmd == 'n' && optind >= save_argc - 1) {
968 status_line_bold("No more files to edit");
972 } else if (strncmp(cmd, "read", i) == 0) { // read file into text[]
975 status_line_bold("No filename given");
978 if (b < 0) { // no addr given- use defaults
979 q = begin_line(dot); // assume "dot"
981 // read after current line- unless user said ":0r foo"
984 { // dance around potentially-reallocated text[]
985 uintptr_t ofs = q - text;
986 ch = file_insert(fn, q, 0);
990 goto vc1; // nothing was inserted
991 // how many lines in text[]?
992 li = count_lines(q, q + ch - 1);
994 IF_FEATURE_VI_READONLY("%s")
996 IF_FEATURE_VI_READONLY((readonly_mode ? " [Readonly]" : ""),)
999 // if the insert is before "dot" then we need to update
1002 /*file_modified++; - done by file_insert */
1004 } else if (strncmp(cmd, "rewind", i) == 0) { // rewind cmd line args
1005 if (file_modified && !useforce) {
1006 status_line_bold("No write since last change (:rewind! overrides)");
1008 // reset the filenames to edit
1009 optind = fn_start - 1;
1012 #if ENABLE_FEATURE_VI_SET
1013 } else if (strncmp(cmd, "set", i) == 0) { // set or clear features
1014 #if ENABLE_FEATURE_VI_SETOPTS
1017 i = 0; // offset into args
1018 // only blank is regarded as args delmiter. What about tab '\t' ?
1019 if (!args[0] || strcasecmp(args, "all") == 0) {
1020 // print out values of all options
1021 go_bottom_and_clear_to_eol();
1022 printf("----------------------------------------\r\n");
1023 #if ENABLE_FEATURE_VI_SETOPTS
1026 printf("autoindent ");
1032 printf("ignorecase ");
1035 printf("showmatch ");
1036 printf("tabstop=%d ", tabstop);
1041 #if ENABLE_FEATURE_VI_SETOPTS
1044 if (strncmp(argp, "no", 2) == 0)
1045 i = 2; // ":set noautoindent"
1046 setops(argp, "autoindent ", i, "ai", VI_AUTOINDENT);
1047 setops(argp, "flash ", i, "fl", VI_ERR_METHOD);
1048 setops(argp, "ignorecase ", i, "ic", VI_IGNORECASE);
1049 setops(argp, "showmatch ", i, "ic", VI_SHOWMATCH);
1051 if (strncmp(argp + i, "tabstop=%d ", 7) == 0) {
1052 sscanf(strchr(argp + i, '='), "tabstop=%d" + 7, &ch);
1053 if (ch > 0 && ch <= MAX_TABSTOP)
1056 while (*argp && *argp != ' ')
1057 argp++; // skip to arg delimiter (i.e. blank)
1058 while (*argp && *argp == ' ')
1059 argp++; // skip all delimiting blanks
1061 #endif /* FEATURE_VI_SETOPTS */
1062 #endif /* FEATURE_VI_SET */
1063 #if ENABLE_FEATURE_VI_SEARCH
1064 } else if (cmd[0] == 's') { // substitute a pattern with a replacement pattern
1068 // F points to the "find" pattern
1069 // R points to the "replace" pattern
1070 // replace the cmd line delimiters "/" with NULLs
1071 gflag = 0; // global replace flag
1072 c = orig_buf[1]; // what is the delimiter
1073 F = orig_buf + 2; // start of "find"
1074 R = strchr(F, c); // middle delimiter
1077 *R++ = '\0'; // terminate "find"
1078 buf1 = strchr(R, c);
1081 *buf1++ = '\0'; // terminate "replace"
1082 if (*buf1 == 'g') { // :s/foo/bar/g
1084 gflag++; // turn on gflag
1087 if (b < 0) { // maybe :s/foo/bar/
1088 q = begin_line(dot); // start with cur line
1089 b = count_lines(text, q); // cur line number
1092 e = b; // maybe :.s/foo/bar/
1093 for (i = b; i <= e; i++) { // so, :20,23 s \0 find \0 replace \0
1094 ls = q; // orig line start
1096 buf1 = char_search(q, F, FORWARD, LIMITED); // search cur line only for "find"
1099 // we found the "find" pattern - delete it
1100 text_hole_delete(buf1, buf1 + strlen(F) - 1);
1101 // inset the "replace" patern
1102 bias = string_insert(buf1, R); // insert the string
1105 /*q += bias; - recalculated anyway */
1106 // check for "global" :s/foo/bar/g
1108 if ((buf1 + strlen(R)) < end_line(ls)) {
1109 q = buf1 + strlen(R);
1110 goto vc4; // don't let q move past cur line
1116 #endif /* FEATURE_VI_SEARCH */
1117 } else if (strncmp(cmd, "version", i) == 0) { // show software version
1118 status_line(BB_VER " " BB_BT);
1119 } else if (strncmp(cmd, "write", i) == 0 // write text to file
1120 || strncmp(cmd, "wq", i) == 0
1121 || strncmp(cmd, "wn", i) == 0
1122 || (cmd[0] == 'x' && !cmd[1])
1124 // is there a file name to write to?
1128 #if ENABLE_FEATURE_VI_READONLY
1129 if (readonly_mode && !useforce) {
1130 status_line_bold("\"%s\" File is read only", fn);
1134 // how many lines in text[]?
1135 li = count_lines(q, r);
1137 // see if file exists- if not, its just a new file request
1139 // if "fn" is not write-able, chmod u+w
1140 // sprintf(syscmd, "chmod u+w %s", fn);
1144 l = file_write(fn, q, r);
1145 if (useforce && forced) {
1147 // sprintf(syscmd, "chmod u-w %s", fn);
1153 status_line_bold("\"%s\" %s", fn, strerror(errno));
1155 status_line("\"%s\" %dL, %dC", fn, li, l);
1156 if (q == text && r == end - 1 && l == ch) {
1158 last_file_modified = -1;
1160 if ((cmd[0] == 'x' || cmd[1] == 'q' || cmd[1] == 'n' ||
1161 cmd[0] == 'X' || cmd[1] == 'Q' || cmd[1] == 'N')
1166 #if ENABLE_FEATURE_VI_READONLY
1169 #if ENABLE_FEATURE_VI_YANKMARK
1170 } else if (strncmp(cmd, "yank", i) == 0) { // yank lines
1171 if (b < 0) { // no addr given- use defaults
1172 q = begin_line(dot); // assume .,. for the range
1175 text_yank(q, r, YDreg);
1176 li = count_lines(q, r);
1177 status_line("Yank %d lines (%d chars) into [%c]",
1178 li, strlen(reg[YDreg]), what_reg());
1182 not_implemented(cmd);
1185 dot = bound_dot(dot); // make sure "dot" is valid
1187 #if ENABLE_FEATURE_VI_SEARCH
1189 status_line(":s expression missing delimiters");
1193 #endif /* FEATURE_VI_COLON */
1195 static void Hit_Return(void)
1200 write1("[Hit return to continue]");
1202 while ((c = get_one_char()) != '\n' && c != '\r')
1204 redraw(TRUE); // force redraw all
1207 static int next_tabstop(int col)
1209 return col + ((tabstop - 1) - (col % tabstop));
1212 //----- Synchronize the cursor to Dot --------------------------
1213 static void sync_cursor(char *d, int *row, int *col)
1215 char *beg_cur; // begin and end of "d" line
1219 beg_cur = begin_line(d); // first char of cur line
1221 if (beg_cur < screenbegin) {
1222 // "d" is before top line on screen
1223 // how many lines do we have to move
1224 cnt = count_lines(beg_cur, screenbegin);
1226 screenbegin = beg_cur;
1227 if (cnt > (rows - 1) / 2) {
1228 // we moved too many lines. put "dot" in middle of screen
1229 for (cnt = 0; cnt < (rows - 1) / 2; cnt++) {
1230 screenbegin = prev_line(screenbegin);
1234 char *end_scr; // begin and end of screen
1235 end_scr = end_screen(); // last char of screen
1236 if (beg_cur > end_scr) {
1237 // "d" is after bottom line on screen
1238 // how many lines do we have to move
1239 cnt = count_lines(end_scr, beg_cur);
1240 if (cnt > (rows - 1) / 2)
1241 goto sc1; // too many lines
1242 for (ro = 0; ro < cnt - 1; ro++) {
1243 // move screen begin the same amount
1244 screenbegin = next_line(screenbegin);
1245 // now, move the end of screen
1246 end_scr = next_line(end_scr);
1247 end_scr = end_line(end_scr);
1251 // "d" is on screen- find out which row
1253 for (ro = 0; ro < rows - 1; ro++) { // drive "ro" to correct row
1259 // find out what col "d" is on
1261 while (tp < d) { // drive "co" to correct column
1262 if (*tp == '\n') //vda || *tp == '\0')
1265 // handle tabs like real vi
1266 if (d == tp && cmd_mode) {
1269 co = next_tabstop(co);
1270 } else if ((unsigned char)*tp < ' ' || *tp == 0x7f) {
1271 co++; // display as ^X, use 2 columns
1277 // "co" is the column where "dot" is.
1278 // The screen has "columns" columns.
1279 // The currently displayed columns are 0+offset -- columns+ofset
1280 // |-------------------------------------------------------------|
1282 // offset | |------- columns ----------------|
1284 // If "co" is already in this range then we do not have to adjust offset
1285 // but, we do have to subtract the "offset" bias from "co".
1286 // If "co" is outside this range then we have to change "offset".
1287 // If the first char of a line is a tab the cursor will try to stay
1288 // in column 7, but we have to set offset to 0.
1290 if (co < 0 + offset) {
1293 if (co >= columns + offset) {
1294 offset = co - columns + 1;
1296 // if the first char of the line is a tab, and "dot" is sitting on it
1297 // force offset to 0.
1298 if (d == beg_cur && *d == '\t') {
1307 //----- Text Movement Routines ---------------------------------
1308 static char *begin_line(char *p) // return pointer to first char cur line
1311 p = memrchr(text, '\n', p - text);
1319 static char *end_line(char *p) // return pointer to NL of cur line
1322 p = memchr(p, '\n', end - p - 1);
1329 static char *dollar_line(char *p) // return pointer to just before NL line
1332 // Try to stay off of the Newline
1333 if (*p == '\n' && (p - begin_line(p)) > 0)
1338 static char *prev_line(char *p) // return pointer first char prev line
1340 p = begin_line(p); // goto begining of cur line
1341 if (p > text && p[-1] == '\n')
1342 p--; // step to prev line
1343 p = begin_line(p); // goto begining of prev line
1347 static char *next_line(char *p) // return pointer first char next line
1350 if (p < end - 1 && *p == '\n')
1351 p++; // step to next line
1355 //----- Text Information Routines ------------------------------
1356 static char *end_screen(void)
1361 // find new bottom line
1363 for (cnt = 0; cnt < rows - 2; cnt++)
1369 // count line from start to stop
1370 static int count_lines(char *start, char *stop)
1375 if (stop < start) { // start and stop are backwards- reverse them
1381 stop = end_line(stop);
1382 while (start <= stop && start <= end - 1) {
1383 start = end_line(start);
1391 static char *find_line(int li) // find begining of line #li
1395 for (q = text; li > 1; li--) {
1401 //----- Dot Movement Routines ----------------------------------
1402 static void dot_left(void)
1404 if (dot > text && dot[-1] != '\n')
1408 static void dot_right(void)
1410 if (dot < end - 1 && *dot != '\n')
1414 static void dot_begin(void)
1416 dot = begin_line(dot); // return pointer to first char cur line
1419 static void dot_end(void)
1421 dot = end_line(dot); // return pointer to last char cur line
1424 static char *move_to_col(char *p, int l)
1430 while (co < l && p < end) {
1431 if (*p == '\n') //vda || *p == '\0')
1434 co = next_tabstop(co);
1435 } else if (*p < ' ' || *p == 127) {
1436 co++; // display as ^X, use 2 columns
1444 static void dot_next(void)
1446 dot = next_line(dot);
1449 static void dot_prev(void)
1451 dot = prev_line(dot);
1454 static void dot_scroll(int cnt, int dir)
1458 for (; cnt > 0; cnt--) {
1461 // ctrl-Y scroll up one line
1462 screenbegin = prev_line(screenbegin);
1465 // ctrl-E scroll down one line
1466 screenbegin = next_line(screenbegin);
1469 // make sure "dot" stays on the screen so we dont scroll off
1470 if (dot < screenbegin)
1472 q = end_screen(); // find new bottom line
1474 dot = begin_line(q); // is dot is below bottom line?
1478 static void dot_skip_over_ws(void)
1481 while (isspace(*dot) && *dot != '\n' && dot < end - 1)
1485 static void dot_delete(void) // delete the char at 'dot'
1487 text_hole_delete(dot, dot);
1490 static char *bound_dot(char *p) // make sure text[0] <= P < "end"
1492 if (p >= end && end > text) {
1494 indicate_error('1');
1498 indicate_error('2');
1503 //----- Helper Utility Routines --------------------------------
1505 //----------------------------------------------------------------
1506 //----- Char Routines --------------------------------------------
1507 /* Chars that are part of a word-
1508 * 0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
1509 * Chars that are Not part of a word (stoppers)
1510 * !"#$%&'()*+,-./:;<=>?@[\]^`{|}~
1511 * Chars that are WhiteSpace
1512 * TAB NEWLINE VT FF RETURN SPACE
1513 * DO NOT COUNT NEWLINE AS WHITESPACE
1516 static char *new_screen(int ro, int co)
1521 screensize = ro * co + 8;
1522 screen = xmalloc(screensize);
1523 // initialize the new screen. assume this will be a empty file.
1525 // non-existent text[] lines start with a tilde (~).
1526 for (li = 1; li < ro - 1; li++) {
1527 screen[(li * co) + 0] = '~';
1532 #if ENABLE_FEATURE_VI_SEARCH
1533 static int mycmp(const char *s1, const char *s2, int len)
1535 if (ENABLE_FEATURE_VI_SETOPTS && ignorecase) {
1536 return strncasecmp(s1, s2, len);
1538 return strncmp(s1, s2, len);
1541 // search for pattern starting at p
1542 static char *char_search(char *p, const char *pat, int dir, int range)
1544 #ifndef REGEX_SEARCH
1549 if (dir == FORWARD) {
1550 stop = end - 1; // assume range is p - end-1
1551 if (range == LIMITED)
1552 stop = next_line(p); // range is to next line
1553 for (start = p; start < stop; start++) {
1554 if (mycmp(start, pat, len) == 0) {
1558 } else if (dir == BACK) {
1559 stop = text; // assume range is text - p
1560 if (range == LIMITED)
1561 stop = prev_line(p); // range is to prev line
1562 for (start = p - len; start >= stop; start--) {
1563 if (mycmp(start, pat, len) == 0) {
1568 // pattern not found
1570 #else /* REGEX_SEARCH */
1572 struct re_pattern_buffer preg;
1576 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1582 // assume a LIMITED forward search
1590 // count the number of chars to search over, forward or backward
1594 // RANGE could be negative if we are searching backwards
1597 q = re_compile_pattern(pat, strlen(pat), &preg);
1599 // The pattern was not compiled
1600 status_line_bold("bad search pattern: \"%s\": %s", pat, q);
1601 i = 0; // return p if pattern not compiled
1611 // search for the compiled pattern, preg, in p[]
1612 // range < 0- search backward
1613 // range > 0- search forward
1615 // re_search() < 0 not found or error
1616 // re_search() > 0 index of found pattern
1617 // struct pattern char int int int struct reg
1618 // re_search (*pattern_buffer, *string, size, start, range, *regs)
1619 i = re_search(&preg, q, size, 0, range, 0);
1622 i = 0; // return NULL if pattern not found
1625 if (dir == FORWARD) {
1631 #endif /* REGEX_SEARCH */
1633 #endif /* FEATURE_VI_SEARCH */
1635 static char *char_insert(char *p, char c) // insert the char c at 'p'
1637 if (c == 22) { // Is this an ctrl-V?
1638 p += stupid_insert(p, '^'); // use ^ to indicate literal next
1639 refresh(FALSE); // show the ^
1644 } else if (c == 27) { // Is this an ESC?
1647 end_cmd_q(); // stop adding to q
1648 last_status_cksum = 0; // force status update
1649 if ((p[-1] != '\n') && (dot > text)) {
1652 } else if (c == erase_char || c == 8 || c == 127) { // Is this a BS
1654 if ((p[-1] != '\n') && (dot>text)) {
1656 p = text_hole_delete(p, p); // shrink buffer 1 char
1659 // insert a char into text[]
1660 char *sp; // "save p"
1663 c = '\n'; // translate \r to \n
1664 sp = p; // remember addr of insert
1665 p += 1 + stupid_insert(p, c); // insert the char
1666 #if ENABLE_FEATURE_VI_SETOPTS
1667 if (showmatch && strchr(")]}", *sp) != NULL) {
1670 if (autoindent && c == '\n') { // auto indent the new line
1673 q = prev_line(p); // use prev line as template
1674 len = strspn(q, " \t"); // space or tab
1677 bias = text_hole_make(p, len);
1689 // might reallocate text[]! use p += stupid_insert(p, ...),
1690 // and be careful to not use pointers into potentially freed text[]!
1691 static uintptr_t stupid_insert(char *p, char c) // stupidly insert the char c at 'p'
1694 bias = text_hole_make(p, 1);
1697 //file_modified++; - done by text_hole_make()
1701 static int find_range(char **start, char **stop, char c)
1703 char *save_dot, *p, *q, *t;
1704 int cnt, multiline = 0;
1709 if (strchr("cdy><", c)) {
1710 // these cmds operate on whole lines
1711 p = q = begin_line(p);
1712 for (cnt = 1; cnt < cmdcnt; cnt++) {
1716 } else if (strchr("^%$0bBeEfth\b\177", c)) {
1717 // These cmds operate on char positions
1718 do_cmd(c); // execute movement cmd
1720 } else if (strchr("wW", c)) {
1721 do_cmd(c); // execute movement cmd
1722 // if we are at the next word's first char
1723 // step back one char
1724 // but check the possibilities when it is true
1725 if (dot > text && ((isspace(dot[-1]) && !isspace(dot[0]))
1726 || (ispunct(dot[-1]) && !ispunct(dot[0]))
1727 || (isalnum(dot[-1]) && !isalnum(dot[0]))))
1728 dot--; // move back off of next word
1729 if (dot > text && *dot == '\n')
1730 dot--; // stay off NL
1732 } else if (strchr("H-k{", c)) {
1733 // these operate on multi-lines backwards
1734 q = end_line(dot); // find NL
1735 do_cmd(c); // execute movement cmd
1738 } else if (strchr("L+j}\r\n", c)) {
1739 // these operate on multi-lines forwards
1740 p = begin_line(dot);
1741 do_cmd(c); // execute movement cmd
1742 dot_end(); // find NL
1745 // nothing -- this causes any other values of c to
1746 // represent the one-character range under the
1747 // cursor. this is correct for ' ' and 'l', but
1748 // perhaps no others.
1757 // backward char movements don't include start position
1758 if (q > p && strchr("^0bBh\b\177", c)) q--;
1761 for (t = p; t <= q; t++) {
1774 static int st_test(char *p, int type, int dir, char *tested)
1784 if (type == S_BEFORE_WS) {
1786 test = ((!isspace(c)) || c == '\n');
1788 if (type == S_TO_WS) {
1790 test = ((!isspace(c)) || c == '\n');
1792 if (type == S_OVER_WS) {
1794 test = ((isspace(c)));
1796 if (type == S_END_PUNCT) {
1798 test = ((ispunct(c)));
1800 if (type == S_END_ALNUM) {
1802 test = ((isalnum(c)) || c == '_');
1808 static char *skip_thing(char *p, int linecnt, int dir, int type)
1812 while (st_test(p, type, dir, &c)) {
1813 // make sure we limit search to correct number of lines
1814 if (c == '\n' && --linecnt < 1)
1816 if (dir >= 0 && p >= end - 1)
1818 if (dir < 0 && p <= text)
1820 p += dir; // move to next char
1825 // find matching char of pair () [] {}
1826 static char *find_pair(char *p, const char c)
1833 dir = 1; // assume forward
1835 case '(': match = ')'; break;
1836 case '[': match = ']'; break;
1837 case '{': match = '}'; break;
1838 case ')': match = '('; dir = -1; break;
1839 case ']': match = '['; dir = -1; break;
1840 case '}': match = '{'; dir = -1; break;
1842 for (q = p + dir; text <= q && q < end; q += dir) {
1843 // look for match, count levels of pairs (( ))
1845 level++; // increase pair levels
1847 level--; // reduce pair level
1849 break; // found matching pair
1852 q = NULL; // indicate no match
1856 #if ENABLE_FEATURE_VI_SETOPTS
1857 // show the matching char of a pair, () [] {}
1858 static void showmatching(char *p)
1862 // we found half of a pair
1863 q = find_pair(p, *p); // get loc of matching char
1865 indicate_error('3'); // no matching char
1867 // "q" now points to matching pair
1868 save_dot = dot; // remember where we are
1869 dot = q; // go to new loc
1870 refresh(FALSE); // let the user see it
1871 mysleep(40); // give user some time
1872 dot = save_dot; // go back to old loc
1876 #endif /* FEATURE_VI_SETOPTS */
1878 // open a hole in text[]
1879 // might reallocate text[]! use p += text_hole_make(p, ...),
1880 // and be careful to not use pointers into potentially freed text[]!
1881 static uintptr_t text_hole_make(char *p, int size) // at "p", make a 'size' byte hole
1887 end += size; // adjust the new END
1888 if (end >= (text + text_size)) {
1890 text_size += end - (text + text_size) + 10240;
1891 new_text = xrealloc(text, text_size);
1892 bias = (new_text - text);
1893 screenbegin += bias;
1899 memmove(p + size, p, end - size - p);
1900 memset(p, ' ', size); // clear new hole
1905 // close a hole in text[]
1906 static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclusive
1911 // move forwards, from beginning
1915 if (q < p) { // they are backward- swap them
1919 hole_size = q - p + 1;
1921 if (src < text || src > end)
1923 if (dest < text || dest >= end)
1926 goto thd_atend; // just delete the end of the buffer
1927 memmove(dest, src, cnt);
1929 end = end - hole_size; // adjust the new END
1931 dest = end - 1; // make sure dest in below end-1
1933 dest = end = text; // keep pointers valid
1939 // copy text into register, then delete text.
1940 // if dist <= 0, do not include, or go past, a NewLine
1942 static char *yank_delete(char *start, char *stop, int dist, int yf)
1946 // make sure start <= stop
1948 // they are backwards, reverse them
1954 // we cannot cross NL boundaries
1958 // dont go past a NewLine
1959 for (; p + 1 <= stop; p++) {
1961 stop = p; // "stop" just before NewLine
1967 #if ENABLE_FEATURE_VI_YANKMARK
1968 text_yank(start, stop, YDreg);
1970 if (yf == YANKDEL) {
1971 p = text_hole_delete(start, stop);
1976 static void show_help(void)
1978 puts("These features are available:"
1979 #if ENABLE_FEATURE_VI_SEARCH
1980 "\n\tPattern searches with / and ?"
1982 #if ENABLE_FEATURE_VI_DOT_CMD
1983 "\n\tLast command repeat with \'.\'"
1985 #if ENABLE_FEATURE_VI_YANKMARK
1986 "\n\tLine marking with 'x"
1987 "\n\tNamed buffers with \"x"
1989 #if ENABLE_FEATURE_VI_READONLY
1990 "\n\tReadonly if vi is called as \"view\""
1991 "\n\tReadonly with -R command line arg"
1993 #if ENABLE_FEATURE_VI_SET
1994 "\n\tSome colon mode commands with \':\'"
1996 #if ENABLE_FEATURE_VI_SETOPTS
1997 "\n\tSettable options with \":set\""
1999 #if ENABLE_FEATURE_VI_USE_SIGNALS
2000 "\n\tSignal catching- ^C"
2001 "\n\tJob suspend and resume with ^Z"
2003 #if ENABLE_FEATURE_VI_WIN_RESIZE
2004 "\n\tAdapt to window re-sizes"
2009 #if ENABLE_FEATURE_VI_DOT_CMD
2010 static void start_new_cmd_q(char c)
2012 // get buffer for new cmd
2013 // if there is a current cmd count put it in the buffer first
2015 lmc_len = sprintf(last_modifying_cmd, "%d%c", cmdcnt, c);
2016 } else { // just save char c onto queue
2017 last_modifying_cmd[0] = c;
2023 static void end_cmd_q(void)
2025 #if ENABLE_FEATURE_VI_YANKMARK
2026 YDreg = 26; // go back to default Yank/Delete reg
2030 #endif /* FEATURE_VI_DOT_CMD */
2032 #if ENABLE_FEATURE_VI_YANKMARK \
2033 || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) \
2034 || ENABLE_FEATURE_VI_CRASHME
2035 // might reallocate text[]! use p += string_insert(p, ...),
2036 // and be careful to not use pointers into potentially freed text[]!
2037 static uintptr_t string_insert(char *p, const char *s) // insert the string at 'p'
2043 bias = text_hole_make(p, i);
2046 #if ENABLE_FEATURE_VI_YANKMARK
2049 for (cnt = 0; *s != '\0'; s++) {
2053 status_line("Put %d lines (%d chars) from [%c]", cnt, i, what_reg());
2060 #if ENABLE_FEATURE_VI_YANKMARK
2061 static char *text_yank(char *p, char *q, int dest) // copy text into a register
2064 if (cnt < 0) { // they are backwards- reverse them
2068 free(reg[dest]); // if already a yank register, free it
2069 reg[dest] = xstrndup(p, cnt + 1);
2073 static char what_reg(void)
2077 c = 'D'; // default to D-reg
2078 if (0 <= YDreg && YDreg <= 25)
2079 c = 'a' + (char) YDreg;
2087 static void check_context(char cmd)
2089 // A context is defined to be "modifying text"
2090 // Any modifying command establishes a new context.
2092 if (dot < context_start || dot > context_end) {
2093 if (strchr(modifying_cmds, cmd) != NULL) {
2094 // we are trying to modify text[]- make this the current context
2095 mark[27] = mark[26]; // move cur to prev
2096 mark[26] = dot; // move local to cur
2097 context_start = prev_line(prev_line(dot));
2098 context_end = next_line(next_line(dot));
2099 //loiter= start_loiter= now;
2104 static char *swap_context(char *p) // goto new context for '' command make this the current context
2108 // the current context is in mark[26]
2109 // the previous context is in mark[27]
2110 // only swap context if other context is valid
2111 if (text <= mark[27] && mark[27] <= end - 1) {
2113 mark[27] = mark[26];
2115 p = mark[26]; // where we are going- previous context
2116 context_start = prev_line(prev_line(prev_line(p)));
2117 context_end = next_line(next_line(next_line(p)));
2121 #endif /* FEATURE_VI_YANKMARK */
2123 //----- Set terminal attributes --------------------------------
2124 static void rawmode(void)
2126 tcgetattr(0, &term_orig);
2127 term_vi = term_orig;
2128 term_vi.c_lflag &= (~ICANON & ~ECHO); // leave ISIG ON- allow intr's
2129 term_vi.c_iflag &= (~IXON & ~ICRNL);
2130 term_vi.c_oflag &= (~ONLCR);
2131 term_vi.c_cc[VMIN] = 1;
2132 term_vi.c_cc[VTIME] = 0;
2133 erase_char = term_vi.c_cc[VERASE];
2134 tcsetattr_stdin_TCSANOW(&term_vi);
2137 static void cookmode(void)
2140 tcsetattr_stdin_TCSANOW(&term_orig);
2143 //----- Come here when we get a window resize signal ---------
2144 #if ENABLE_FEATURE_VI_USE_SIGNALS
2145 static void winch_sig(int sig UNUSED_PARAM)
2147 // FIXME: do it in main loop!!!
2148 signal(SIGWINCH, winch_sig);
2149 if (ENABLE_FEATURE_VI_WIN_RESIZE) {
2150 get_terminal_width_height(0, &columns, &rows);
2151 if (rows > MAX_SCR_ROWS) rows = MAX_SCR_ROWS;
2152 if (columns > MAX_SCR_COLS) columns = MAX_SCR_COLS;
2154 new_screen(rows, columns); // get memory for virtual screen
2155 redraw(TRUE); // re-draw the screen
2158 //----- Come here when we get a continue signal -------------------
2159 static void cont_sig(int sig UNUSED_PARAM)
2161 rawmode(); // terminal to "raw"
2162 last_status_cksum = 0; // force status update
2163 redraw(TRUE); // re-draw the screen
2165 signal(SIGTSTP, suspend_sig);
2166 signal(SIGCONT, SIG_DFL);
2167 kill(my_pid, SIGCONT); // huh? why? we are already "continued"...
2170 //----- Come here when we get a Suspend signal -------------------
2171 static void suspend_sig(int sig UNUSED_PARAM)
2173 go_bottom_and_clear_to_eol();
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 int readit(void) // read (maybe cursor) key from stdin
2205 c = read_key(STDIN_FILENO, readbuffer);
2206 if (c == -1) { // EOF/error
2207 go_bottom_and_clear_to_eol();
2208 cookmode(); // terminal to "cooked"
2209 bb_error_msg_and_die("can't read user input");
2214 //----- IO Routines --------------------------------------------
2215 static int get_one_char(void)
2219 #if ENABLE_FEATURE_VI_DOT_CMD
2221 // we are not adding to the q.
2222 // but, we may be reading from a q
2224 // there is no current q, read from STDIN
2225 c = readit(); // get the users input
2227 // there is a queue to get chars from first
2228 // careful with correct sign expansion!
2229 c = (unsigned char)*ioq++;
2231 // the end of the q, read from STDIN
2233 ioq_start = ioq = 0;
2234 c = readit(); // get the users input
2238 // adding STDIN chars to q
2239 c = readit(); // get the users input
2240 if (lmc_len >= MAX_INPUT_LEN - 1) {
2241 status_line_bold("last_modifying_cmd overrun");
2243 // add new char to q
2244 last_modifying_cmd[lmc_len++] = c;
2248 c = readit(); // get the users input
2249 #endif /* FEATURE_VI_DOT_CMD */
2253 // Get input line (uses "status line" area)
2254 static char *get_input_line(const char *prompt)
2256 // char [MAX_INPUT_LEN]
2257 #define buf get_input_line__buf
2262 strcpy(buf, prompt);
2263 last_status_cksum = 0; // force status update
2264 go_bottom_and_clear_to_eol();
2265 write1(prompt); // write out the :, /, or ? prompt
2268 while (i < MAX_INPUT_LEN) {
2270 if (c == '\n' || c == '\r' || c == 27)
2271 break; // this is end of input
2272 if (c == erase_char || c == 8 || c == 127) {
2273 // user wants to erase prev char
2275 write1("\b \b"); // erase char on screen
2276 if (i <= 0) // user backs up before b-o-l, exit
2278 } else if (c > 0 && c < 256) { // exclude Unicode
2279 // (TODO: need to handle Unicode)
2290 static int file_size(const char *fn) // what is the byte size of "fn"
2296 if (fn && fn[0] && stat(fn, &st_buf) == 0) // see if file exists
2297 cnt = (int) st_buf.st_size;
2301 // might reallocate text[]!
2302 static int file_insert(const char *fn, char *p, int update_ro_status)
2306 struct stat statbuf;
2309 if (stat(fn, &statbuf) < 0) {
2310 status_line_bold("\"%s\" %s", fn, strerror(errno));
2313 if (!S_ISREG(statbuf.st_mode)) {
2314 // This is not a regular file
2315 status_line_bold("\"%s\" Not a regular file", fn);
2318 if (p < text || p > end) {
2319 status_line_bold("Trying to insert file outside of memory");
2323 // read file to buffer
2324 fd = open(fn, O_RDONLY);
2326 status_line_bold("\"%s\" %s", fn, strerror(errno));
2329 size = statbuf.st_size;
2330 p += text_hole_make(p, size);
2331 cnt = safe_read(fd, p, size);
2333 status_line_bold("\"%s\" %s", fn, strerror(errno));
2334 p = text_hole_delete(p, p + size - 1); // un-do buffer insert
2335 } else if (cnt < size) {
2336 // There was a partial read, shrink unused space text[]
2337 p = text_hole_delete(p + cnt, p + (size - cnt) - 1); // un-do buffer insert
2338 status_line_bold("cannot read all of file \"%s\"", fn);
2344 #if ENABLE_FEATURE_VI_READONLY
2345 if (update_ro_status
2346 && ((access(fn, W_OK) < 0) ||
2347 /* root will always have access()
2348 * so we check fileperms too */
2349 !(statbuf.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH))
2352 SET_READONLY_FILE(readonly_mode);
2358 static int file_write(char *fn, char *first, char *last)
2360 int fd, cnt, charcnt;
2363 status_line_bold("No current filename");
2367 /* By popular request we do not open file with O_TRUNC,
2368 * but instead ftruncate() it _after_ successful write.
2369 * Might reduce amount of data lost on power fail etc.
2371 fd = open(fn, (O_WRONLY | O_CREAT), 0666);
2374 cnt = last - first + 1;
2375 charcnt = full_write(fd, first, cnt);
2376 ftruncate(fd, charcnt);
2377 if (charcnt == cnt) {
2379 //file_modified = FALSE;
2387 //----- Terminal Drawing ---------------------------------------
2388 // The terminal is made up of 'rows' line of 'columns' columns.
2389 // classically this would be 24 x 80.
2390 // screen coordinates
2396 // 23,0 ... 23,79 <- status line
2398 //----- Move the cursor to row x col (count from 0, not 1) -------
2399 static void place_cursor(int row, int col, int optimize)
2401 char cm1[sizeof(CMrc) + sizeof(int)*3 * 2];
2402 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
2404 SZ_UP = sizeof(CMup),
2405 SZ_DN = sizeof(CMdown),
2406 SEQ_SIZE = SZ_UP > SZ_DN ? SZ_UP : SZ_DN,
2408 char cm2[SEQ_SIZE * 5 + 32]; // bigger than worst case size
2412 if (row < 0) row = 0;
2413 if (row >= rows) row = rows - 1;
2414 if (col < 0) col = 0;
2415 if (col >= columns) col = columns - 1;
2417 //----- 1. Try the standard terminal ESC sequence
2418 sprintf(cm1, CMrc, row + 1, col + 1);
2421 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
2422 if (optimize && col < 16) {
2424 int Rrow = last_row;
2425 int diff = Rrow - row;
2427 if (diff < -5 || diff > 5)
2430 //----- find the minimum # of chars to move cursor -------------
2431 //----- 2. Try moving with discreet chars (Newline, [back]space, ...)
2434 // move to the correct row
2435 while (row < Rrow) {
2436 // the cursor has to move up
2440 while (row > Rrow) {
2441 // the cursor has to move down
2442 strcat(cm2, CMdown);
2446 // now move to the correct column
2447 strcat(cm2, "\r"); // start at col 0
2448 // just send out orignal source char to get to correct place
2449 screenp = &screen[row * columns]; // start of screen line
2450 strncat(cm2, screenp, col);
2452 // pick the shortest cursor motion to send out
2453 if (strlen(cm2) < strlen(cm)) {
2459 #endif /* FEATURE_VI_OPTIMIZE_CURSOR */
2463 //----- Erase from cursor to end of line -----------------------
2464 static void clear_to_eol(void)
2466 write1(Ceol); // Erase from cursor to end of line
2469 static void go_bottom_and_clear_to_eol(void)
2471 place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
2472 clear_to_eol(); // erase to end of line
2475 //----- Erase from cursor to end of screen -----------------------
2476 static void clear_to_eos(void)
2478 write1(Ceos); // Erase from cursor to end of screen
2481 //----- Start standout mode ------------------------------------
2482 static void standout_start(void) // send "start reverse video" sequence
2484 write1(SOs); // Start reverse video mode
2487 //----- End standout mode --------------------------------------
2488 static void standout_end(void) // send "end reverse video" sequence
2490 write1(SOn); // End reverse video mode
2493 //----- Flash the screen --------------------------------------
2494 static void flash(int h)
2496 standout_start(); // send "start reverse video" sequence
2499 standout_end(); // send "end reverse video" sequence
2503 static void Indicate_Error(void)
2505 #if ENABLE_FEATURE_VI_CRASHME
2507 return; // generate a random command
2510 write1(bell); // send out a bell character
2516 //----- Screen[] Routines --------------------------------------
2517 //----- Erase the Screen[] memory ------------------------------
2518 static void screen_erase(void)
2520 memset(screen, ' ', screensize); // clear new screen
2523 static int bufsum(char *buf, int count)
2526 char *e = buf + count;
2529 sum += (unsigned char) *buf++;
2533 //----- Draw the status line at bottom of the screen -------------
2534 static void show_status_line(void)
2536 int cnt = 0, cksum = 0;
2538 // either we already have an error or status message, or we
2540 if (!have_status_msg) {
2541 cnt = format_edit_status();
2542 cksum = bufsum(status_buffer, cnt);
2544 if (have_status_msg || ((cnt > 0 && last_status_cksum != cksum))) {
2545 last_status_cksum = cksum; // remember if we have seen this line
2546 go_bottom_and_clear_to_eol();
2547 write1(status_buffer);
2548 if (have_status_msg) {
2549 if (((int)strlen(status_buffer) - (have_status_msg - 1)) >
2551 have_status_msg = 0;
2554 have_status_msg = 0;
2556 place_cursor(crow, ccol, FALSE); // put cursor back in correct place
2561 //----- format the status buffer, the bottom line of screen ------
2562 // format status buffer, with STANDOUT mode
2563 static void status_line_bold(const char *format, ...)
2567 va_start(args, format);
2568 strcpy(status_buffer, SOs); // Terminal standout mode on
2569 vsprintf(status_buffer + sizeof(SOs)-1, format, args);
2570 strcat(status_buffer, SOn); // Terminal standout mode off
2573 have_status_msg = 1 + sizeof(SOs) + sizeof(SOn) - 2;
2576 // format status buffer
2577 static void status_line(const char *format, ...)
2581 va_start(args, format);
2582 vsprintf(status_buffer, format, args);
2585 have_status_msg = 1;
2588 // copy s to buf, convert unprintable
2589 static void print_literal(char *buf, const char *s)
2602 c_is_no_print = (c & 0x80) && !Isprint(c);
2603 if (c_is_no_print) {
2607 if (c < ' ' || c == 127) {
2620 if (strlen(buf) > MAX_INPUT_LEN - 10) // paranoia
2625 static void not_implemented(const char *s)
2627 char buf[MAX_INPUT_LEN];
2629 print_literal(buf, s);
2630 status_line_bold("\'%s\' is not implemented", buf);
2633 // show file status on status line
2634 static int format_edit_status(void)
2636 static const char cmd_mode_indicator[] ALIGN1 = "-IR-";
2638 #define tot format_edit_status__tot
2640 int cur, percent, ret, trunc_at;
2642 // file_modified is now a counter rather than a flag. this
2643 // helps reduce the amount of line counting we need to do.
2644 // (this will cause a mis-reporting of modified status
2645 // once every MAXINT editing operations.)
2647 // it would be nice to do a similar optimization here -- if
2648 // we haven't done a motion that could have changed which line
2649 // we're on, then we shouldn't have to do this count_lines()
2650 cur = count_lines(text, dot);
2652 // reduce counting -- the total lines can't have
2653 // changed if we haven't done any edits.
2654 if (file_modified != last_file_modified) {
2655 tot = cur + count_lines(dot, end - 1) - 1;
2656 last_file_modified = file_modified;
2659 // current line percent
2660 // ------------- ~~ ----------
2663 percent = (100 * cur) / tot;
2669 trunc_at = columns < STATUS_BUFFER_LEN-1 ?
2670 columns : STATUS_BUFFER_LEN-1;
2672 ret = snprintf(status_buffer, trunc_at+1,
2673 #if ENABLE_FEATURE_VI_READONLY
2674 "%c %s%s%s %d/%d %d%%",
2676 "%c %s%s %d/%d %d%%",
2678 cmd_mode_indicator[cmd_mode & 3],
2679 (current_filename != NULL ? current_filename : "No file"),
2680 #if ENABLE_FEATURE_VI_READONLY
2681 (readonly_mode ? " [Readonly]" : ""),
2683 (file_modified ? " [Modified]" : ""),
2686 if (ret >= 0 && ret < trunc_at)
2687 return ret; /* it all fit */
2689 return trunc_at; /* had to truncate */
2693 //----- Force refresh of all Lines -----------------------------
2694 static void redraw(int full_screen)
2696 place_cursor(0, 0, FALSE); // put cursor in correct place
2697 clear_to_eos(); // tell terminal to erase display
2698 screen_erase(); // erase the internal screen buffer
2699 last_status_cksum = 0; // force status update
2700 refresh(full_screen); // this will redraw the entire display
2704 //----- Format a text[] line into a buffer ---------------------
2705 static char* format_line(char *src /*, int li*/)
2710 char *dest = scr_out_buf; // [MAX_SCR_COLS + MAX_TABSTOP * 2]
2712 c = '~'; // char in col 0 in non-existent lines is '~'
2714 while (co < columns + tabstop) {
2715 // have we gone past the end?
2720 if ((c & 0x80) && !Isprint(c)) {
2723 if (c < ' ' || c == 0x7f) {
2727 while ((co % tabstop) != (tabstop - 1)) {
2735 c += '@'; // Ctrl-X -> 'X'
2740 // discard scrolled-off-to-the-left portion,
2741 // in tabstop-sized pieces
2742 if (ofs >= tabstop && co >= tabstop) {
2743 memmove(dest, dest + tabstop, co);
2750 // check "short line, gigantic offset" case
2753 // discard last scrolled off part
2756 // fill the rest with spaces
2758 memset(&dest[co], ' ', columns - co);
2762 //----- Refresh the changed screen lines -----------------------
2763 // Copy the source line from text[] into the buffer and note
2764 // if the current screenline is different from the new buffer.
2765 // If they differ then that line needs redrawing on the terminal.
2767 static void refresh(int full_screen)
2769 #define old_offset refresh__old_offset
2772 char *tp, *sp; // pointer into text[] and screen[]
2774 if (ENABLE_FEATURE_VI_WIN_RESIZE) {
2775 unsigned c = columns, r = rows;
2776 get_terminal_width_height(0, &columns, &rows);
2777 if (rows > MAX_SCR_ROWS) rows = MAX_SCR_ROWS;
2778 if (columns > MAX_SCR_COLS) columns = MAX_SCR_COLS;
2779 full_screen |= (c - columns) | (r - rows);
2781 sync_cursor(dot, &crow, &ccol); // where cursor will be (on "dot")
2782 tp = screenbegin; // index into text[] of top line
2784 // compare text[] to screen[] and mark screen[] lines that need updating
2785 for (li = 0; li < rows - 1; li++) {
2786 int cs, ce; // column start & end
2788 // format current text line
2789 out_buf = format_line(tp /*, li*/);
2791 // skip to the end of the current text[] line
2793 char *t = memchr(tp, '\n', end - tp);
2794 if (!t) t = end - 1;
2798 // see if there are any changes between vitual screen and out_buf
2799 changed = FALSE; // assume no change
2802 sp = &screen[li * columns]; // start of screen line
2804 // force re-draw of every single column from 0 - columns-1
2807 // compare newly formatted buffer with virtual screen
2808 // look forward for first difference between buf and screen
2809 for (; cs <= ce; cs++) {
2810 if (out_buf[cs] != sp[cs]) {
2811 changed = TRUE; // mark for redraw
2816 // look backward for last difference between out_buf and screen
2817 for (; ce >= cs; ce--) {
2818 if (out_buf[ce] != sp[ce]) {
2819 changed = TRUE; // mark for redraw
2823 // now, cs is index of first diff, and ce is index of last diff
2825 // if horz offset has changed, force a redraw
2826 if (offset != old_offset) {
2831 // make a sanity check of columns indexes
2833 if (ce > columns - 1) ce = columns - 1;
2834 if (cs > ce) { cs = 0; ce = columns - 1; }
2835 // is there a change between vitual screen and out_buf
2837 // copy changed part of buffer to virtual screen
2838 memcpy(sp+cs, out_buf+cs, ce-cs+1);
2840 // move cursor to column of first change
2841 //if (offset != old_offset) {
2842 // // place_cursor is still too stupid
2843 // // to handle offsets correctly
2844 // place_cursor(li, cs, FALSE);
2846 place_cursor(li, cs, TRUE);
2849 // write line out to terminal
2850 fwrite(&sp[cs], ce - cs + 1, 1, stdout);
2854 place_cursor(crow, ccol, TRUE);
2856 old_offset = offset;
2860 //---------------------------------------------------------------------
2861 //----- the Ascii Chart -----------------------------------------------
2863 // 00 nul 01 soh 02 stx 03 etx 04 eot 05 enq 06 ack 07 bel
2864 // 08 bs 09 ht 0a nl 0b vt 0c np 0d cr 0e so 0f si
2865 // 10 dle 11 dc1 12 dc2 13 dc3 14 dc4 15 nak 16 syn 17 etb
2866 // 18 can 19 em 1a sub 1b esc 1c fs 1d gs 1e rs 1f us
2867 // 20 sp 21 ! 22 " 23 # 24 $ 25 % 26 & 27 '
2868 // 28 ( 29 ) 2a * 2b + 2c , 2d - 2e . 2f /
2869 // 30 0 31 1 32 2 33 3 34 4 35 5 36 6 37 7
2870 // 38 8 39 9 3a : 3b ; 3c < 3d = 3e > 3f ?
2871 // 40 @ 41 A 42 B 43 C 44 D 45 E 46 F 47 G
2872 // 48 H 49 I 4a J 4b K 4c L 4d M 4e N 4f O
2873 // 50 P 51 Q 52 R 53 S 54 T 55 U 56 V 57 W
2874 // 58 X 59 Y 5a Z 5b [ 5c \ 5d ] 5e ^ 5f _
2875 // 60 ` 61 a 62 b 63 c 64 d 65 e 66 f 67 g
2876 // 68 h 69 i 6a j 6b k 6c l 6d m 6e n 6f o
2877 // 70 p 71 q 72 r 73 s 74 t 75 u 76 v 77 w
2878 // 78 x 79 y 7a z 7b { 7c | 7d } 7e ~ 7f del
2879 //---------------------------------------------------------------------
2881 //----- Execute a Vi Command -----------------------------------
2882 static void do_cmd(int c)
2884 const char *msg = msg; // for compiler
2885 char *p, *q, *save_dot;
2891 // c1 = c; // quiet the compiler
2892 // cnt = yf = 0; // quiet the compiler
2893 // msg = p = q = save_dot = buf; // quiet the compiler
2894 memset(buf, '\0', 12);
2898 /* if this is a cursor key, skip these checks */
2906 case KEYCODE_PAGEUP:
2907 case KEYCODE_PAGEDOWN:
2908 case KEYCODE_DELETE:
2912 if (cmd_mode == 2) {
2913 // flip-flop Insert/Replace mode
2914 if (c == KEYCODE_INSERT)
2916 // we are 'R'eplacing the current *dot with new char
2918 // don't Replace past E-o-l
2919 cmd_mode = 1; // convert to insert
2921 if (1 <= c || Isprint(c)) {
2923 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
2924 dot = char_insert(dot, c); // insert new char
2929 if (cmd_mode == 1) {
2930 // hitting "Insert" twice means "R" replace mode
2931 if (c == KEYCODE_INSERT) goto dc5;
2932 // insert the char c at "dot"
2933 if (1 <= c || Isprint(c)) {
2934 dot = char_insert(dot, c);
2949 #if ENABLE_FEATURE_VI_CRASHME
2950 case 0x14: // dc4 ctrl-T
2951 crashme = (crashme == 0) ? 1 : 0;
2980 //case 'u': // u- FIXME- there is no undo
2982 default: // unrecognized command
2990 not_implemented(buf);
2991 end_cmd_q(); // stop adding to q
2992 case 0x00: // nul- ignore
2994 case 2: // ctrl-B scroll up full screen
2995 case KEYCODE_PAGEUP: // Cursor Key Page Up
2996 dot_scroll(rows - 2, -1);
2998 case 4: // ctrl-D scroll down half screen
2999 dot_scroll((rows - 2) / 2, 1);
3001 case 5: // ctrl-E scroll down one line
3004 case 6: // ctrl-F scroll down full screen
3005 case KEYCODE_PAGEDOWN: // Cursor Key Page Down
3006 dot_scroll(rows - 2, 1);
3008 case 7: // ctrl-G show current status
3009 last_status_cksum = 0; // force status update
3011 case 'h': // h- move left
3012 case KEYCODE_LEFT: // cursor key Left
3013 case 8: // ctrl-H- move left (This may be ERASE char)
3014 case 0x7f: // DEL- move left (This may be ERASE char)
3020 case 10: // Newline ^J
3021 case 'j': // j- goto next line, same col
3022 case KEYCODE_DOWN: // cursor key Down
3026 dot_next(); // go to next B-o-l
3027 dot = move_to_col(dot, ccol + offset); // try stay in same col
3029 case 12: // ctrl-L force redraw whole screen
3030 case 18: // ctrl-R force redraw
3031 place_cursor(0, 0, FALSE); // put cursor in correct place
3032 clear_to_eos(); // tel terminal to erase display
3034 screen_erase(); // erase the internal screen buffer
3035 last_status_cksum = 0; // force status update
3036 refresh(TRUE); // this will redraw the entire display
3038 case 13: // Carriage Return ^M
3039 case '+': // +- goto next line
3046 case 21: // ctrl-U scroll up half screen
3047 dot_scroll((rows - 2) / 2, -1);
3049 case 25: // ctrl-Y scroll up one line
3055 cmd_mode = 0; // stop insrting
3057 last_status_cksum = 0; // force status update
3059 case ' ': // move right
3060 case 'l': // move right
3061 case KEYCODE_RIGHT: // Cursor Key Right
3067 #if ENABLE_FEATURE_VI_YANKMARK
3068 case '"': // "- name a register to use for Delete/Yank
3069 c1 = (get_one_char() | 0x20) - 'a'; // | 0x20 is tolower()
3070 if ((unsigned)c1 <= 25) { // a-z?
3076 case '\'': // '- goto a specific mark
3077 c1 = (get_one_char() | 0x20) - 'a';
3078 if ((unsigned)c1 <= 25) { // a-z?
3081 if (text <= q && q < end) {
3083 dot_begin(); // go to B-o-l
3086 } else if (c1 == '\'') { // goto previous context
3087 dot = swap_context(dot); // swap current and previous context
3088 dot_begin(); // go to B-o-l
3094 case 'm': // m- Mark a line
3095 // this is really stupid. If there are any inserts or deletes
3096 // between text[0] and dot then this mark will not point to the
3097 // correct location! It could be off by many lines!
3098 // Well..., at least its quick and dirty.
3099 c1 = (get_one_char() | 0x20) - 'a';
3100 if ((unsigned)c1 <= 25) { // a-z?
3101 // remember the line
3107 case 'P': // P- Put register before
3108 case 'p': // p- put register after
3111 status_line_bold("Nothing in register %c", what_reg());
3114 // are we putting whole lines or strings
3115 if (strchr(p, '\n') != NULL) {
3117 dot_begin(); // putting lines- Put above
3120 // are we putting after very last line?
3121 if (end_line(dot) == (end - 1)) {
3122 dot = end; // force dot to end of text[]
3124 dot_next(); // next line, then put before
3129 dot_right(); // move to right, can move to NL
3131 string_insert(dot, p); // insert the string
3132 end_cmd_q(); // stop adding to q
3134 case 'U': // U- Undo; replace current line with original version
3135 if (reg[Ureg] != 0) {
3136 p = begin_line(dot);
3138 p = text_hole_delete(p, q); // delete cur line
3139 p += string_insert(p, reg[Ureg]); // insert orig line
3144 #endif /* FEATURE_VI_YANKMARK */
3145 case '$': // $- goto end of line
3146 case KEYCODE_END: // Cursor Key End
3150 dot = end_line(dot);
3152 case '%': // %- find matching char of pair () [] {}
3153 for (q = dot; q < end && *q != '\n'; q++) {
3154 if (strchr("()[]{}", *q) != NULL) {
3155 // we found half of a pair
3156 p = find_pair(q, *q);
3168 case 'f': // f- forward to a user specified char
3169 last_forward_char = get_one_char(); // get the search char
3171 // dont separate these two commands. 'f' depends on ';'
3173 //**** fall through to ... ';'
3174 case ';': // ;- look at rest of line for last forward char
3178 if (last_forward_char == 0)
3181 while (q < end - 1 && *q != '\n' && *q != last_forward_char) {
3184 if (*q == last_forward_char)
3187 case ',': // repeat latest 'f' in opposite direction
3191 if (last_forward_char == 0)
3194 while (q >= text && *q != '\n' && *q != last_forward_char) {
3197 if (q >= text && *q == last_forward_char)
3201 case '-': // -- goto prev line
3208 #if ENABLE_FEATURE_VI_DOT_CMD
3209 case '.': // .- repeat the last modifying command
3210 // Stuff the last_modifying_cmd back into stdin
3211 // and let it be re-executed.
3213 last_modifying_cmd[lmc_len] = 0;
3214 ioq = ioq_start = xstrdup(last_modifying_cmd);
3218 #if ENABLE_FEATURE_VI_SEARCH
3219 case '?': // /- search for a pattern
3220 case '/': // /- search for a pattern
3223 q = get_input_line(buf); // get input line- use "status line"
3224 if (q[0] && !q[1]) {
3225 if (last_search_pattern[0])
3226 last_search_pattern[0] = c;
3227 goto dc3; // if no pat re-use old pat
3229 if (q[0]) { // strlen(q) > 1: new pat- save it and find
3230 // there is a new pat
3231 free(last_search_pattern);
3232 last_search_pattern = xstrdup(q);
3233 goto dc3; // now find the pattern
3235 // user changed mind and erased the "/"- do nothing
3237 case 'N': // N- backward search for last pattern
3241 dir = BACK; // assume BACKWARD search
3243 if (last_search_pattern[0] == '?') {
3247 goto dc4; // now search for pattern
3249 case 'n': // n- repeat search for last pattern
3250 // search rest of text[] starting at next char
3251 // if search fails return orignal "p" not the "p+1" address
3256 dir = FORWARD; // assume FORWARD search
3258 if (last_search_pattern[0] == '?') {
3263 q = char_search(p, last_search_pattern + 1, dir, FULL);
3265 dot = q; // good search, update "dot"
3269 // no pattern found between "dot" and "end"- continue at top
3274 q = char_search(p, last_search_pattern + 1, dir, FULL);
3275 if (q != NULL) { // found something
3276 dot = q; // found new pattern- goto it
3277 msg = "search hit BOTTOM, continuing at TOP";
3279 msg = "search hit TOP, continuing at BOTTOM";
3282 msg = "Pattern not found";
3286 status_line_bold("%s", msg);
3288 case '{': // {- move backward paragraph
3289 q = char_search(dot, "\n\n", BACK, FULL);
3290 if (q != NULL) { // found blank line
3291 dot = next_line(q); // move to next blank line
3294 case '}': // }- move forward paragraph
3295 q = char_search(dot, "\n\n", FORWARD, FULL);
3296 if (q != NULL) { // found blank line
3297 dot = next_line(q); // move to next blank line
3300 #endif /* FEATURE_VI_SEARCH */
3301 case '0': // 0- goto begining of line
3311 if (c == '0' && cmdcnt < 1) {
3312 dot_begin(); // this was a standalone zero
3314 cmdcnt = cmdcnt * 10 + (c - '0'); // this 0 is part of a number
3317 case ':': // :- the colon mode commands
3318 p = get_input_line(":"); // get input line- use "status line"
3319 #if ENABLE_FEATURE_VI_COLON
3320 colon(p); // execute the command
3323 p++; // move past the ':'
3327 if (strncmp(p, "quit", cnt) == 0
3328 || strncmp(p, "q!", cnt) == 0 // delete lines
3330 if (file_modified && p[1] != '!') {
3331 status_line_bold("No write since last change (:quit! overrides)");
3335 } else if (strncmp(p, "write", cnt) == 0
3336 || strncmp(p, "wq", cnt) == 0
3337 || strncmp(p, "wn", cnt) == 0
3338 || (p[0] == 'x' && !p[1])
3340 cnt = file_write(current_filename, text, end - 1);
3343 status_line_bold("Write error: %s", strerror(errno));
3346 last_file_modified = -1;
3347 status_line("\"%s\" %dL, %dC", current_filename, count_lines(text, end - 1), cnt);
3348 if (p[0] == 'x' || p[1] == 'q' || p[1] == 'n'
3349 || p[0] == 'X' || p[1] == 'Q' || p[1] == 'N'
3354 } else if (strncmp(p, "file", cnt) == 0) {
3355 last_status_cksum = 0; // force status update
3356 } else if (sscanf(p, "%d", &j) > 0) {
3357 dot = find_line(j); // go to line # j
3359 } else { // unrecognized cmd
3362 #endif /* !FEATURE_VI_COLON */
3364 case '<': // <- Left shift something
3365 case '>': // >- Right shift something
3366 cnt = count_lines(text, dot); // remember what line we are on
3367 c1 = get_one_char(); // get the type of thing to delete
3368 find_range(&p, &q, c1);
3369 yank_delete(p, q, 1, YANKONLY); // save copy before change
3372 i = count_lines(p, q); // # of lines we are shifting
3373 for ( ; i > 0; i--, p = next_line(p)) {
3375 // shift left- remove tab or 8 spaces
3377 // shrink buffer 1 char
3378 text_hole_delete(p, p);
3379 } else if (*p == ' ') {
3380 // we should be calculating columns, not just SPACE
3381 for (j = 0; *p == ' ' && j < tabstop; j++) {
3382 text_hole_delete(p, p);
3385 } else if (c == '>') {
3386 // shift right -- add tab or 8 spaces
3387 char_insert(p, '\t');
3390 dot = find_line(cnt); // what line were we on
3392 end_cmd_q(); // stop adding to q
3394 case 'A': // A- append at e-o-l
3395 dot_end(); // go to e-o-l
3396 //**** fall through to ... 'a'
3397 case 'a': // a- append after current char
3402 case 'B': // B- back a blank-delimited Word
3403 case 'E': // E- end of a blank-delimited word
3404 case 'W': // W- forward a blank-delimited word
3411 if (c == 'W' || isspace(dot[dir])) {
3412 dot = skip_thing(dot, 1, dir, S_TO_WS);
3413 dot = skip_thing(dot, 2, dir, S_OVER_WS);
3416 dot = skip_thing(dot, 1, dir, S_BEFORE_WS);
3418 case 'C': // C- Change to e-o-l
3419 case 'D': // D- delete to e-o-l
3421 dot = dollar_line(dot); // move to before NL
3422 // copy text into a register and delete
3423 dot = yank_delete(save_dot, dot, 0, YANKDEL); // delete to e-o-l
3425 goto dc_i; // start inserting
3426 #if ENABLE_FEATURE_VI_DOT_CMD
3428 end_cmd_q(); // stop adding to q
3431 case 'g': // 'gg' goto a line number (vim) (default: very first line)
3432 c1 = get_one_char();
3435 buf[1] = c1; // TODO: if Unicode?
3437 not_implemented(buf);
3443 case 'G': // G- goto to a line number (default= E-O-F)
3444 dot = end - 1; // assume E-O-F
3446 dot = find_line(cmdcnt); // what line is #cmdcnt
3450 case 'H': // H- goto top line on screen
3452 if (cmdcnt > (rows - 1)) {
3453 cmdcnt = (rows - 1);
3460 case 'I': // I- insert before first non-blank
3463 //**** fall through to ... 'i'
3464 case 'i': // i- insert before current char
3465 case KEYCODE_INSERT: // Cursor Key Insert
3467 cmd_mode = 1; // start insrting
3469 case 'J': // J- join current and next lines together
3473 dot_end(); // move to NL
3474 if (dot < end - 1) { // make sure not last char in text[]
3475 *dot++ = ' '; // replace NL with space
3477 while (isblank(*dot)) { // delete leading WS
3481 end_cmd_q(); // stop adding to q
3483 case 'L': // L- goto bottom line on screen
3485 if (cmdcnt > (rows - 1)) {
3486 cmdcnt = (rows - 1);
3494 case 'M': // M- goto middle line on screen
3496 for (cnt = 0; cnt < (rows-1) / 2; cnt++)
3497 dot = next_line(dot);
3499 case 'O': // O- open a empty line above
3501 p = begin_line(dot);
3502 if (p[-1] == '\n') {
3504 case 'o': // o- open a empty line below; Yes, I know it is in the middle of the "if (..."
3506 dot = char_insert(dot, '\n');
3509 dot = char_insert(dot, '\n'); // i\n ESC
3514 case 'R': // R- continuous Replace char
3518 case KEYCODE_DELETE:
3521 case 'X': // X- delete char before dot
3522 case 'x': // x- delete the current char
3523 case 's': // s- substitute the current char
3530 if (dot[dir] != '\n') {
3532 dot--; // delete prev char
3533 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
3536 goto dc_i; // start insrting
3537 end_cmd_q(); // stop adding to q
3539 case 'Z': // Z- if modified, {write}; exit
3540 // ZZ means to save file (if necessary), then exit
3541 c1 = get_one_char();
3546 if (file_modified) {
3547 if (ENABLE_FEATURE_VI_READONLY && readonly_mode) {
3548 status_line_bold("\"%s\" File is read only", current_filename);
3551 cnt = file_write(current_filename, text, end - 1);
3554 status_line_bold("Write error: %s", strerror(errno));
3555 } else if (cnt == (end - 1 - text + 1)) {
3562 case '^': // ^- move to first non-blank on line
3566 case 'b': // b- back a word
3567 case 'e': // e- end of word
3574 if ((dot + dir) < text || (dot + dir) > end - 1)
3577 if (isspace(*dot)) {
3578 dot = skip_thing(dot, (c == 'e') ? 2 : 1, dir, S_OVER_WS);
3580 if (isalnum(*dot) || *dot == '_') {
3581 dot = skip_thing(dot, 1, dir, S_END_ALNUM);
3582 } else if (ispunct(*dot)) {
3583 dot = skip_thing(dot, 1, dir, S_END_PUNCT);
3586 case 'c': // c- change something
3587 case 'd': // d- delete something
3588 #if ENABLE_FEATURE_VI_YANKMARK
3589 case 'y': // y- yank something
3590 case 'Y': // Y- Yank a line
3593 int yf, ml, whole = 0;
3594 yf = YANKDEL; // assume either "c" or "d"
3595 #if ENABLE_FEATURE_VI_YANKMARK
3596 if (c == 'y' || c == 'Y')
3601 c1 = get_one_char(); // get the type of thing to delete
3602 // determine range, and whether it spans lines
3603 ml = find_range(&p, &q, c1);
3604 if (c1 == 27) { // ESC- user changed mind and wants out
3605 c = c1 = 27; // Escape- do nothing
3606 } else if (strchr("wW", c1)) {
3608 // don't include trailing WS as part of word
3609 while (isblank(*q)) {
3610 if (q <= text || q[-1] == '\n')
3615 dot = yank_delete(p, q, ml, yf); // delete word
3616 } else if (strchr("^0bBeEft%$ lh\b\177", c1)) {
3617 // partial line copy text into a register and delete
3618 dot = yank_delete(p, q, ml, yf); // delete word
3619 } else if (strchr("cdykjHL+-{}\r\n", c1)) {
3620 // whole line copy text into a register and delete
3621 dot = yank_delete(p, q, ml, yf); // delete lines
3624 // could not recognize object
3625 c = c1 = 27; // error-
3631 dot = char_insert(dot, '\n');
3632 // on the last line of file don't move to prev line
3633 if (whole && dot != (end-1)) {
3636 } else if (c == 'd') {
3642 // if CHANGING, not deleting, start inserting after the delete
3644 strcpy(buf, "Change");
3645 goto dc_i; // start inserting
3648 strcpy(buf, "Delete");
3650 #if ENABLE_FEATURE_VI_YANKMARK
3651 if (c == 'y' || c == 'Y') {
3652 strcpy(buf, "Yank");
3656 for (cnt = 0; p <= q; p++) {
3660 status_line("%s %d lines (%d chars) using [%c]",
3661 buf, cnt, strlen(reg[YDreg]), what_reg());
3663 end_cmd_q(); // stop adding to q
3667 case 'k': // k- goto prev line, same col
3668 case KEYCODE_UP: // cursor key Up
3673 dot = move_to_col(dot, ccol + offset); // try stay in same col
3675 case 'r': // r- replace the current char with user input
3676 c1 = get_one_char(); // get the replacement char
3681 end_cmd_q(); // stop adding to q
3683 case 't': // t- move to char prior to next x
3684 last_forward_char = get_one_char();
3686 if (*dot == last_forward_char)
3688 last_forward_char = 0;
3690 case 'w': // w- forward a word
3694 if (isalnum(*dot) || *dot == '_') { // we are on ALNUM
3695 dot = skip_thing(dot, 1, FORWARD, S_END_ALNUM);
3696 } else if (ispunct(*dot)) { // we are on PUNCT
3697 dot = skip_thing(dot, 1, FORWARD, S_END_PUNCT);
3700 dot++; // move over word
3701 if (isspace(*dot)) {
3702 dot = skip_thing(dot, 2, FORWARD, S_OVER_WS);
3706 c1 = get_one_char(); // get the replacement char
3709 cnt = (rows - 2) / 2; // put dot at center
3711 cnt = rows - 2; // put dot at bottom
3712 screenbegin = begin_line(dot); // start dot at top
3713 dot_scroll(cnt, -1);
3715 case '|': // |- move to column "cmdcnt"
3716 dot = move_to_col(dot, cmdcnt - 1); // try to move to column
3718 case '~': // ~- flip the case of letters a-z -> A-Z
3722 if (islower(*dot)) {
3723 *dot = toupper(*dot);
3725 } else if (isupper(*dot)) {
3726 *dot = tolower(*dot);
3730 end_cmd_q(); // stop adding to q
3732 //----- The Cursor and Function Keys -----------------------------
3733 case KEYCODE_HOME: // Cursor Key Home
3736 // The Fn keys could point to do_macro which could translate them
3738 case KEYCODE_FUN1: // Function Key F1
3739 case KEYCODE_FUN2: // Function Key F2
3740 case KEYCODE_FUN3: // Function Key F3
3741 case KEYCODE_FUN4: // Function Key F4
3742 case KEYCODE_FUN5: // Function Key F5
3743 case KEYCODE_FUN6: // Function Key F6
3744 case KEYCODE_FUN7: // Function Key F7
3745 case KEYCODE_FUN8: // Function Key F8
3746 case KEYCODE_FUN9: // Function Key F9
3747 case KEYCODE_FUN10: // Function Key F10
3748 case KEYCODE_FUN11: // Function Key F11
3749 case KEYCODE_FUN12: // Function Key F12
3755 // if text[] just became empty, add back an empty line
3757 char_insert(text, '\n'); // start empty buf with dummy line
3760 // it is OK for dot to exactly equal to end, otherwise check dot validity
3762 dot = bound_dot(dot); // make sure "dot" is valid
3764 #if ENABLE_FEATURE_VI_YANKMARK
3765 check_context(c); // update the current context
3769 cmdcnt = 0; // cmd was not a number, reset cmdcnt
3770 cnt = dot - begin_line(dot);
3771 // Try to stay off of the Newline
3772 if (*dot == '\n' && cnt > 0 && cmd_mode == 0)
3776 /* NB! the CRASHME code is unmaintained, and doesn't currently build */
3777 #if ENABLE_FEATURE_VI_CRASHME
3778 static int totalcmds = 0;
3779 static int Mp = 85; // Movement command Probability
3780 static int Np = 90; // Non-movement command Probability
3781 static int Dp = 96; // Delete command Probability
3782 static int Ip = 97; // Insert command Probability
3783 static int Yp = 98; // Yank command Probability
3784 static int Pp = 99; // Put command Probability
3785 static int M = 0, N = 0, I = 0, D = 0, Y = 0, P = 0, U = 0;
3786 static const char chars[20] = "\t012345 abcdABCD-=.$";
3787 static const char *const words[20] = {
3788 "this", "is", "a", "test",
3789 "broadcast", "the", "emergency", "of",
3790 "system", "quick", "brown", "fox",
3791 "jumped", "over", "lazy", "dogs",
3792 "back", "January", "Febuary", "March"
3794 static const char *const lines[20] = {
3795 "You should have received a copy of the GNU General Public License\n",
3796 "char c, cm, *cmd, *cmd1;\n",
3797 "generate a command by percentages\n",
3798 "Numbers may be typed as a prefix to some commands.\n",
3799 "Quit, discarding changes!\n",
3800 "Forced write, if permission originally not valid.\n",
3801 "In general, any ex or ed command (such as substitute or delete).\n",
3802 "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
3803 "Please get w/ me and I will go over it with you.\n",
3804 "The following is a list of scheduled, committed changes.\n",
3805 "1. Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
3806 "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
3807 "Any question about transactions please contact Sterling Huxley.\n",
3808 "I will try to get back to you by Friday, December 31.\n",
3809 "This Change will be implemented on Friday.\n",
3810 "Let me know if you have problems accessing this;\n",
3811 "Sterling Huxley recently added you to the access list.\n",
3812 "Would you like to go to lunch?\n",
3813 "The last command will be automatically run.\n",
3814 "This is too much english for a computer geek.\n",
3816 static char *multilines[20] = {
3817 "You should have received a copy of the GNU General Public License\n",
3818 "char c, cm, *cmd, *cmd1;\n",
3819 "generate a command by percentages\n",
3820 "Numbers may be typed as a prefix to some commands.\n",
3821 "Quit, discarding changes!\n",
3822 "Forced write, if permission originally not valid.\n",
3823 "In general, any ex or ed command (such as substitute or delete).\n",
3824 "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
3825 "Please get w/ me and I will go over it with you.\n",
3826 "The following is a list of scheduled, committed changes.\n",
3827 "1. Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
3828 "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
3829 "Any question about transactions please contact Sterling Huxley.\n",
3830 "I will try to get back to you by Friday, December 31.\n",
3831 "This Change will be implemented on Friday.\n",
3832 "Let me know if you have problems accessing this;\n",
3833 "Sterling Huxley recently added you to the access list.\n",
3834 "Would you like to go to lunch?\n",
3835 "The last command will be automatically run.\n",
3836 "This is too much english for a computer geek.\n",
3839 // create a random command to execute
3840 static void crash_dummy()
3842 static int sleeptime; // how long to pause between commands
3843 char c, cm, *cmd, *cmd1;
3844 int i, cnt, thing, rbi, startrbi, percent;
3846 // "dot" movement commands
3847 cmd1 = " \n\r\002\004\005\006\025\0310^$-+wWeEbBhjklHL";
3849 // is there already a command running?
3850 if (readbuffer[0] > 0)
3853 readbuffer[0] = 'X';
3855 sleeptime = 0; // how long to pause between commands
3856 memset(readbuffer, '\0', sizeof(readbuffer));
3857 // generate a command by percentages
3858 percent = (int) lrand48() % 100; // get a number from 0-99
3859 if (percent < Mp) { // Movement commands
3860 // available commands
3863 } else if (percent < Np) { // non-movement commands
3864 cmd = "mz<>\'\""; // available commands
3866 } else if (percent < Dp) { // Delete commands
3867 cmd = "dx"; // available commands
3869 } else if (percent < Ip) { // Inset commands
3870 cmd = "iIaAsrJ"; // available commands
3872 } else if (percent < Yp) { // Yank commands
3873 cmd = "yY"; // available commands
3875 } else if (percent < Pp) { // Put commands
3876 cmd = "pP"; // available commands
3879 // We do not know how to handle this command, try again
3883 // randomly pick one of the available cmds from "cmd[]"
3884 i = (int) lrand48() % strlen(cmd);
3886 if (strchr(":\024", cm))
3887 goto cd0; // dont allow colon or ctrl-T commands
3888 readbuffer[rbi++] = cm; // put cmd into input buffer
3890 // now we have the command-
3891 // there are 1, 2, and multi char commands
3892 // find out which and generate the rest of command as necessary
3893 if (strchr("dmryz<>\'\"", cm)) { // 2-char commands
3894 cmd1 = " \n\r0$^-+wWeEbBhjklHL";
3895 if (cm == 'm' || cm == '\'' || cm == '\"') { // pick a reg[]
3896 cmd1 = "abcdefghijklmnopqrstuvwxyz";
3898 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
3900 readbuffer[rbi++] = c; // add movement to input buffer
3902 if (strchr("iIaAsc", cm)) { // multi-char commands
3904 // change some thing
3905 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
3907 readbuffer[rbi++] = c; // add movement to input buffer
3909 thing = (int) lrand48() % 4; // what thing to insert
3910 cnt = (int) lrand48() % 10; // how many to insert
3911 for (i = 0; i < cnt; i++) {
3912 if (thing == 0) { // insert chars
3913 readbuffer[rbi++] = chars[((int) lrand48() % strlen(chars))];
3914 } else if (thing == 1) { // insert words
3915 strcat(readbuffer, words[(int) lrand48() % 20]);
3916 strcat(readbuffer, " ");
3917 sleeptime = 0; // how fast to type
3918 } else if (thing == 2) { // insert lines
3919 strcat(readbuffer, lines[(int) lrand48() % 20]);
3920 sleeptime = 0; // how fast to type
3921 } else { // insert multi-lines
3922 strcat(readbuffer, multilines[(int) lrand48() % 20]);
3923 sleeptime = 0; // how fast to type
3926 strcat(readbuffer, "\033");
3928 readbuffer[0] = strlen(readbuffer + 1);
3932 mysleep(sleeptime); // sleep 1/100 sec
3935 // test to see if there are any errors
3936 static void crash_test()
3938 static time_t oldtim;
3945 strcat(msg, "end<text ");
3947 if (end > textend) {
3948 strcat(msg, "end>textend ");
3951 strcat(msg, "dot<text ");
3954 strcat(msg, "dot>end ");
3956 if (screenbegin < text) {
3957 strcat(msg, "screenbegin<text ");
3959 if (screenbegin > end - 1) {
3960 strcat(msg, "screenbegin>end-1 ");
3964 printf("\n\n%d: \'%c\' %s\n\n\n%s[Hit return to continue]%s",
3965 totalcmds, last_input_char, msg, SOs, SOn);
3967 while (safe_read(STDIN_FILENO, d, 1) > 0) {
3968 if (d[0] == '\n' || d[0] == '\r')
3973 if (tim >= (oldtim + 3)) {
3974 sprintf(status_buffer,
3975 "Tot=%d: M=%d N=%d I=%d D=%d Y=%d P=%d U=%d size=%d",
3976 totalcmds, M, N, I, D, Y, P, U, end - text + 1);