1 /* vi: set sw=8 ts=8: */
3 * tiny vi.c: A small 'vi' clone
4 * Copyright (C) 2000, 2001 Sterling Huxley <sterling@europa.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 "$Id: vi.c,v 1.9 2001/06/23 13:49:14 andersen Exp $";
25 * To compile for standalone use:
26 * gcc -Wall -Os -s -DSTANDALONE -o vi vi.c
28 * gcc -Wall -Os -s -DSTANDALONE -DBB_FEATURE_VI_CRASHME -o vi vi.c # include testing features
35 * $HOME/.exrc and ./.exrc
36 * add magic to search /foo.*bar
39 * how about mode lines: vi: set sw=8 ts=8:
40 * if mark[] values were line numbers rather than pointers
41 * it would be easier to change the mark when add/delete lines
42 * More intelligence in refresh()
43 * ":r !cmd" and "!cmd" to filter text through an external command
44 * A true "undo" facility
45 * An "ex" line oriented mode- maybe using "cmdedit"
48 //---- Feature -------------- Bytes to immplement
51 #define BB_FEATURE_VI_COLON // 4288
52 #define BB_FEATURE_VI_YANKMARK // 1408
53 #define BB_FEATURE_VI_SEARCH // 1088
54 #define BB_FEATURE_VI_USE_SIGNALS // 1056
55 #define BB_FEATURE_VI_DOT_CMD // 576
56 #define BB_FEATURE_VI_READONLY // 128
57 #define BB_FEATURE_VI_SETOPTS // 576
58 #define BB_FEATURE_VI_SET // 224
59 #define BB_FEATURE_VI_WIN_RESIZE // 256 WIN_RESIZE
60 // To test editor using CRASHME:
62 // To stop testing, wait until all to text[] is deleted, or
63 // Ctrl-Z and kill -9 %1
64 // while in the editor Ctrl-T will toggle the crashme function on and off.
65 //#define BB_FEATURE_VI_CRASHME // randomly pick commands to execute
66 #endif /* STANDALONE */
73 #include <sys/ioctl.h>
75 #include <sys/types.h>
88 #endif /* STANDALONE */
92 #define FALSE ((int)0)
94 #define MAX_SCR_COLS BUFSIZ
96 // Misc. non-Ascii keys that report an escape sequence
97 #define VI_K_UP 128 // cursor key Up
98 #define VI_K_DOWN 129 // cursor key Down
99 #define VI_K_RIGHT 130 // Cursor Key Right
100 #define VI_K_LEFT 131 // cursor key Left
101 #define VI_K_HOME 132 // Cursor Key Home
102 #define VI_K_END 133 // Cursor Key End
103 #define VI_K_INSERT 134 // Cursor Key Insert
104 #define VI_K_PAGEUP 135 // Cursor Key Page Up
105 #define VI_K_PAGEDOWN 136 // Cursor Key Page Down
106 #define VI_K_FUN1 137 // Function Key F1
107 #define VI_K_FUN2 138 // Function Key F2
108 #define VI_K_FUN3 139 // Function Key F3
109 #define VI_K_FUN4 140 // Function Key F4
110 #define VI_K_FUN5 141 // Function Key F5
111 #define VI_K_FUN6 142 // Function Key F6
112 #define VI_K_FUN7 143 // Function Key F7
113 #define VI_K_FUN8 144 // Function Key F8
114 #define VI_K_FUN9 145 // Function Key F9
115 #define VI_K_FUN10 146 // Function Key F10
116 #define VI_K_FUN11 147 // Function Key F11
117 #define VI_K_FUN12 148 // Function Key F12
119 static const int YANKONLY = FALSE;
120 static const int YANKDEL = TRUE;
121 static const int FORWARD = 1; // code depends on "1" for array index
122 static const int BACK = -1; // code depends on "-1" for array index
123 static const int LIMITED = 0; // how much of text[] in char_search
124 static const int FULL = 1; // how much of text[] in char_search
126 static const int S_BEFORE_WS = 1; // used in skip_thing() for moving "dot"
127 static const int S_TO_WS = 2; // used in skip_thing() for moving "dot"
128 static const int S_OVER_WS = 3; // used in skip_thing() for moving "dot"
129 static const int S_END_PUNCT = 4; // used in skip_thing() for moving "dot"
130 static const int S_END_ALNUM = 5; // used in skip_thing() for moving "dot"
132 typedef unsigned char Byte;
135 static int editing; // >0 while we are editing a file
136 static int cmd_mode; // 0=command 1=insert
137 static int file_modified; // buffer contents changed
138 static int err_method; // indicate error with beep or flash
139 static int fn_start; // index of first cmd line file name
140 static int save_argc; // how many file names on cmd line
141 static int cmdcnt; // repetition count
142 static fd_set rfds; // use select() for small sleeps
143 static struct timeval tv; // use select() for small sleeps
144 static char erase_char; // the users erase character
145 static int rows, columns; // the terminal screen is this size
146 static int crow, ccol, offset; // cursor is on Crow x Ccol with Horz Ofset
147 static char *SOs, *SOn; // terminal standout start/normal ESC sequence
148 static char *bell; // terminal bell sequence
149 static char *Ceol, *Ceos; // Clear-end-of-line and Clear-end-of-screen ESC sequence
150 static char *CMrc; // Cursor motion arbitrary destination ESC sequence
151 static char *CMup, *CMdown; // Cursor motion up and down ESC sequence
152 static Byte *status_buffer; // mesages to the user
153 static Byte last_input_char; // last char read from user
154 static Byte last_forward_char; // last char searched for with 'f'
155 static Byte *cfn; // previous, current, and next file name
156 static Byte *text, *end, *textend; // pointers to the user data in memory
157 static Byte *screen; // pointer to the virtual screen buffer
158 static int screensize; // and its size
159 static Byte *screenbegin; // index into text[], of top line on the screen
160 static Byte *dot; // where all the action takes place
162 static struct termios term_orig, term_vi; // remember what the cooked mode was
164 #ifdef BB_FEATURE_VI_OPTIMIZE_CURSOR
165 static int last_row; // where the cursor was last moved to
166 #endif /* BB_FEATURE_VI_OPTIMIZE_CURSOR */
167 #ifdef BB_FEATURE_VI_USE_SIGNALS
168 static jmp_buf restart; // catch_sig()
169 #endif /* BB_FEATURE_VI_USE_SIGNALS */
170 #ifdef BB_FEATURE_VI_WIN_RESIZE
171 static struct winsize winsize; // remember the window size
172 #endif /* BB_FEATURE_VI_WIN_RESIZE */
173 #ifdef BB_FEATURE_VI_DOT_CMD
174 static int adding2q; // are we currently adding user input to q
175 static Byte *last_modifying_cmd; // last modifying cmd for "."
176 static Byte *ioq, *ioq_start; // pointer to string for get_one_char to "read"
177 #endif /* BB_FEATURE_VI_DOT_CMD */
178 #if defined(BB_FEATURE_VI_DOT_CMD) || defined(BB_FEATURE_VI_YANKMARK)
179 static Byte *modifying_cmds; // cmds that modify text[]
180 #endif /* BB_FEATURE_VI_DOT_CMD || BB_FEATURE_VI_YANKMARK */
181 #ifdef BB_FEATURE_VI_READONLY
182 static int vi_readonly, readonly;
183 #endif /* BB_FEATURE_VI_READONLY */
184 #ifdef BB_FEATURE_VI_SETOPTS
185 static int autoindent;
186 static int showmatch;
187 static int ignorecase;
188 #endif /* BB_FEATURE_VI_SETOPTS */
189 #ifdef BB_FEATURE_VI_YANKMARK
190 static Byte *reg[28]; // named register a-z, "D", and "U" 0-25,26,27
191 static int YDreg, Ureg; // default delete register and orig line for "U"
192 static Byte *mark[28]; // user marks points somewhere in text[]- a-z and previous context ''
193 static Byte *context_start, *context_end;
194 #endif /* BB_FEATURE_VI_YANKMARK */
195 #ifdef BB_FEATURE_VI_SEARCH
196 static Byte *last_search_pattern; // last pattern from a '/' or '?' search
197 #endif /* BB_FEATURE_VI_SEARCH */
200 static void edit_file(Byte *); // edit one file
201 static void do_cmd(Byte); // execute a command
202 static void sync_cursor(Byte *, int *, int *); // synchronize the screen cursor to dot
203 static Byte *begin_line(Byte *); // return pointer to cur line B-o-l
204 static Byte *end_line(Byte *); // return pointer to cur line E-o-l
205 static Byte *dollar_line(Byte *); // return pointer to just before NL
206 static Byte *prev_line(Byte *); // return pointer to prev line B-o-l
207 static Byte *next_line(Byte *); // return pointer to next line B-o-l
208 static Byte *end_screen(void); // get pointer to last char on screen
209 static int count_lines(Byte *, Byte *); // count line from start to stop
210 static Byte *find_line(int); // find begining of line #li
211 static Byte *move_to_col(Byte *, int); // move "p" to column l
212 static int isblnk(Byte); // is the char a blank or tab
213 static void dot_left(void); // move dot left- dont leave line
214 static void dot_right(void); // move dot right- dont leave line
215 static void dot_begin(void); // move dot to B-o-l
216 static void dot_end(void); // move dot to E-o-l
217 static void dot_next(void); // move dot to next line B-o-l
218 static void dot_prev(void); // move dot to prev line B-o-l
219 static void dot_scroll(int, int); // move the screen up or down
220 static void dot_skip_over_ws(void); // move dot pat WS
221 static void dot_delete(void); // delete the char at 'dot'
222 static Byte *bound_dot(Byte *); // make sure text[0] <= P < "end"
223 static Byte *new_screen(int, int); // malloc virtual screen memory
224 static Byte *new_text(int); // malloc memory for text[] buffer
225 static Byte *char_insert(Byte *, Byte); // insert the char c at 'p'
226 static Byte *stupid_insert(Byte *, Byte); // stupidly insert the char c at 'p'
227 static Byte find_range(Byte **, Byte **, Byte); // return pointers for an object
228 static int st_test(Byte *, int, int, Byte *); // helper for skip_thing()
229 static Byte *skip_thing(Byte *, int, int, int); // skip some object
230 static Byte *find_pair(Byte *, Byte); // find matching pair () [] {}
231 static Byte *text_hole_delete(Byte *, Byte *); // at "p", delete a 'size' byte hole
232 static Byte *text_hole_make(Byte *, int); // at "p", make a 'size' byte hole
233 static Byte *yank_delete(Byte *, Byte *, int, int); // yank text[] into register then delete
234 static void show_help(void); // display some help info
235 static void print_literal(Byte *, Byte *); // copy s to buf, convert unprintable
236 static void rawmode(void); // set "raw" mode on tty
237 static void cookmode(void); // return to "cooked" mode on tty
238 static int mysleep(int); // sleep for 'h' 1/100 seconds
239 static Byte readit(void); // read (maybe cursor) key from stdin
240 static Byte get_one_char(void); // read 1 char from stdin
241 static int file_size(Byte *); // what is the byte size of "fn"
242 static int file_insert(Byte *, Byte *, int);
243 static int file_write(Byte *, Byte *, Byte *);
244 static void place_cursor(int, int, int);
245 static void screen_erase();
246 static void clear_to_eol(void);
247 static void clear_to_eos(void);
248 static void standout_start(void); // send "start reverse video" sequence
249 static void standout_end(void); // send "end reverse video" sequence
250 static void flash(int); // flash the terminal screen
251 static void beep(void); // beep the terminal
252 static void indicate_error(char); // use flash or beep to indicate error
253 static void show_status_line(void); // put a message on the bottom line
254 static void psb(char *, ...); // Print Status Buf
255 static void psbs(char *, ...); // Print Status Buf in standout mode
256 static void ni(Byte *); // display messages
257 static void edit_status(void); // show file status on status line
258 static void redraw(int); // force a full screen refresh
259 static void format_line(Byte*, Byte*, int);
260 static void refresh(int); // update the terminal from screen[]
262 #ifdef BB_FEATURE_VI_SEARCH
263 static Byte *char_search(Byte *, Byte *, int, int); // search for pattern starting at p
264 static int mycmp(Byte *, Byte *, int); // string cmp based in "ignorecase"
265 #endif /* BB_FEATURE_VI_SEARCH */
266 #ifdef BB_FEATURE_VI_COLON
267 static void Hit_Return(void);
268 static Byte *get_one_address(Byte *, int *); // get colon addr, if present
269 static Byte *get_address(Byte *, int *, int *); // get two colon addrs, if present
270 static void colon(Byte *); // execute the "colon" mode cmds
271 #endif /* BB_FEATURE_VI_COLON */
272 static Byte *get_input_line(Byte *); // get input line- use "status line"
273 #ifdef BB_FEATURE_VI_USE_SIGNALS
274 static void winch_sig(int); // catch window size changes
275 static void suspend_sig(int); // catch ctrl-Z
276 static void alarm_sig(int); // catch alarm time-outs
277 static void catch_sig(int); // catch ctrl-C
278 static void core_sig(int); // catch a core dump signal
279 #endif /* BB_FEATURE_VI_USE_SIGNALS */
280 #ifdef BB_FEATURE_VI_DOT_CMD
281 static void start_new_cmd_q(Byte); // new queue for command
282 static void end_cmd_q(); // stop saving input chars
283 #else /* BB_FEATURE_VI_DOT_CMD */
285 #endif /* BB_FEATURE_VI_DOT_CMD */
286 #ifdef BB_FEATURE_VI_WIN_RESIZE
287 static void window_size_get(int); // find out what size the window is
288 #endif /* BB_FEATURE_VI_WIN_RESIZE */
289 #ifdef BB_FEATURE_VI_SETOPTS
290 static void showmatching(Byte *); // show the matching pair () [] {}
291 #endif /* BB_FEATURE_VI_SETOPTS */
292 #if defined(BB_FEATURE_VI_YANKMARK) || defined(BB_FEATURE_VI_COLON) || defined(BB_FEATURE_VI_CRASHME)
293 static Byte *string_insert(Byte *, Byte *); // insert the string at 'p'
294 #endif /* BB_FEATURE_VI_YANKMARK || BB_FEATURE_VI_COLON || BB_FEATURE_VI_CRASHME */
295 #ifdef BB_FEATURE_VI_YANKMARK
296 static Byte *text_yank(Byte *, Byte *, int); // save copy of "p" into a register
297 static Byte what_reg(void); // what is letter of current YDreg
298 static void check_context(Byte); // remember context for '' command
299 static Byte *swap_context(Byte *); // goto new context for '' command
300 #endif /* BB_FEATURE_VI_YANKMARK */
301 #ifdef BB_FEATURE_VI_CRASHME
302 static void crash_dummy();
303 static void crash_test();
304 static int crashme = 0;
305 #endif /* BB_FEATURE_VI_CRASHME */
308 extern int vi_main(int argc, char **argv)
312 #ifdef BB_FEATURE_VI_YANKMARK
314 #endif /* BB_FEATURE_VI_YANKMARK */
316 CMrc= "\033[%d;%dH"; // Terminal Crusor motion ESC sequence
317 CMup= "\033[A"; // move cursor up one line, same col
318 CMdown="\n"; // move cursor down one line, same col
319 Ceol= "\033[0K"; // Clear from cursor to end of line
320 Ceos= "\033[0J"; // Clear from cursor to end of screen
321 SOs = "\033[7m"; // Terminal standout mode on
322 SOn = "\033[0m"; // Terminal standout mode off
323 bell= "\007"; // Terminal bell sequence
324 #ifdef BB_FEATURE_VI_CRASHME
325 (void) srand((long) getpid());
326 #endif /* BB_FEATURE_VI_CRASHME */
327 status_buffer = (Byte *) malloc(200); // hold messages to user
328 #ifdef BB_FEATURE_VI_READONLY
329 vi_readonly = readonly = FALSE;
330 if (strncmp(argv[0], "view", 4) == 0) {
334 #endif /* BB_FEATURE_VI_READONLY */
335 #ifdef BB_FEATURE_VI_SETOPTS
339 #endif /* BB_FEATURE_VI_SETOPTS */
340 #ifdef BB_FEATURE_VI_YANKMARK
341 for (i = 0; i < 28; i++) {
343 } // init the yank regs
344 #endif /* BB_FEATURE_VI_YANKMARK */
345 #ifdef BB_FEATURE_VI_DOT_CMD
346 modifying_cmds = (Byte *) "aAcCdDiIJoOpPrRsxX<>~"; // cmds modifying text[]
347 #endif /* BB_FEATURE_VI_DOT_CMD */
349 // 1- process $HOME/.exrc file
350 // 2- process EXINIT variable from environment
351 // 3- process command line args
352 while ((c = getopt(argc, argv, "hCR")) != -1) {
354 #ifdef BB_FEATURE_VI_CRASHME
358 #endif /* BB_FEATURE_VI_CRASHME */
359 #ifdef BB_FEATURE_VI_READONLY
360 case 'R': // Read-only flag
363 #endif /* BB_FEATURE_VI_READONLY */
364 //case 'r': // recover flag- ignore- we don't use tmp file
365 //case 'x': // encryption flag- ignore
366 //case 'c': // execute command first
367 //case 'h': // help -- just use default
374 // The argv array can be used by the ":next" and ":rewind" commands
376 fn_start = optind; // remember first file name for :next and :rew
379 //----- This is the main file handling loop --------------
380 if (optind >= argc) {
381 editing = 1; // 0= exit, 1= one file, 2= multiple files
384 for (; optind < argc; optind++) {
385 editing = 1; // 0=exit, 1=one file, 2+ =many files
388 cfn = (Byte *) strdup(argv[optind]);
392 //-----------------------------------------------------------
397 static void edit_file(Byte * fn)
402 #ifdef BB_FEATURE_VI_USE_SIGNALS
405 #endif /* BB_FEATURE_VI_USE_SIGNALS */
406 #ifdef BB_FEATURE_VI_YANKMARK
407 static Byte *cur_line;
408 #endif /* BB_FEATURE_VI_YANKMARK */
414 #ifdef BB_FEATURE_VI_WIN_RESIZE
416 #endif /* BB_FEATURE_VI_WIN_RESIZE */
417 new_screen(rows, columns); // get memory for virtual screen
419 cnt = file_size(fn); // file size
420 size = 2 * cnt; // 200% of file size
421 new_text(size); // get a text[] buffer
422 screenbegin = dot = end = text;
424 ch= file_insert(fn, text, cnt);
427 (void) char_insert(text, '\n'); // start empty buf with dummy line
429 file_modified = FALSE;
430 #ifdef BB_FEATURE_VI_YANKMARK
431 YDreg = 26; // default Yank/Delete reg
432 Ureg = 27; // hold orig line for "U" cmd
433 for (cnt = 0; cnt < 28; cnt++) {
436 mark[26] = mark[27] = text; // init "previous context"
437 #endif /* BB_FEATURE_VI_YANKMARK */
439 err_method = 1; // flash
440 last_forward_char = last_input_char = '\0';
445 #ifdef BB_FEATURE_VI_USE_SIGNALS
446 signal(SIGHUP, catch_sig);
447 signal(SIGINT, catch_sig);
448 signal(SIGALRM, alarm_sig);
449 signal(SIGTERM, catch_sig);
450 signal(SIGQUIT, core_sig);
451 signal(SIGILL, core_sig);
452 signal(SIGTRAP, core_sig);
453 signal(SIGIOT, core_sig);
454 signal(SIGABRT, core_sig);
455 signal(SIGFPE, core_sig);
456 signal(SIGBUS, core_sig);
457 signal(SIGSEGV, core_sig);
459 signal(SIGSYS, core_sig);
461 signal(SIGWINCH, winch_sig);
462 signal(SIGTSTP, suspend_sig);
463 sig = setjmp(restart);
467 msg = "(window resize)";
477 msg = "(I tried to touch invalid memory)";
481 psbs("-- caught signal %d %s--", sig, msg);
482 screenbegin = dot = text;
484 #endif /* BB_FEATURE_VI_USE_SIGNALS */
487 cmd_mode = 0; // 0=command 1=insert 2='R'eplace
490 offset = 0; // no horizontal offset
492 #ifdef BB_FEATURE_VI_DOT_CMD
493 if (last_modifying_cmd != 0)
494 free(last_modifying_cmd);
495 if (ioq_start != NULL)
497 ioq = ioq_start = last_modifying_cmd = 0;
499 #endif /* BB_FEATURE_VI_DOT_CMD */
500 redraw(FALSE); // dont force every col re-draw
503 //------This is the main Vi cmd handling loop -----------------------
504 while (editing > 0) {
505 #ifdef BB_FEATURE_VI_CRASHME
507 if ((end - text) > 1) {
508 crash_dummy(); // generate a random command
512 string_insert(text, (Byte *) "\n\n##### Ran out of text to work on. #####\n\n"); // insert the string
516 #endif /* BB_FEATURE_VI_CRASHME */
517 last_input_char = c = get_one_char(); // get a cmd from user
518 #ifdef BB_FEATURE_VI_YANKMARK
519 // save a copy of the current line- for the 'U" command
520 if (begin_line(dot) != cur_line) {
521 cur_line = begin_line(dot);
522 text_yank(begin_line(dot), end_line(dot), Ureg);
524 #endif /* BB_FEATURE_VI_YANKMARK */
525 #ifdef BB_FEATURE_VI_DOT_CMD
526 // These are commands that change text[].
527 // Remember the input for the "." command
528 if (!adding2q && ioq_start == 0
529 && strchr((char *) modifying_cmds, c) != NULL) {
532 #endif /* BB_FEATURE_VI_DOT_CMD */
533 do_cmd(c); // execute the user command
535 // poll to see if there is input already waiting. if we are
536 // not able to display output fast enough to keep up, skip
537 // the display update until we catch up with input.
538 if (mysleep(0) == 0) {
539 // no input pending- so update output
543 #ifdef BB_FEATURE_VI_CRASHME
545 crash_test(); // test editor variables
546 #endif /* BB_FEATURE_VI_CRASHME */
548 //-------------------------------------------------------------------
550 place_cursor(rows, 0, FALSE); // go to bottom of screen
551 clear_to_eol(); // Erase to end of line
555 static Byte readbuffer[BUFSIZ];
557 #ifdef BB_FEATURE_VI_CRASHME
558 static int totalcmds = 0;
559 static int Mp = 85; // Movement command Probability
560 static int Np = 90; // Non-movement command Probability
561 static int Dp = 96; // Delete command Probability
562 static int Ip = 97; // Insert command Probability
563 static int Yp = 98; // Yank command Probability
564 static int Pp = 99; // Put command Probability
565 static int M = 0, N = 0, I = 0, D = 0, Y = 0, P = 0, U = 0;
566 char chars[20] = "\t012345 abcdABCD-=.$";
567 char *words[20] = { "this", "is", "a", "test",
568 "broadcast", "the", "emergency", "of",
569 "system", "quick", "brown", "fox",
570 "jumped", "over", "lazy", "dogs",
571 "back", "January", "Febuary", "March"
574 "You should have received a copy of the GNU General Public License\n",
575 "char c, cm, *cmd, *cmd1;\n",
576 "generate a command by percentages\n",
577 "Numbers may be typed as a prefix to some commands.\n",
578 "Quit, discarding changes!\n",
579 "Forced write, if permission originally not valid.\n",
580 "In general, any ex or ed command (such as substitute or delete).\n",
581 "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
582 "Please get w/ me and I will go over it with you.\n",
583 "The following is a list of scheduled, committed changes.\n",
584 "1. Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
585 "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
586 "Any question about transactions please contact Sterling Huxley.\n",
587 "I will try to get back to you by Friday, December 31.\n",
588 "This Change will be implemented on Friday.\n",
589 "Let me know if you have problems accessing this;\n",
590 "Sterling Huxley recently added you to the access list.\n",
591 "Would you like to go to lunch?\n",
592 "The last command will be automatically run.\n",
593 "This is too much english for a computer geek.\n",
595 char *multilines[20] = {
596 "You should have received a copy of the GNU General Public License\n",
597 "char c, cm, *cmd, *cmd1;\n",
598 "generate a command by percentages\n",
599 "Numbers may be typed as a prefix to some commands.\n",
600 "Quit, discarding changes!\n",
601 "Forced write, if permission originally not valid.\n",
602 "In general, any ex or ed command (such as substitute or delete).\n",
603 "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
604 "Please get w/ me and I will go over it with you.\n",
605 "The following is a list of scheduled, committed changes.\n",
606 "1. Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
607 "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
608 "Any question about transactions please contact Sterling Huxley.\n",
609 "I will try to get back to you by Friday, December 31.\n",
610 "This Change will be implemented on Friday.\n",
611 "Let me know if you have problems accessing this;\n",
612 "Sterling Huxley recently added you to the access list.\n",
613 "Would you like to go to lunch?\n",
614 "The last command will be automatically run.\n",
615 "This is too much english for a computer geek.\n",
618 // create a random command to execute
619 static void crash_dummy()
621 static int sleeptime; // how long to pause between commands
622 char c, cm, *cmd, *cmd1;
623 int i, cnt, thing, rbi, startrbi, percent;
625 // "dot" movement commands
626 cmd1 = " \n\r\002\004\005\006\025\0310^$-+wWeEbBhjklHL";
628 // is there already a command running?
629 if (strlen((char *) readbuffer) > 0)
633 sleeptime = 0; // how long to pause between commands
634 memset(readbuffer, '\0', BUFSIZ - 1); // clear the read buffer
635 // generate a command by percentages
636 percent = (int) lrand48() % 100; // get a number from 0-99
637 if (percent < Mp) { // Movement commands
638 // available commands
641 } else if (percent < Np) { // non-movement commands
642 cmd = "mz<>\'\""; // available commands
644 } else if (percent < Dp) { // Delete commands
645 cmd = "dx"; // available commands
647 } else if (percent < Ip) { // Inset commands
648 cmd = "iIaAsrJ"; // available commands
650 } else if (percent < Yp) { // Yank commands
651 cmd = "yY"; // available commands
653 } else if (percent < Pp) { // Put commands
654 cmd = "pP"; // available commands
657 // We do not know how to handle this command, try again
661 // randomly pick one of the available cmds from "cmd[]"
662 i = (int) lrand48() % strlen(cmd);
664 if (strchr(":\024", cm))
665 goto cd0; // dont allow colon or ctrl-T commands
666 readbuffer[rbi++] = cm; // put cmd into input buffer
668 // now we have the command-
669 // there are 1, 2, and multi char commands
670 // find out which and generate the rest of command as necessary
671 if (strchr("dmryz<>\'\"", cm)) { // 2-char commands
672 cmd1 = " \n\r0$^-+wWeEbBhjklHL";
673 if (cm == 'm' || cm == '\'' || cm == '\"') { // pick a reg[]
674 cmd1 = "abcdefghijklmnopqrstuvwxyz";
676 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
678 readbuffer[rbi++] = c; // add movement to input buffer
680 if (strchr("iIaAsc", cm)) { // multi-char commands
683 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
685 readbuffer[rbi++] = c; // add movement to input buffer
687 thing = (int) lrand48() % 4; // what thing to insert
688 cnt = (int) lrand48() % 10; // how many to insert
689 for (i = 0; i < cnt; i++) {
690 if (thing == 0) { // insert chars
691 readbuffer[rbi++] = chars[((int) lrand48() % strlen(chars))];
692 } else if (thing == 1) { // insert words
693 strcat((char *) readbuffer, words[(int) lrand48() % 20]);
694 strcat((char *) readbuffer, " ");
695 sleeptime = 0; // how fast to type
696 } else if (thing == 2) { // insert lines
697 strcat((char *) readbuffer, lines[(int) lrand48() % 20]);
698 sleeptime = 0; // how fast to type
699 } else { // insert multi-lines
700 strcat((char *) readbuffer, multilines[(int) lrand48() % 20]);
701 sleeptime = 0; // how fast to type
704 strcat((char *) readbuffer, "\033");
709 (void) mysleep(sleeptime); // sleep 1/100 sec
712 // test to see if there are any errors
713 static void crash_test()
715 static time_t oldtim;
717 char d[2], buf[BUFSIZ], msg[BUFSIZ];
721 strcat((char *) msg, "end<text ");
724 strcat((char *) msg, "end>textend ");
727 strcat((char *) msg, "dot<text ");
730 strcat((char *) msg, "dot>end ");
732 if (screenbegin < text) {
733 strcat((char *) msg, "screenbegin<text ");
735 if (screenbegin > end - 1) {
736 strcat((char *) msg, "screenbegin>end-1 ");
739 if (strlen(msg) > 0) {
741 sprintf(buf, "\n\n%d: \'%c\' %s\n\n\n%s[Hit return to continue]%s",
742 totalcmds, last_input_char, msg, SOs, SOn);
743 write(1, buf, strlen(buf));
744 while (read(0, d, 1) > 0) {
745 if (d[0] == '\n' || d[0] == '\r')
750 tim = (time_t) time((time_t *) 0);
751 if (tim >= (oldtim + 3)) {
752 sprintf((char *) status_buffer,
753 "Tot=%d: M=%d N=%d I=%d D=%d Y=%d P=%d U=%d size=%d",
754 totalcmds, M, N, I, D, Y, P, U, end - text + 1);
759 #endif /* BB_FEATURE_VI_CRASHME */
761 //---------------------------------------------------------------------
762 //----- the Ascii Chart -----------------------------------------------
764 // 00 nul 01 soh 02 stx 03 etx 04 eot 05 enq 06 ack 07 bel
765 // 08 bs 09 ht 0a nl 0b vt 0c np 0d cr 0e so 0f si
766 // 10 dle 11 dc1 12 dc2 13 dc3 14 dc4 15 nak 16 syn 17 etb
767 // 18 can 19 em 1a sub 1b esc 1c fs 1d gs 1e rs 1f us
768 // 20 sp 21 ! 22 " 23 # 24 $ 25 % 26 & 27 '
769 // 28 ( 29 ) 2a * 2b + 2c , 2d - 2e . 2f /
770 // 30 0 31 1 32 2 33 3 34 4 35 5 36 6 37 7
771 // 38 8 39 9 3a : 3b ; 3c < 3d = 3e > 3f ?
772 // 40 @ 41 A 42 B 43 C 44 D 45 E 46 F 47 G
773 // 48 H 49 I 4a J 4b K 4c L 4d M 4e N 4f O
774 // 50 P 51 Q 52 R 53 S 54 T 55 U 56 V 57 W
775 // 58 X 59 Y 5a Z 5b [ 5c \ 5d ] 5e ^ 5f _
776 // 60 ` 61 a 62 b 63 c 64 d 65 e 66 f 67 g
777 // 68 h 69 i 6a j 6b k 6c l 6d m 6e n 6f o
778 // 70 p 71 q 72 r 73 s 74 t 75 u 76 v 77 w
779 // 78 x 79 y 7a z 7b { 7c | 7d } 7e ~ 7f del
780 //---------------------------------------------------------------------
782 //----- Execute a Vi Command -----------------------------------
783 static void do_cmd(Byte c)
785 Byte c1, *p, *q, *msg, buf[9], *save_dot;
786 int cnt, i, j, dir, yf;
788 c1 = c; // quiet the compiler
789 cnt = yf = dir = 0; // quiet the compiler
790 p = q = save_dot = msg = buf; // quiet the compiler
791 memset(buf, '\0', 9); // clear buf
793 // we are 'R'eplacing the current *dot with new char
795 // don't Replace past E-o-l
796 cmd_mode = 1; // convert to insert
798 if (1 <= c && c <= 127) { // only ASCII chars
800 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
801 dot = char_insert(dot, c); // insert new char
807 // hitting "Insert" twice means "R" replace mode
808 if (c == VI_K_INSERT) goto dc5;
809 // insert the char c at "dot"
810 if (1 <= c && c <= 127) {
811 dot = char_insert(dot, c); // only ASCII chars
825 #ifdef BB_FEATURE_VI_CRASHME
826 case 0x14: // dc4 ctrl-T
827 crashme = (crashme == 0) ? 1 : 0;
829 #endif /* BB_FEATURE_VI_CRASHME */
858 //case 'u': // u- FIXME- there is no undo
860 default: // unrecognised command
869 end_cmd_q(); // stop adding to q
870 case 0x00: // nul- ignore
872 case 2: // ctrl-B scroll up full screen
873 case VI_K_PAGEUP: // Cursor Key Page Up
874 dot_scroll(rows - 2, -1);
876 #ifdef BB_FEATURE_VI_USE_SIGNALS
877 case 0x03: // ctrl-C interrupt
880 case 26: // ctrl-Z suspend
881 suspend_sig(SIGTSTP);
883 #endif /* BB_FEATURE_VI_USE_SIGNALS */
884 case 4: // ctrl-D scroll down half screen
885 dot_scroll((rows - 2) / 2, 1);
887 case 5: // ctrl-E scroll down one line
890 case 6: // ctrl-F scroll down full screen
891 case VI_K_PAGEDOWN: // Cursor Key Page Down
892 dot_scroll(rows - 2, 1);
894 case 7: // ctrl-G show current status
897 case 'h': // h- move left
898 case VI_K_LEFT: // cursor key Left
899 case 8: // ctrl-H- move left (This may be ERASE char)
900 case 127: // DEL- move left (This may be ERASE char)
906 case 10: // Newline ^J
907 case 'j': // j- goto next line, same col
908 case VI_K_DOWN: // cursor key Down
912 dot_next(); // go to next B-o-l
913 dot = move_to_col(dot, ccol + offset); // try stay in same col
915 case 12: // ctrl-L force redraw whole screen
916 case 18: // ctrl-R force redraw
917 place_cursor(0, 0, FALSE); // put cursor in correct place
918 clear_to_eos(); // tel terminal to erase display
920 screen_erase(); // erase the internal screen buffer
921 refresh(TRUE); // this will redraw the entire display
923 case 13: // Carriage Return ^M
924 case '+': // +- goto next line
931 case 21: // ctrl-U scroll up half screen
932 dot_scroll((rows - 2) / 2, -1);
934 case 25: // ctrl-Y scroll up one line
940 cmd_mode = 0; // stop insrting
942 *status_buffer = '\0'; // clear status buffer
944 case ' ': // move right
945 case 'l': // move right
946 case VI_K_RIGHT: // Cursor Key Right
952 #ifdef BB_FEATURE_VI_YANKMARK
953 case '"': // "- name a register to use for Delete/Yank
962 case '\'': // '- goto a specific mark
969 if (text <= q && q < end) {
971 dot_begin(); // go to B-o-l
974 } else if (c1 == '\'') { // goto previous context
975 dot = swap_context(dot); // swap current and previous context
976 dot_begin(); // go to B-o-l
982 case 'm': // m- Mark a line
983 // this is really stupid. If there are any inserts or deletes
984 // between text[0] and dot then this mark will not point to the
985 // correct location! It could be off by many lines!
986 // Well..., at least its quick and dirty.
992 mark[(int) c1] = dot;
997 case 'P': // P- Put register before
998 case 'p': // p- put register after
1001 psbs("Nothing in register %c", what_reg());
1004 // are we putting whole lines or strings
1005 if (strchr((char *) p, '\n') != NULL) {
1007 dot_begin(); // putting lines- Put above
1010 // are we putting after very last line?
1011 if (end_line(dot) == (end - 1)) {
1012 dot = end; // force dot to end of text[]
1014 dot_next(); // next line, then put before
1019 dot_right(); // move to right, can move to NL
1021 dot = string_insert(dot, p); // insert the string
1022 end_cmd_q(); // stop adding to q
1024 case 'U': // U- Undo; replace current line with original version
1025 if (reg[Ureg] != 0) {
1026 p = begin_line(dot);
1028 p = text_hole_delete(p, q); // delete cur line
1029 p = string_insert(p, reg[Ureg]); // insert orig line
1034 #endif /* BB_FEATURE_VI_YANKMARK */
1035 case '$': // $- goto end of line
1036 case VI_K_END: // Cursor Key End
1040 dot = end_line(dot + 1);
1042 case '%': // %- find matching char of pair () [] {}
1043 for (q = dot; q < end && *q != '\n'; q++) {
1044 if (strchr("()[]{}", *q) != NULL) {
1045 // we found half of a pair
1046 p = find_pair(q, *q);
1058 case 'f': // f- forward to a user specified char
1059 last_forward_char = get_one_char(); // get the search char
1061 // dont seperate these two commands. 'f' depends on ';'
1063 //**** fall thru to ... 'i'
1064 case ';': // ;- look at rest of line for last forward char
1068 if (last_forward_char == 0) break;
1070 while (q < end - 1 && *q != '\n' && *q != last_forward_char) {
1073 if (*q == last_forward_char)
1076 case '-': // -- goto prev line
1083 #ifdef BB_FEATURE_VI_DOT_CMD
1084 case '.': // .- repeat the last modifying command
1085 // Stuff the last_modifying_cmd back into stdin
1086 // and let it be re-executed.
1087 if (last_modifying_cmd != 0) {
1088 ioq = ioq_start = (Byte *) strdup((char *) last_modifying_cmd);
1091 #endif /* BB_FEATURE_VI_DOT_CMD */
1092 #ifdef BB_FEATURE_VI_SEARCH
1093 case '?': // /- search for a pattern
1094 case '/': // /- search for a pattern
1097 q = get_input_line(buf); // get input line- use "status line"
1098 if (strlen((char *) q) == 1)
1099 goto dc3; // if no pat re-use old pat
1100 if (strlen((char *) q) > 1) { // new pat- save it and find
1101 // there is a new pat
1102 if (last_search_pattern != 0) {
1103 free(last_search_pattern);
1105 last_search_pattern = (Byte *) strdup((char *) q);
1106 goto dc3; // now find the pattern
1108 // user changed mind and erased the "/"- do nothing
1110 case 'N': // N- backward search for last pattern
1114 dir = BACK; // assume BACKWARD search
1116 if (last_search_pattern[0] == '?') {
1120 goto dc4; // now search for pattern
1122 case 'n': // n- repeat search for last pattern
1123 // search rest of text[] starting at next char
1124 // if search fails return orignal "p" not the "p+1" address
1129 if (last_search_pattern == 0) {
1130 msg = (Byte *) "No previous regular expression";
1133 if (last_search_pattern[0] == '/') {
1134 dir = FORWARD; // assume FORWARD search
1137 if (last_search_pattern[0] == '?') {
1142 q = char_search(p, last_search_pattern + 1, dir, FULL);
1144 dot = q; // good search, update "dot"
1148 // no pattern found between "dot" and "end"- continue at top
1153 q = char_search(p, last_search_pattern + 1, dir, FULL);
1154 if (q != NULL) { // found something
1155 dot = q; // found new pattern- goto it
1156 msg = (Byte *) "search hit BOTTOM, continuing at TOP";
1158 msg = (Byte *) "search hit TOP, continuing at BOTTOM";
1161 msg = (Byte *) "Pattern not found";
1166 case '{': // {- move backward paragraph
1167 q = char_search(dot, (Byte *) "\n\n", BACK, FULL);
1168 if (q != NULL) { // found blank line
1169 dot = next_line(q); // move to next blank line
1172 case '}': // }- move forward paragraph
1173 q = char_search(dot, (Byte *) "\n\n", FORWARD, FULL);
1174 if (q != NULL) { // found blank line
1175 dot = next_line(q); // move to next blank line
1178 #endif /* BB_FEATURE_VI_SEARCH */
1179 case '0': // 0- goto begining of line
1189 if (c == '0' && cmdcnt < 1) {
1190 dot_begin(); // this was a standalone zero
1192 cmdcnt = cmdcnt * 10 + (c - '0'); // this 0 is part of a number
1195 case ':': // :- the colon mode commands
1196 p = get_input_line((Byte *) ":"); // get input line- use "status line"
1197 #ifdef BB_FEATURE_VI_COLON
1198 colon(p); // execute the command
1199 #else /* BB_FEATURE_VI_COLON */
1201 p++; // move past the ':'
1202 cnt = strlen((char *) p);
1205 if (strncasecmp((char *) p, "quit", cnt) == 0 ||
1206 strncasecmp((char *) p, "q!", cnt) == 0) { // delete lines
1207 if (file_modified == TRUE && p[1] != '!') {
1208 psbs("No write since last change (:quit! overrides)");
1212 } else if (strncasecmp((char *) p, "write", cnt) == 0 ||
1213 strncasecmp((char *) p, "wq", cnt) == 0) {
1214 cnt = file_write(cfn, text, end - 1);
1215 file_modified = FALSE;
1216 psb("\"%s\" %dL, %dC", cfn, count_lines(text, end - 1), cnt);
1220 } else if (strncasecmp((char *) p, "file", cnt) == 0 ) {
1221 edit_status(); // show current file status
1222 } else if (sscanf((char *) p, "%d", &j) > 0) {
1223 dot = find_line(j); // go to line # j
1225 } else { // unrecognised cmd
1228 #endif /* BB_FEATURE_VI_COLON */
1230 case '<': // <- Left shift something
1231 case '>': // >- Right shift something
1232 cnt = count_lines(text, dot); // remember what line we are on
1233 c1 = get_one_char(); // get the type of thing to delete
1234 find_range(&p, &q, c1);
1235 (void) yank_delete(p, q, 1, YANKONLY); // save copy before change
1238 i = count_lines(p, q); // # of lines we are shifting
1239 for ( ; i > 0; i--, p = next_line(p)) {
1241 // shift left- remove tab or 8 spaces
1243 // shrink buffer 1 char
1244 (void) text_hole_delete(p, p);
1245 } else if (*p == ' ') {
1246 // we should be calculating columns, not just SPACE
1247 for (j = 0; *p == ' ' && j < tabstop; j++) {
1248 (void) text_hole_delete(p, p);
1251 } else if (c == '>') {
1252 // shift right -- add tab or 8 spaces
1253 (void) char_insert(p, '\t');
1256 dot = find_line(cnt); // what line were we on
1258 end_cmd_q(); // stop adding to q
1260 case 'A': // A- append at e-o-l
1261 dot_end(); // go to e-o-l
1262 //**** fall thru to ... 'a'
1263 case 'a': // a- append after current char
1268 case 'B': // B- back a blank-delimited Word
1269 case 'E': // E- end of a blank-delimited word
1270 case 'W': // W- forward a blank-delimited word
1277 if (c == 'W' || isspace(dot[dir])) {
1278 dot = skip_thing(dot, 1, dir, S_TO_WS);
1279 dot = skip_thing(dot, 2, dir, S_OVER_WS);
1282 dot = skip_thing(dot, 1, dir, S_BEFORE_WS);
1284 case 'C': // C- Change to e-o-l
1285 case 'D': // D- delete to e-o-l
1287 dot = dollar_line(dot); // move to before NL
1288 // copy text into a register and delete
1289 dot = yank_delete(save_dot, dot, 0, YANKDEL); // delete to e-o-l
1291 goto dc_i; // start inserting
1292 #ifdef BB_FEATURE_VI_DOT_CMD
1294 end_cmd_q(); // stop adding to q
1295 #endif /* BB_FEATURE_VI_DOT_CMD */
1297 case 'G': // G- goto to a line number (default= E-O-F)
1298 dot = end - 1; // assume E-O-F
1300 dot = find_line(cmdcnt); // what line is #cmdcnt
1304 case 'H': // H- goto top line on screen
1306 if (cmdcnt > (rows - 1)) {
1307 cmdcnt = (rows - 1);
1314 case 'I': // I- insert before first non-blank
1317 //**** fall thru to ... 'i'
1318 case 'i': // i- insert before current char
1319 case VI_K_INSERT: // Cursor Key Insert
1321 cmd_mode = 1; // start insrting
1322 psb("-- Insert --");
1324 case 'J': // J- join current and next lines together
1328 dot_end(); // move to NL
1329 if (dot < end - 1) { // make sure not last char in text[]
1330 *dot++ = ' '; // replace NL with space
1331 while (isblnk(*dot)) { // delete leading WS
1335 end_cmd_q(); // stop adding to q
1337 case 'L': // L- goto bottom line on screen
1339 if (cmdcnt > (rows - 1)) {
1340 cmdcnt = (rows - 1);
1348 case 'M': // M- goto middle line on screen
1350 for (cnt = 0; cnt < (rows-1) / 2; cnt++)
1351 dot = next_line(dot);
1353 case 'O': // O- open a empty line above
1355 p = begin_line(dot);
1356 if (p[-1] == '\n') {
1358 case 'o': // o- open a empty line below; Yes, I know it is in the middle of the "if (..."
1360 dot = char_insert(dot, '\n');
1363 dot = char_insert(dot, '\n'); // i\n ESC
1368 case 'R': // R- continuous Replace char
1371 psb("-- Replace --");
1373 case 'X': // X- delete char before dot
1374 case 'x': // x- delete the current char
1375 case 's': // s- substitute the current char
1382 if (dot[dir] != '\n') {
1384 dot--; // delete prev char
1385 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
1388 goto dc_i; // start insrting
1389 end_cmd_q(); // stop adding to q
1391 case 'Z': // Z- if modified, {write}; exit
1392 // ZZ means to save file (if necessary), then exit
1393 c1 = get_one_char();
1398 if (file_modified == TRUE
1399 #ifdef BB_FEATURE_VI_READONLY
1400 && vi_readonly == FALSE
1401 && readonly == FALSE
1402 #endif /* BB_FEATURE_VI_READONLY */
1404 cnt = file_write(cfn, text, end - 1);
1405 if (cnt == (end - 1 - text + 1)) {
1412 case '^': // ^- move to first non-blank on line
1416 case 'b': // b- back a word
1417 case 'e': // e- end of word
1424 if ((dot + dir) < text || (dot + dir) > end - 1)
1427 if (isspace(*dot)) {
1428 dot = skip_thing(dot, (c == 'e') ? 2 : 1, dir, S_OVER_WS);
1430 if (isalnum(*dot) || *dot == '_') {
1431 dot = skip_thing(dot, 1, dir, S_END_ALNUM);
1432 } else if (ispunct(*dot)) {
1433 dot = skip_thing(dot, 1, dir, S_END_PUNCT);
1436 case 'c': // c- change something
1437 case 'd': // d- delete something
1438 #ifdef BB_FEATURE_VI_YANKMARK
1439 case 'y': // y- yank something
1440 case 'Y': // Y- Yank a line
1441 #endif /* BB_FEATURE_VI_YANKMARK */
1442 yf = YANKDEL; // assume either "c" or "d"
1443 #ifdef BB_FEATURE_VI_YANKMARK
1444 if (c == 'y' || c == 'Y')
1446 #endif /* BB_FEATURE_VI_YANKMARK */
1449 c1 = get_one_char(); // get the type of thing to delete
1450 find_range(&p, &q, c1);
1451 if (c1 == 27) { // ESC- user changed mind and wants out
1452 c = c1 = 27; // Escape- do nothing
1453 } else if (strchr("wW", c1)) {
1455 // don't include trailing WS as part of word
1456 while (isblnk(*q)) {
1457 if (q <= text || q[-1] == '\n')
1462 dot = yank_delete(p, q, 0, yf); // delete word
1463 } else if (strchr("^0bBeEft$", c1)) {
1464 // single line copy text into a register and delete
1465 dot = yank_delete(p, q, 0, yf); // delete word
1466 } else if (strchr("cdykjHL%+-{}\r\n", c1)) {
1467 // multiple line copy text into a register and delete
1468 dot = yank_delete(p, q, 1, yf); // delete lines
1470 dot = char_insert(dot, '\n');
1471 // on the last line of file don't move to prev line
1472 if (dot != (end-1)) {
1475 } else if (c == 'd') {
1480 // could not recognize object
1481 c = c1 = 27; // error-
1485 // if CHANGING, not deleting, start inserting after the delete
1487 strcpy((char *) buf, "Change");
1488 goto dc_i; // start inserting
1491 strcpy((char *) buf, "Delete");
1493 #ifdef BB_FEATURE_VI_YANKMARK
1494 if (c == 'y' || c == 'Y') {
1495 strcpy((char *) buf, "Yank");
1498 q = p + strlen((char *) p);
1499 for (cnt = 0; p <= q; p++) {
1503 psb("%s %d lines (%d chars) using [%c]",
1504 buf, cnt, strlen((char *) reg[YDreg]), what_reg());
1505 #endif /* BB_FEATURE_VI_YANKMARK */
1506 end_cmd_q(); // stop adding to q
1509 case 'k': // k- goto prev line, same col
1510 case VI_K_UP: // cursor key Up
1515 dot = move_to_col(dot, ccol + offset); // try stay in same col
1517 case 'r': // r- replace the current char with user input
1518 c1 = get_one_char(); // get the replacement char
1521 file_modified = TRUE; // has the file been modified
1523 end_cmd_q(); // stop adding to q
1525 case 't': // t- move to char prior to next x
1526 last_forward_char = get_one_char();
1528 if (*dot == last_forward_char)
1530 last_forward_char= 0;
1532 case 'w': // w- forward a word
1536 if (isalnum(*dot) || *dot == '_') { // we are on ALNUM
1537 dot = skip_thing(dot, 1, FORWARD, S_END_ALNUM);
1538 } else if (ispunct(*dot)) { // we are on PUNCT
1539 dot = skip_thing(dot, 1, FORWARD, S_END_PUNCT);
1542 dot++; // move over word
1543 if (isspace(*dot)) {
1544 dot = skip_thing(dot, 2, FORWARD, S_OVER_WS);
1548 c1 = get_one_char(); // get the replacement char
1551 cnt = (rows - 2) / 2; // put dot at center
1553 cnt = rows - 2; // put dot at bottom
1554 screenbegin = begin_line(dot); // start dot at top
1555 dot_scroll(cnt, -1);
1557 case '|': // |- move to column "cmdcnt"
1558 dot = move_to_col(dot, cmdcnt - 1); // try to move to column
1560 case '~': // ~- flip the case of letters a-z -> A-Z
1564 if (islower(*dot)) {
1565 *dot = toupper(*dot);
1566 file_modified = TRUE; // has the file been modified
1567 } else if (isupper(*dot)) {
1568 *dot = tolower(*dot);
1569 file_modified = TRUE; // has the file been modified
1572 end_cmd_q(); // stop adding to q
1574 //----- The Cursor and Function Keys -----------------------------
1575 case VI_K_HOME: // Cursor Key Home
1578 // The Fn keys could point to do_macro which could translate them
1579 case VI_K_FUN1: // Function Key F1
1580 case VI_K_FUN2: // Function Key F2
1581 case VI_K_FUN3: // Function Key F3
1582 case VI_K_FUN4: // Function Key F4
1583 case VI_K_FUN5: // Function Key F5
1584 case VI_K_FUN6: // Function Key F6
1585 case VI_K_FUN7: // Function Key F7
1586 case VI_K_FUN8: // Function Key F8
1587 case VI_K_FUN9: // Function Key F9
1588 case VI_K_FUN10: // Function Key F10
1589 case VI_K_FUN11: // Function Key F11
1590 case VI_K_FUN12: // Function Key F12
1595 // if text[] just became empty, add back an empty line
1597 (void) char_insert(text, '\n'); // start empty buf with dummy line
1600 // it is OK for dot to exactly equal to end, otherwise check dot validity
1602 dot = bound_dot(dot); // make sure "dot" is valid
1604 #ifdef BB_FEATURE_VI_YANKMARK
1605 check_context(c); // update the current context
1606 #endif /* BB_FEATURE_VI_YANKMARK */
1609 cmdcnt = 0; // cmd was not a number, reset cmdcnt
1610 cnt = dot - begin_line(dot);
1611 // Try to stay off of the Newline
1612 if (*dot == '\n' && cnt > 0 && cmd_mode == 0)
1616 //----- The Colon commands -------------------------------------
1617 #ifdef BB_FEATURE_VI_COLON
1618 static Byte *get_one_address(Byte * p, int *addr) // get colon addr, if present
1623 #ifdef BB_FEATURE_VI_YANKMARK
1625 #endif /* BB_FEATURE_VI_YANKMARK */
1626 #ifdef BB_FEATURE_VI_SEARCH
1627 Byte *pat, buf[BUFSIZ];
1628 #endif /* BB_FEATURE_VI_SEARCH */
1630 *addr = -1; // assume no addr
1631 if (*p == '.') { // the current line
1633 q = begin_line(dot);
1634 *addr = count_lines(text, q);
1635 #ifdef BB_FEATURE_VI_YANKMARK
1636 } else if (*p == '\'') { // is this a mark addr
1640 if (c >= 'a' && c <= 'z') {
1644 if (q != NULL) { // is mark valid
1645 *addr = count_lines(text, q); // count lines
1648 #endif /* BB_FEATURE_VI_YANKMARK */
1649 #ifdef BB_FEATURE_VI_SEARCH
1650 } else if (*p == '/') { // a search pattern
1652 for (p++; *p; p++) {
1658 pat = (Byte *) strdup((char *) buf); // save copy of pattern
1661 q = char_search(dot, pat, FORWARD, FULL);
1663 *addr = count_lines(text, q);
1666 #endif /* BB_FEATURE_VI_SEARCH */
1667 } else if (*p == '$') { // the last line in file
1669 q = begin_line(end - 1);
1670 *addr = count_lines(text, q);
1671 } else if (isdigit(*p)) { // specific line number
1672 sscanf((char *) p, "%d%n", addr, &st);
1674 } else { // I don't reconise this
1675 // unrecognised address- assume -1
1681 static Byte *get_address(Byte *p, int *b, int *e) // get two colon addrs, if present
1683 //----- get the address' i.e., 1,3 'a,'b -----
1684 // get FIRST addr, if present
1686 p++; // skip over leading spaces
1687 if (*p == '%') { // alias for 1,$
1690 *e = count_lines(text, end-1);
1693 p = get_one_address(p, b);
1696 if (*p == ',') { // is there a address seperator
1700 // get SECOND addr, if present
1701 p = get_one_address(p, e);
1705 p++; // skip over trailing spaces
1709 static void colon(Byte * buf)
1711 Byte c, *orig_buf, *buf1, *q, *r;
1712 Byte *fn, cmd[BUFSIZ], args[BUFSIZ];
1713 int i, l, li, ch, st, b, e;
1714 int useforce, forced;
1717 // :3154 // if (-e line 3154) goto it else stay put
1718 // :4,33w! foo // write a portion of buffer to file "foo"
1719 // :w // write all of buffer to current file
1721 // :q! // quit- dont care about modified file
1722 // :'a,'z!sort -u // filter block through sort
1723 // :'f // goto mark "f"
1724 // :'fl // list literal the mark "f" line
1725 // :.r bar // read file "bar" into buffer before dot
1726 // :/123/,/abc/d // delete lines from "123" line to "abc" line
1727 // :/xyz/ // goto the "xyz" line
1728 // :s/find/replace/ // substitute pattern "find" with "replace"
1729 // :!<cmd> // run <cmd> then return
1731 if (strlen((char *) buf) <= 0)
1734 buf++; // move past the ':'
1736 forced = useforce = FALSE;
1737 li = st = ch = i = 0;
1739 q = text; // assume 1,$ for the range
1741 li = count_lines(text, end - 1);
1742 fn = cfn; // default to current file
1743 memset(cmd, '\0', BUFSIZ); // clear cmd[]
1744 memset(args, '\0', BUFSIZ); // clear args[]
1746 // look for optional address(es) :. :1 :1,9 :'q,'a :%
1747 buf = get_address(buf, &b, &e);
1749 // remember orig command line
1752 // get the COMMAND into cmd[]
1754 while (*buf != '\0') {
1759 // get any ARGuments
1760 while (isblnk(*buf))
1762 strcpy((char *) args, (char *) buf);
1763 buf1 = last_char_is((char *)cmd, '!');
1766 *buf1 = '\0'; // get rid of !
1769 // if there is only one addr, then the addr
1770 // is the line number of the single line the
1771 // user wants. So, reset the end
1772 // pointer to point at end of the "b" line
1773 q = find_line(b); // what line is #b
1778 // we were given two addrs. change the
1779 // end pointer to the addr given by user.
1780 r = find_line(e); // what line is #e
1784 // ------------ now look for the command ------------
1785 i = strlen((char *) cmd);
1786 if (i == 0) { // :123CR goto line #123
1788 dot = find_line(b); // what line is #b
1791 } else if (strncmp((char *) cmd, "!", 1) == 0) { // run a cmd
1792 // :!ls run the <cmd>
1793 (void) alarm(0); // wait for input- no alarms
1794 place_cursor(rows - 1, 0, FALSE); // go to Status line
1795 clear_to_eol(); // clear the line
1797 system(orig_buf+1); // run the cmd
1799 Hit_Return(); // let user see results
1800 (void) alarm(3); // done waiting for input
1801 } else if (strncmp((char *) cmd, "=", i) == 0) { // where is the address
1802 if (b < 0) { // no addr given- use defaults
1803 b = e = count_lines(text, dot);
1806 } else if (strncasecmp((char *) cmd, "delete", i) == 0) { // delete lines
1807 if (b < 0) { // no addr given- use defaults
1808 q = begin_line(dot); // assume .,. for the range
1811 dot = yank_delete(q, r, 1, YANKDEL); // save, then delete lines
1813 } else if (strncasecmp((char *) cmd, "edit", i) == 0) { // Edit a file
1816 // don't edit, if the current file has been modified
1817 if (file_modified == TRUE && useforce != TRUE) {
1818 psbs("No write since last change (:edit! overrides)");
1821 if (strlen(args) > 0) {
1822 // the user supplied a file name
1824 } else if (cfn != 0 && strlen(cfn) > 0) {
1825 // no user supplied name- use the current filename
1829 // no user file name, no current name- punt
1830 psbs("No current filename");
1834 // see if file exists- if not, its just a new file request
1835 if ((sr=stat((char*)fn, &st_buf)) < 0) {
1836 // This is just a request for a new file creation.
1837 // The file_insert below will fail but we get
1838 // an empty buffer with a file name. Then the "write"
1839 // command can do the create.
1841 if ((st_buf.st_mode & (S_IFREG)) == 0) {
1842 // This is not a regular file
1843 psbs("\"%s\" is not a regular file", fn);
1846 if ((st_buf.st_mode & (S_IRUSR | S_IRGRP | S_IROTH)) == 0) {
1847 // dont have any read permissions
1848 psbs("\"%s\" is not readable", fn);
1853 // There is a read-able regular file
1854 // make this the current file
1855 q = (Byte *) strdup((char *) fn); // save the cfn
1857 free(cfn); // free the old name
1858 cfn = q; // remember new cfn
1861 // delete all the contents of text[]
1862 new_text(2 * file_size(fn));
1863 screenbegin = dot = end = text;
1866 ch = file_insert(fn, text, file_size(fn));
1869 // start empty buf with dummy line
1870 (void) char_insert(text, '\n');
1873 file_modified = FALSE;
1874 #ifdef BB_FEATURE_VI_YANKMARK
1875 if (Ureg >= 0 && Ureg < 28 && reg[Ureg] != 0) {
1876 free(reg[Ureg]); // free orig line reg- for 'U'
1879 if (YDreg >= 0 && YDreg < 28 && reg[YDreg] != 0) {
1880 free(reg[YDreg]); // free default yank/delete register
1883 for (li = 0; li < 28; li++) {
1886 #endif /* BB_FEATURE_VI_YANKMARK */
1887 // how many lines in text[]?
1888 li = count_lines(text, end - 1);
1890 #ifdef BB_FEATURE_VI_READONLY
1892 #endif /* BB_FEATURE_VI_READONLY */
1894 (sr < 0 ? " [New file]" : ""),
1895 #ifdef BB_FEATURE_VI_READONLY
1896 ((vi_readonly == TRUE || readonly == TRUE) ? " [Read only]" : ""),
1897 #endif /* BB_FEATURE_VI_READONLY */
1899 } else if (strncasecmp((char *) cmd, "file", i) == 0) { // what File is this
1900 if (b != -1 || e != -1) {
1901 ni((Byte *) "No address allowed on this command");
1904 if (strlen((char *) args) > 0) {
1905 // user wants a new filename
1908 cfn = (Byte *) strdup((char *) args);
1910 // user wants file status info
1913 } else if (strncasecmp((char *) cmd, "features", i) == 0) { // what features are available
1914 // print out values of all features
1915 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
1916 clear_to_eol(); // clear the line
1921 } else if (strncasecmp((char *) cmd, "list", i) == 0) { // literal print line
1922 if (b < 0) { // no addr given- use defaults
1923 q = begin_line(dot); // assume .,. for the range
1926 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
1927 clear_to_eol(); // clear the line
1928 write(1, "\r\n", 2);
1929 for (; q <= r; q++) {
1935 } else if (*q < ' ') {
1943 #ifdef BB_FEATURE_VI_SET
1945 #endif /* BB_FEATURE_VI_SET */
1947 } else if ((strncasecmp((char *) cmd, "quit", i) == 0) || // Quit
1948 (strncasecmp((char *) cmd, "next", i) == 0)) { // edit next file
1949 if (useforce == TRUE) {
1950 // force end of argv list
1957 // don't exit if the file been modified
1958 if (file_modified == TRUE) {
1959 psbs("No write since last change (:%s! overrides)",
1960 (*cmd == 'q' ? "quit" : "next"));
1963 // are there other file to edit
1964 if (*cmd == 'q' && optind < save_argc - 1) {
1965 psbs("%d more file to edit", (save_argc - optind - 1));
1968 if (*cmd == 'n' && optind >= save_argc - 1) {
1969 psbs("No more files to edit");
1973 } else if (strncasecmp((char *) cmd, "read", i) == 0) { // read file into text[]
1975 if (strlen((char *) fn) <= 0) {
1976 psbs("No filename given");
1979 if (b < 0) { // no addr given- use defaults
1980 q = begin_line(dot); // assume "dot"
1982 // read after current line- unless user said ":0r foo"
1985 l= readonly; // remember current files' status
1986 ch = file_insert(fn, q, file_size(fn));
1989 goto vc1; // nothing was inserted
1990 // how many lines in text[]?
1991 li = count_lines(q, q + ch - 1);
1993 #ifdef BB_FEATURE_VI_READONLY
1995 #endif /* BB_FEATURE_VI_READONLY */
1997 #ifdef BB_FEATURE_VI_READONLY
1998 ((vi_readonly == TRUE || readonly == TRUE) ? " [Read only]" : ""),
1999 #endif /* BB_FEATURE_VI_READONLY */
2002 // if the insert is before "dot" then we need to update
2005 file_modified = TRUE;
2007 } else if (strncasecmp((char *) cmd, "rewind", i) == 0) { // rewind cmd line args
2008 if (file_modified == TRUE && useforce != TRUE) {
2009 psbs("No write since last change (:rewind! overrides)");
2011 // reset the filenames to edit
2012 optind = fn_start - 1;
2015 #ifdef BB_FEATURE_VI_SET
2016 } else if (strncasecmp((char *) cmd, "set", i) == 0) { // set or clear features
2017 i = 0; // offset into args
2018 if (strlen((char *) args) == 0) {
2019 // print out values of all options
2020 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
2021 clear_to_eol(); // clear the line
2022 printf("----------------------------------------\r\n");
2023 #ifdef BB_FEATURE_VI_SETOPTS
2026 printf("autoindent ");
2032 printf("ignorecase ");
2035 printf("showmatch ");
2036 printf("tabstop=%d ", tabstop);
2037 #endif /* BB_FEATURE_VI_SETOPTS */
2041 if (strncasecmp((char *) args, "no", 2) == 0)
2042 i = 2; // ":set noautoindent"
2043 #ifdef BB_FEATURE_VI_SETOPTS
2044 if (strncasecmp((char *) args + i, "autoindent", 10) == 0 ||
2045 strncasecmp((char *) args + i, "ai", 2) == 0) {
2046 autoindent = (i == 2) ? 0 : 1;
2048 if (strncasecmp((char *) args + i, "flash", 5) == 0 ||
2049 strncasecmp((char *) args + i, "fl", 2) == 0) {
2050 err_method = (i == 2) ? 0 : 1;
2052 if (strncasecmp((char *) args + i, "ignorecase", 10) == 0 ||
2053 strncasecmp((char *) args + i, "ic", 2) == 0) {
2054 ignorecase = (i == 2) ? 0 : 1;
2056 if (strncasecmp((char *) args + i, "showmatch", 9) == 0 ||
2057 strncasecmp((char *) args + i, "sm", 2) == 0) {
2058 showmatch = (i == 2) ? 0 : 1;
2060 if (strncasecmp((char *) args + i, "tabstop", 7) == 0) {
2061 sscanf(strchr((char *) args + i, '='), "=%d", &ch);
2062 if (ch > 0 && ch < columns - 1)
2065 #endif /* BB_FEATURE_VI_SETOPTS */
2066 #endif /* BB_FEATURE_VI_SET */
2067 #ifdef BB_FEATURE_VI_SEARCH
2068 } else if (strncasecmp((char *) cmd, "s", 1) == 0) { // substitute a pattern with a replacement pattern
2072 // F points to the "find" pattern
2073 // R points to the "replace" pattern
2074 // replace the cmd line delimiters "/" with NULLs
2075 gflag = 0; // global replace flag
2076 c = orig_buf[1]; // what is the delimiter
2077 F = orig_buf + 2; // start of "find"
2078 R = (Byte *) strchr((char *) F, c); // middle delimiter
2079 if (!R) goto colon_s_fail;
2080 *R++ = '\0'; // terminate "find"
2081 buf1 = (Byte *) strchr((char *) R, c);
2082 if (!buf1) goto colon_s_fail;
2083 *buf1++ = '\0'; // terminate "replace"
2084 if (*buf1 == 'g') { // :s/foo/bar/g
2086 gflag++; // turn on gflag
2089 if (b < 0) { // maybe :s/foo/bar/
2090 q = begin_line(dot); // start with cur line
2091 b = count_lines(text, q); // cur line number
2094 e = b; // maybe :.s/foo/bar/
2095 for (i = b; i <= e; i++) { // so, :20,23 s \0 find \0 replace \0
2096 ls = q; // orig line start
2098 buf1 = char_search(q, F, FORWARD, LIMITED); // search cur line only for "find"
2100 // we found the "find" pattern- delete it
2101 (void) text_hole_delete(buf1, buf1 + strlen((char *) F) - 1);
2102 // inset the "replace" patern
2103 (void) string_insert(buf1, R); // insert the string
2104 // check for "global" :s/foo/bar/g
2106 if ((buf1 + strlen((char *) R)) < end_line(ls)) {
2107 q = buf1 + strlen((char *) R);
2108 goto vc4; // don't let q move past cur line
2114 #endif /* BB_FEATURE_VI_SEARCH */
2115 } else if (strncasecmp((char *) cmd, "version", i) == 0) { // show software version
2116 psb("%s", vi_Version);
2117 } else if ((strncasecmp((char *) cmd, "write", i) == 0) || // write text to file
2118 (strncasecmp((char *) cmd, "wq", i) == 0)) { // write text to file
2119 // is there a file name to write to?
2120 if (strlen((char *) args) > 0) {
2123 #ifdef BB_FEATURE_VI_READONLY
2124 if ((vi_readonly == TRUE || readonly == TRUE) && useforce == FALSE) {
2125 psbs("\"%s\" File is read only", fn);
2128 #endif /* BB_FEATURE_VI_READONLY */
2129 // how many lines in text[]?
2130 li = count_lines(q, r);
2132 // see if file exists- if not, its just a new file request
2133 if (useforce == TRUE) {
2134 // if "fn" is not write-able, chmod u+w
2135 // sprintf(syscmd, "chmod u+w %s", fn);
2139 l = file_write(fn, q, r);
2140 if (useforce == TRUE && forced == TRUE) {
2142 // sprintf(syscmd, "chmod u-w %s", fn);
2146 psb("\"%s\" %dL, %dC", fn, li, l);
2147 if (q == text && r == end - 1 && l == ch)
2148 file_modified = FALSE;
2149 if (cmd[1] == 'q' && l == ch) {
2152 #ifdef BB_FEATURE_VI_READONLY
2154 #endif /* BB_FEATURE_VI_READONLY */
2155 #ifdef BB_FEATURE_VI_YANKMARK
2156 } else if (strncasecmp((char *) cmd, "yank", i) == 0) { // yank lines
2157 if (b < 0) { // no addr given- use defaults
2158 q = begin_line(dot); // assume .,. for the range
2161 text_yank(q, r, YDreg);
2162 li = count_lines(q, r);
2163 psb("Yank %d lines (%d chars) into [%c]",
2164 li, strlen((char *) reg[YDreg]), what_reg());
2165 #endif /* BB_FEATURE_VI_YANKMARK */
2171 dot = bound_dot(dot); // make sure "dot" is valid
2173 #ifdef BB_FEATURE_VI_SEARCH
2175 psb(":s expression missing delimiters");
2181 static void Hit_Return(void)
2185 standout_start(); // start reverse video
2186 write(1, "[Hit return to continue]", 24);
2187 standout_end(); // end reverse video
2188 while ((c = get_one_char()) != '\n' && c != '\r') /*do nothing */
2190 redraw(TRUE); // force redraw all
2192 #endif /* BB_FEATURE_VI_COLON */
2194 //----- Synchronize the cursor to Dot --------------------------
2195 static void sync_cursor(Byte * d, int *row, int *col)
2197 Byte *beg_cur, *end_cur; // begin and end of "d" line
2198 Byte *beg_scr, *end_scr; // begin and end of screen
2202 beg_cur = begin_line(d); // first char of cur line
2203 end_cur = end_line(d); // last char of cur line
2205 beg_scr = end_scr = screenbegin; // first char of screen
2206 end_scr = end_screen(); // last char of screen
2208 if (beg_cur < screenbegin) {
2209 // "d" is before top line on screen
2210 // how many lines do we have to move
2211 cnt = count_lines(beg_cur, screenbegin);
2213 screenbegin = beg_cur;
2214 if (cnt > (rows - 1) / 2) {
2215 // we moved too many lines. put "dot" in middle of screen
2216 for (cnt = 0; cnt < (rows - 1) / 2; cnt++) {
2217 screenbegin = prev_line(screenbegin);
2220 } else if (beg_cur > end_scr) {
2221 // "d" is after bottom line on screen
2222 // how many lines do we have to move
2223 cnt = count_lines(end_scr, beg_cur);
2224 if (cnt > (rows - 1) / 2)
2225 goto sc1; // too many lines
2226 for (ro = 0; ro < cnt - 1; ro++) {
2227 // move screen begin the same amount
2228 screenbegin = next_line(screenbegin);
2229 // now, move the end of screen
2230 end_scr = next_line(end_scr);
2231 end_scr = end_line(end_scr);
2234 // "d" is on screen- find out which row
2236 for (ro = 0; ro < rows - 1; ro++) { // drive "ro" to correct row
2242 // find out what col "d" is on
2244 do { // drive "co" to correct column
2245 if (*tp == '\n' || *tp == '\0')
2249 co += ((tabstop - 1) - (co % tabstop));
2250 } else if (*tp < ' ') {
2251 co++; // display as ^X, use 2 columns
2253 } while (tp++ < d && ++co);
2255 // "co" is the column where "dot" is.
2256 // The screen has "columns" columns.
2257 // The currently displayed columns are 0+offset -- columns+ofset
2258 // |-------------------------------------------------------------|
2260 // offset | |------- columns ----------------|
2262 // If "co" is already in this range then we do not have to adjust offset
2263 // but, we do have to subtract the "offset" bias from "co".
2264 // If "co" is outside this range then we have to change "offset".
2265 // If the first char of a line is a tab the cursor will try to stay
2266 // in column 7, but we have to set offset to 0.
2268 if (co < 0 + offset) {
2271 if (co >= columns + offset) {
2272 offset = co - columns + 1;
2274 // if the first char of the line is a tab, and "dot" is sitting on it
2275 // force offset to 0.
2276 if (d == beg_cur && *d == '\t') {
2285 //----- Text Movement Routines ---------------------------------
2286 static Byte *begin_line(Byte * p) // return pointer to first char cur line
2288 while (p > text && p[-1] != '\n')
2289 p--; // go to cur line B-o-l
2293 static Byte *end_line(Byte * p) // return pointer to NL of cur line line
2295 while (p < end - 1 && *p != '\n')
2296 p++; // go to cur line E-o-l
2300 static Byte *dollar_line(Byte * p) // return pointer to just before NL line
2302 while (p < end - 1 && *p != '\n')
2303 p++; // go to cur line E-o-l
2304 // Try to stay off of the Newline
2305 if (*p == '\n' && (p - begin_line(p)) > 0)
2310 static Byte *prev_line(Byte * p) // return pointer first char prev line
2312 p = begin_line(p); // goto begining of cur line
2313 if (p[-1] == '\n' && p > text)
2314 p--; // step to prev line
2315 p = begin_line(p); // goto begining of prev line
2319 static Byte *next_line(Byte * p) // return pointer first char next line
2322 if (*p == '\n' && p < end - 1)
2323 p++; // step to next line
2327 //----- Text Information Routines ------------------------------
2328 static Byte *end_screen(void)
2333 // find new bottom line
2335 for (cnt = 0; cnt < rows - 2; cnt++)
2341 static int count_lines(Byte * start, Byte * stop) // count line from start to stop
2346 if (stop < start) { // start and stop are backwards- reverse them
2352 stop = end_line(stop); // get to end of this line
2353 for (q = start; q <= stop && q <= end - 1; q++) {
2360 static Byte *find_line(int li) // find begining of line #li
2364 for (q = text; li > 1; li--) {
2370 //----- Dot Movement Routines ----------------------------------
2371 static void dot_left(void)
2373 if (dot > text && dot[-1] != '\n')
2377 static void dot_right(void)
2379 if (dot < end - 1 && *dot != '\n')
2383 static void dot_begin(void)
2385 dot = begin_line(dot); // return pointer to first char cur line
2388 static void dot_end(void)
2390 dot = end_line(dot); // return pointer to last char cur line
2393 static Byte *move_to_col(Byte * p, int l)
2400 if (*p == '\n' || *p == '\0')
2404 co += ((tabstop - 1) - (co % tabstop));
2405 } else if (*p < ' ') {
2406 co++; // display as ^X, use 2 columns
2408 } while (++co <= l && p++ < end);
2412 static void dot_next(void)
2414 dot = next_line(dot);
2417 static void dot_prev(void)
2419 dot = prev_line(dot);
2422 static void dot_scroll(int cnt, int dir)
2426 for (; cnt > 0; cnt--) {
2429 // ctrl-Y scroll up one line
2430 screenbegin = prev_line(screenbegin);
2433 // ctrl-E scroll down one line
2434 screenbegin = next_line(screenbegin);
2437 // make sure "dot" stays on the screen so we dont scroll off
2438 if (dot < screenbegin)
2440 q = end_screen(); // find new bottom line
2442 dot = begin_line(q); // is dot is below bottom line?
2446 static void dot_skip_over_ws(void)
2449 while (isspace(*dot) && *dot != '\n' && dot < end - 1)
2453 static void dot_delete(void) // delete the char at 'dot'
2455 (void) text_hole_delete(dot, dot);
2458 static Byte *bound_dot(Byte * p) // make sure text[0] <= P < "end"
2460 if (p >= end && end > text) {
2462 indicate_error('1');
2466 indicate_error('2');
2471 //----- Helper Utility Routines --------------------------------
2473 //----------------------------------------------------------------
2474 //----- Char Routines --------------------------------------------
2475 /* Chars that are part of a word-
2476 * 0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
2477 * Chars that are Not part of a word (stoppers)
2478 * !"#$%&'()*+,-./:;<=>?@[\]^`{|}~
2479 * Chars that are WhiteSpace
2480 * TAB NEWLINE VT FF RETURN SPACE
2481 * DO NOT COUNT NEWLINE AS WHITESPACE
2484 static Byte *new_screen(int ro, int co)
2490 screensize = ro * co + 8;
2491 screen = (Byte *) malloc(screensize);
2492 // initialize the new screen. assume this will be a empty file.
2494 // non-existant text[] lines start with a tilde (~).
2495 for (li = 1; li < ro - 1; li++) {
2496 screen[(li * co) + 0] = '~';
2501 static Byte *new_text(int size)
2504 size = 10240; // have a minimum size for new files
2509 text = (Byte *) malloc(size + 8);
2510 memset(text, '\0', size); // clear new text[]
2511 //text += 4; // leave some room for "oops"
2512 textend = text + size - 1;
2513 //textend -= 4; // leave some root for "oops"
2517 #ifdef BB_FEATURE_VI_SEARCH
2518 static int mycmp(Byte * s1, Byte * s2, int len)
2522 i = strncmp((char *) s1, (char *) s2, len);
2523 #ifdef BB_FEATURE_VI_SETOPTS
2525 i = strncasecmp((char *) s1, (char *) s2, len);
2527 #endif /* BB_FEATURE_VI_SETOPTS */
2531 static Byte *char_search(Byte * p, Byte * pat, int dir, int range) // search for pattern starting at p
2533 #ifndef REGEX_SEARCH
2537 len = strlen((char *) pat);
2538 if (dir == FORWARD) {
2539 stop = end - 1; // assume range is p - end-1
2540 if (range == LIMITED)
2541 stop = next_line(p); // range is to next line
2542 for (start = p; start < stop; start++) {
2543 if (mycmp(start, pat, len) == 0) {
2547 } else if (dir == BACK) {
2548 stop = text; // assume range is text - p
2549 if (range == LIMITED)
2550 stop = prev_line(p); // range is to prev line
2551 for (start = p - len; start >= stop; start--) {
2552 if (mycmp(start, pat, len) == 0) {
2557 // pattern not found
2559 #else /*REGEX_SEARCH */
2561 struct re_pattern_buffer preg;
2565 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
2571 // assume a LIMITED forward search
2579 // count the number of chars to search over, forward or backward
2583 // RANGE could be negative if we are searching backwards
2586 q = (char *) re_compile_pattern(pat, strlen((char *) pat), &preg);
2588 // The pattern was not compiled
2589 psbs("bad search pattern: \"%s\": %s", pat, q);
2590 i = 0; // return p if pattern not compiled
2600 // search for the compiled pattern, preg, in p[]
2601 // range < 0- search backward
2602 // range > 0- search forward
2604 // re_search() < 0 not found or error
2605 // re_search() > 0 index of found pattern
2606 // struct pattern char int int int struct reg
2607 // re_search (*pattern_buffer, *string, size, start, range, *regs)
2608 i = re_search(&preg, q, size, 0, range, 0);
2611 i = 0; // return NULL if pattern not found
2614 if (dir == FORWARD) {
2620 #endif /*REGEX_SEARCH */
2622 #endif /* BB_FEATURE_VI_SEARCH */
2624 static Byte *char_insert(Byte * p, Byte c) // insert the char c at 'p'
2626 if (c == 22) { // Is this an ctrl-V?
2627 p = stupid_insert(p, '^'); // use ^ to indicate literal next
2628 p--; // backup onto ^
2629 refresh(FALSE); // show the ^
2633 file_modified = TRUE; // has the file been modified
2634 } else if (c == 27) { // Is this an ESC?
2637 end_cmd_q(); // stop adding to q
2638 strcpy((char *) status_buffer, " "); // clear the status buffer
2639 if (p[-1] != '\n') {
2642 } else if (c == erase_char) { // Is this a BS
2644 if (p[-1] != '\n') {
2646 p = text_hole_delete(p, p); // shrink buffer 1 char
2647 #ifdef BB_FEATURE_VI_DOT_CMD
2648 // also rmove char from last_modifying_cmd
2649 if (strlen((char *) last_modifying_cmd) > 0) {
2652 q = last_modifying_cmd;
2653 q[strlen((char *) q) - 1] = '\0'; // erase BS
2654 q[strlen((char *) q) - 1] = '\0'; // erase prev char
2656 #endif /* BB_FEATURE_VI_DOT_CMD */
2659 // insert a char into text[]
2660 Byte *sp; // "save p"
2663 c = '\n'; // translate \r to \n
2664 sp = p; // remember addr of insert
2665 p = stupid_insert(p, c); // insert the char
2666 #ifdef BB_FEATURE_VI_SETOPTS
2667 if (showmatch && strchr(")]}", *sp) != NULL) {
2670 if (autoindent && c == '\n') { // auto indent the new line
2673 q = prev_line(p); // use prev line as templet
2674 for (; isblnk(*q); q++) {
2675 p = stupid_insert(p, *q); // insert the char
2678 #endif /* BB_FEATURE_VI_SETOPTS */
2683 static Byte *stupid_insert(Byte * p, Byte c) // stupidly insert the char c at 'p'
2685 p = text_hole_make(p, 1);
2688 file_modified = TRUE; // has the file been modified
2694 static Byte find_range(Byte ** start, Byte ** stop, Byte c)
2696 Byte *save_dot, *p, *q;
2702 if (strchr("cdy><", c)) {
2703 // these cmds operate on whole lines
2704 p = q = begin_line(p);
2705 for (cnt = 1; cnt < cmdcnt; cnt++) {
2709 } else if (strchr("^%$0bBeEft", c)) {
2710 // These cmds operate on char positions
2711 do_cmd(c); // execute movement cmd
2713 } else if (strchr("wW", c)) {
2714 do_cmd(c); // execute movement cmd
2716 dot--; // move back off of next word
2717 if (dot > text && *dot == '\n')
2718 dot--; // stay off NL
2720 } else if (strchr("H-k{", c)) {
2721 // these operate on multi-lines backwards
2722 q = end_line(dot); // find NL
2723 do_cmd(c); // execute movement cmd
2726 } else if (strchr("L+j}\r\n", c)) {
2727 // these operate on multi-lines forwards
2728 p = begin_line(dot);
2729 do_cmd(c); // execute movement cmd
2730 dot_end(); // find NL
2733 c = 27; // error- return an ESC char
2746 static int st_test(Byte * p, int type, int dir, Byte * tested)
2756 if (type == S_BEFORE_WS) {
2758 test = ((!isspace(c)) || c == '\n');
2760 if (type == S_TO_WS) {
2762 test = ((!isspace(c)) || c == '\n');
2764 if (type == S_OVER_WS) {
2766 test = ((isspace(c)));
2768 if (type == S_END_PUNCT) {
2770 test = ((ispunct(c)));
2772 if (type == S_END_ALNUM) {
2774 test = ((isalnum(c)) || c == '_');
2780 static Byte *skip_thing(Byte * p, int linecnt, int dir, int type)
2784 while (st_test(p, type, dir, &c)) {
2785 // make sure we limit search to correct number of lines
2786 if (c == '\n' && --linecnt < 1)
2788 if (dir >= 0 && p >= end - 1)
2790 if (dir < 0 && p <= text)
2792 p += dir; // move to next char
2797 // find matching char of pair () [] {}
2798 static Byte *find_pair(Byte * p, Byte c)
2805 dir = 1; // assume forward
2829 for (q = p + dir; text <= q && q < end; q += dir) {
2830 // look for match, count levels of pairs (( ))
2832 level++; // increase pair levels
2834 level--; // reduce pair level
2836 break; // found matching pair
2839 q = NULL; // indicate no match
2843 #ifdef BB_FEATURE_VI_SETOPTS
2844 // show the matching char of a pair, () [] {}
2845 static void showmatching(Byte * p)
2849 // we found half of a pair
2850 q = find_pair(p, *p); // get loc of matching char
2852 indicate_error('3'); // no matching char
2854 // "q" now points to matching pair
2855 save_dot = dot; // remember where we are
2856 dot = q; // go to new loc
2857 refresh(FALSE); // let the user see it
2858 (void) mysleep(40); // give user some time
2859 dot = save_dot; // go back to old loc
2863 #endif /* BB_FEATURE_VI_SETOPTS */
2865 // open a hole in text[]
2866 static Byte *text_hole_make(Byte * p, int size) // at "p", make a 'size' byte hole
2875 cnt = end - src; // the rest of buffer
2876 if (memmove(dest, src, cnt) != dest) {
2877 psbs("can't create room for new characters");
2879 memset(p, ' ', size); // clear new hole
2880 end = end + size; // adjust the new END
2881 file_modified = TRUE; // has the file been modified
2886 // close a hole in text[]
2887 static Byte *text_hole_delete(Byte * p, Byte * q) // delete "p" thru "q", inclusive
2892 // move forwards, from beginning
2896 if (q < p) { // they are backward- swap them
2900 hole_size = q - p + 1;
2902 if (src < text || src > end)
2904 if (dest < text || dest >= end)
2907 goto thd_atend; // just delete the end of the buffer
2908 if (memmove(dest, src, cnt) != dest) {
2909 psbs("can't delete the character");
2912 end = end - hole_size; // adjust the new END
2914 dest = end - 1; // make sure dest in below end-1
2916 dest = end = text; // keep pointers valid
2917 file_modified = TRUE; // has the file been modified
2922 // copy text into register, then delete text.
2923 // if dist <= 0, do not include, or go past, a NewLine
2925 static Byte *yank_delete(Byte * start, Byte * stop, int dist, int yf)
2929 // make sure start <= stop
2931 // they are backwards, reverse them
2937 // we can not cross NL boundaries
2941 // dont go past a NewLine
2942 for (; p + 1 <= stop; p++) {
2944 stop = p; // "stop" just before NewLine
2950 #ifdef BB_FEATURE_VI_YANKMARK
2951 text_yank(start, stop, YDreg);
2952 #endif /* BB_FEATURE_VI_YANKMARK */
2953 if (yf == YANKDEL) {
2954 p = text_hole_delete(start, stop);
2959 static void show_help(void)
2961 printf("These features are available:\n");
2962 #ifdef BB_FEATURE_VI_SEARCH
2963 printf("\tPattern searches with / and ?\n");
2964 #endif /* BB_FEATURE_VI_SEARCH */
2965 #ifdef BB_FEATURE_VI_DOT_CMD
2966 printf("\tLast command repeat with \'.\'\n");
2967 #endif /* BB_FEATURE_VI_DOT_CMD */
2968 #ifdef BB_FEATURE_VI_YANKMARK
2969 printf("\tLine marking with 'x\n");
2970 printf("\tNamed buffers with \"x\n");
2971 #endif /* BB_FEATURE_VI_YANKMARK */
2972 #ifdef BB_FEATURE_VI_READONLY
2973 printf("\tReadonly if vi is called as \"view\"\n");
2974 printf("\tReadonly with -R command line arg\n");
2975 #endif /* BB_FEATURE_VI_READONLY */
2976 #ifdef BB_FEATURE_VI_SET
2977 printf("\tSome colon mode commands with \':\'\n");
2978 #endif /* BB_FEATURE_VI_SET */
2979 #ifdef BB_FEATURE_VI_SETOPTS
2980 printf("\tSettable options with \":set\"\n");
2981 #endif /* BB_FEATURE_VI_SETOPTS */
2982 #ifdef BB_FEATURE_VI_USE_SIGNALS
2983 printf("\tSignal catching- ^C\n");
2984 printf("\tJob suspend and resume with ^Z\n");
2985 #endif /* BB_FEATURE_VI_USE_SIGNALS */
2986 #ifdef BB_FEATURE_VI_WIN_RESIZE
2987 printf("\tAdapt to window re-sizes\n");
2988 #endif /* BB_FEATURE_VI_WIN_RESIZE */
2991 static void print_literal(Byte * buf, Byte * s) // copy s to buf, convert unprintable
2996 strcpy((char *) buf, ""); // init buf
2997 if (strlen((char *) s) <= 0)
2998 s = (Byte *) "(NULL)";
2999 for (; *s > '\0'; s++) {
3002 strcat((char *) buf, SOs);
3006 strcat((char *) buf, "^");
3010 strcat((char *) buf, (char *) b);
3012 strcat((char *) buf, SOn);
3014 strcat((char *) buf, "$");
3019 #ifdef BB_FEATURE_VI_DOT_CMD
3020 static void start_new_cmd_q(Byte c)
3023 if (last_modifying_cmd != 0)
3024 free(last_modifying_cmd);
3025 // get buffer for new cmd
3026 last_modifying_cmd = (Byte *) malloc(BUFSIZ);
3027 memset(last_modifying_cmd, '\0', BUFSIZ); // clear new cmd queue
3028 // if there is a current cmd count put it in the buffer first
3030 sprintf((char *) last_modifying_cmd, "%d", cmdcnt);
3031 // save char c onto queue
3032 last_modifying_cmd[strlen((char *) last_modifying_cmd)] = c;
3037 static void end_cmd_q()
3039 #ifdef BB_FEATURE_VI_YANKMARK
3040 YDreg = 26; // go back to default Yank/Delete reg
3041 #endif /* BB_FEATURE_VI_YANKMARK */
3045 #endif /* BB_FEATURE_VI_DOT_CMD */
3047 #if defined(BB_FEATURE_VI_YANKMARK) || defined(BB_FEATURE_VI_COLON) || defined(BB_FEATURE_VI_CRASHME)
3048 static Byte *string_insert(Byte * p, Byte * s) // insert the string at 'p'
3052 i = strlen((char *) s);
3053 p = text_hole_make(p, i);
3054 strncpy((char *) p, (char *) s, i);
3055 for (cnt = 0; *s != '\0'; s++) {
3059 #ifdef BB_FEATURE_VI_YANKMARK
3060 psb("Put %d lines (%d chars) from [%c]", cnt, i, what_reg());
3061 #endif /* BB_FEATURE_VI_YANKMARK */
3064 #endif /* BB_FEATURE_VI_YANKMARK || BB_FEATURE_VI_COLON || BB_FEATURE_VI_CRASHME */
3066 #ifdef BB_FEATURE_VI_YANKMARK
3067 static Byte *text_yank(Byte * p, Byte * q, int dest) // copy text into a register
3072 if (q < p) { // they are backwards- reverse them
3079 if (t != 0) { // if already a yank register
3082 t = (Byte *) malloc(cnt + 1); // get a new register
3083 memset(t, '\0', cnt + 1); // clear new text[]
3084 strncpy((char *) t, (char *) p, cnt); // copy text[] into bufer
3089 static Byte what_reg(void)
3095 c = 'D'; // default to D-reg
3096 if (0 <= YDreg && YDreg <= 25)
3097 c = 'a' + (Byte) YDreg;
3105 static void check_context(Byte cmd)
3107 // A context is defined to be "modifying text"
3108 // Any modifying command establishes a new context.
3110 if (dot < context_start || dot > context_end) {
3111 if (strchr((char *) modifying_cmds, cmd) != NULL) {
3112 // we are trying to modify text[]- make this the current context
3113 mark[27] = mark[26]; // move cur to prev
3114 mark[26] = dot; // move local to cur
3115 context_start = prev_line(prev_line(dot));
3116 context_end = next_line(next_line(dot));
3117 //loiter= start_loiter= now;
3123 static Byte *swap_context(Byte * p) // goto new context for '' command make this the current context
3127 // the current context is in mark[26]
3128 // the previous context is in mark[27]
3129 // only swap context if other context is valid
3130 if (text <= mark[27] && mark[27] <= end - 1) {
3132 mark[27] = mark[26];
3134 p = mark[26]; // where we are going- previous context
3135 context_start = prev_line(prev_line(prev_line(p)));
3136 context_end = next_line(next_line(next_line(p)));
3140 #endif /* BB_FEATURE_VI_YANKMARK */
3142 static int isblnk(Byte c) // is the char a blank or tab
3144 return (c == ' ' || c == '\t');
3147 //----- Set terminal attributes --------------------------------
3148 static void rawmode(void)
3150 tcgetattr(0, &term_orig);
3151 term_vi = term_orig;
3152 term_vi.c_lflag &= (~ICANON & ~ECHO); // leave ISIG ON- allow intr's
3153 term_vi.c_iflag &= (~IXON & ~ICRNL);
3154 term_vi.c_oflag &= (~ONLCR);
3155 term_vi.c_cc[VMIN] = 1;
3156 term_vi.c_cc[VTIME] = 0;
3157 erase_char = term_vi.c_cc[VERASE];
3158 tcsetattr(0, TCSANOW, &term_vi);
3161 static void cookmode(void)
3163 tcsetattr(0, TCSANOW, &term_orig);
3166 #ifdef BB_FEATURE_VI_WIN_RESIZE
3167 //----- See what the window size currently is --------------------
3168 static void window_size_get(int sig)
3172 i = ioctl(0, TIOCGWINSZ, &winsize);
3175 winsize.ws_row = 24;
3176 winsize.ws_col = 80;
3178 if (winsize.ws_row <= 1) {
3179 winsize.ws_row = 24;
3181 if (winsize.ws_col <= 1) {
3182 winsize.ws_col = 80;
3184 rows = (int) winsize.ws_row;
3185 columns = (int) winsize.ws_col;
3187 #endif /* BB_FEATURE_VI_WIN_RESIZE */
3189 //----- Come here when we get a window resize signal ---------
3190 #ifdef BB_FEATURE_VI_USE_SIGNALS
3191 static void winch_sig(int sig)
3193 signal(SIGWINCH, winch_sig);
3194 #ifdef BB_FEATURE_VI_WIN_RESIZE
3196 #endif /* BB_FEATURE_VI_WIN_RESIZE */
3197 new_screen(rows, columns); // get memory for virtual screen
3198 redraw(TRUE); // re-draw the screen
3201 //----- Come here when we get a continue signal -------------------
3202 static void cont_sig(int sig)
3204 rawmode(); // terminal to "raw"
3205 *status_buffer = '\0'; // clear the status buffer
3206 redraw(TRUE); // re-draw the screen
3208 signal(SIGTSTP, suspend_sig);
3209 signal(SIGCONT, SIG_DFL);
3210 kill(getpid(), SIGCONT);
3213 //----- Come here when we get a Suspend signal -------------------
3214 static void suspend_sig(int sig)
3216 place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
3217 clear_to_eol(); // Erase to end of line
3218 cookmode(); // terminal to "cooked"
3220 signal(SIGCONT, cont_sig);
3221 signal(SIGTSTP, SIG_DFL);
3222 kill(getpid(), SIGTSTP);
3225 //----- Come here when we get a signal ---------------------------
3226 static void catch_sig(int sig)
3228 signal(SIGHUP, catch_sig);
3229 signal(SIGINT, catch_sig);
3230 signal(SIGTERM, catch_sig);
3231 longjmp(restart, sig);
3234 static void alarm_sig(int sig)
3236 signal(SIGALRM, catch_sig);
3237 longjmp(restart, sig);
3240 //----- Come here when we get a core dump signal -----------------
3241 static void core_sig(int sig)
3243 signal(SIGQUIT, core_sig);
3244 signal(SIGILL, core_sig);
3245 signal(SIGTRAP, core_sig);
3246 signal(SIGIOT, core_sig);
3247 signal(SIGABRT, core_sig);
3248 signal(SIGFPE, core_sig);
3249 signal(SIGBUS, core_sig);
3250 signal(SIGSEGV, core_sig);
3252 signal(SIGSYS, core_sig);
3255 dot = bound_dot(dot); // make sure "dot" is valid
3257 longjmp(restart, sig);
3259 #endif /* BB_FEATURE_VI_USE_SIGNALS */
3261 static int mysleep(int hund) // sleep for 'h' 1/100 seconds
3263 // Don't hang- Wait 5/100 seconds- 1 Sec= 1000000
3267 tv.tv_usec = hund * 10000;
3268 select(1, &rfds, NULL, NULL, &tv);
3269 return (FD_ISSET(0, &rfds));
3272 //----- IO Routines --------------------------------------------
3273 static Byte readit(void) // read (maybe cursor) key from stdin
3276 int i, bufsiz, cnt, cmdindex;
3282 static struct esc_cmds esccmds[] = {
3283 {(Byte *) "
\eOA", (Byte) VI_K_UP}, // cursor key Up
3284 {(Byte *) "
\eOB", (Byte) VI_K_DOWN}, // cursor key Down
3285 {(Byte *) "
\eOC", (Byte) VI_K_RIGHT}, // Cursor Key Right
3286 {(Byte *) "
\eOD", (Byte) VI_K_LEFT}, // cursor key Left
3287 {(Byte *) "
\eOH", (Byte) VI_K_HOME}, // Cursor Key Home
3288 {(Byte *) "
\eOF", (Byte) VI_K_END}, // Cursor Key End
3289 {(Byte *) "
\e[A", (Byte) VI_K_UP}, // cursor key Up
3290 {(Byte *) "
\e[B", (Byte) VI_K_DOWN}, // cursor key Down
3291 {(Byte *) "
\e[C", (Byte) VI_K_RIGHT}, // Cursor Key Right
3292 {(Byte *) "
\e[D", (Byte) VI_K_LEFT}, // cursor key Left
3293 {(Byte *) "
\e[H", (Byte) VI_K_HOME}, // Cursor Key Home
3294 {(Byte *) "
\e[F", (Byte) VI_K_END}, // Cursor Key End
3295 {(Byte *) "
\e[2~", (Byte) VI_K_INSERT}, // Cursor Key Insert
3296 {(Byte *) "
\e[5~", (Byte) VI_K_PAGEUP}, // Cursor Key Page Up
3297 {(Byte *) "
\e[6~", (Byte) VI_K_PAGEDOWN}, // Cursor Key Page Down
3298 {(Byte *) "
\eOP", (Byte) VI_K_FUN1}, // Function Key F1
3299 {(Byte *) "
\eOQ", (Byte) VI_K_FUN2}, // Function Key F2
3300 {(Byte *) "
\eOR", (Byte) VI_K_FUN3}, // Function Key F3
3301 {(Byte *) "
\eOS", (Byte) VI_K_FUN4}, // Function Key F4
3302 {(Byte *) "
\e[15~", (Byte) VI_K_FUN5}, // Function Key F5
3303 {(Byte *) "
\e[17~", (Byte) VI_K_FUN6}, // Function Key F6
3304 {(Byte *) "
\e[18~", (Byte) VI_K_FUN7}, // Function Key F7
3305 {(Byte *) "
\e[19~", (Byte) VI_K_FUN8}, // Function Key F8
3306 {(Byte *) "
\e[20~", (Byte) VI_K_FUN9}, // Function Key F9
3307 {(Byte *) "
\e[21~", (Byte) VI_K_FUN10}, // Function Key F10
3308 {(Byte *) "
\e[23~", (Byte) VI_K_FUN11}, // Function Key F11
3309 {(Byte *) "
\e[24~", (Byte) VI_K_FUN12}, // Function Key F12
3310 {(Byte *) "
\e[11~", (Byte) VI_K_FUN1}, // Function Key F1
3311 {(Byte *) "
\e[12~", (Byte) VI_K_FUN2}, // Function Key F2
3312 {(Byte *) "
\e[13~", (Byte) VI_K_FUN3}, // Function Key F3
3313 {(Byte *) "
\e[14~", (Byte) VI_K_FUN4}, // Function Key F4
3316 #define ESCCMDS_COUNT (sizeof(esccmds)/sizeof(struct esc_cmds))
3318 (void) alarm(0); // turn alarm OFF while we wait for input
3319 // get input from User- are there already input chars in Q?
3320 bufsiz = strlen((char *) readbuffer);
3323 // the Q is empty, wait for a typed char
3324 bufsiz = read(0, readbuffer, BUFSIZ - 1);
3327 goto ri0; // interrupted sys call
3330 if (errno == EFAULT)
3332 if (errno == EINVAL)
3339 readbuffer[bufsiz] = '\0';
3341 // return char if it is not part of ESC sequence
3342 if (readbuffer[0] != 27)
3345 // This is an ESC char. Is this Esc sequence?
3346 // Could be bare Esc key. See if there are any
3347 // more chars to read after the ESC. This would
3348 // be a Function or Cursor Key sequence.
3352 tv.tv_usec = 50000; // Wait 5/100 seconds- 1 Sec=1000000
3354 // keep reading while there are input chars and room in buffer
3355 while (select(1, &rfds, NULL, NULL, &tv) > 0 && bufsiz <= (BUFSIZ - 5)) {
3356 // read the rest of the ESC string
3357 i = read(0, (void *) (readbuffer + bufsiz), BUFSIZ - bufsiz);
3360 readbuffer[bufsiz] = '\0'; // Terminate the string
3363 // Maybe cursor or function key?
3364 for (cmdindex = 0; cmdindex < ESCCMDS_COUNT; cmdindex++) {
3365 cnt = strlen((char *) esccmds[cmdindex].seq);
3366 i = strncmp((char *) esccmds[cmdindex].seq, (char *) readbuffer, cnt);
3368 // is a Cursor key- put derived value back into Q
3369 readbuffer[0] = esccmds[cmdindex].val;
3370 // squeeze out the ESC sequence
3371 for (i = 1; i < cnt; i++) {
3372 memmove(readbuffer + 1, readbuffer + 2, BUFSIZ - 2);
3373 readbuffer[BUFSIZ - 1] = '\0';
3380 // remove one char from Q
3381 memmove(readbuffer, readbuffer + 1, BUFSIZ - 1);
3382 readbuffer[BUFSIZ - 1] = '\0';
3383 (void) alarm(3); // we are done waiting for input, turn alarm ON
3387 //----- IO Routines --------------------------------------------
3388 static Byte get_one_char()
3392 #ifdef BB_FEATURE_VI_DOT_CMD
3393 // ! adding2q && ioq == 0 read()
3394 // ! adding2q && ioq != 0 *ioq
3395 // adding2q *last_modifying_cmd= read()
3397 // we are not adding to the q.
3398 // but, we may be reading from a q
3400 // there is no current q, read from STDIN
3401 c = readit(); // get the users input
3403 // there is a queue to get chars from first
3406 // the end of the q, read from STDIN
3408 ioq_start = ioq = 0;
3409 c = readit(); // get the users input
3413 // adding STDIN chars to q
3414 c = readit(); // get the users input
3415 if (last_modifying_cmd != 0) {
3416 // add new char to q
3417 last_modifying_cmd[strlen((char *) last_modifying_cmd)] = c;
3420 #else /* BB_FEATURE_VI_DOT_CMD */
3421 c = readit(); // get the users input
3422 #endif /* BB_FEATURE_VI_DOT_CMD */
3423 return (c); // return the char, where ever it came from
3426 static Byte *get_input_line(Byte * prompt) // get input line- use "status line"
3431 static Byte *obufp = NULL;
3433 strcpy((char *) buf, (char *) prompt);
3434 *status_buffer = '\0'; // clear the status buffer
3435 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
3436 clear_to_eol(); // clear the line
3437 write(1, prompt, strlen((char *) prompt)); // write out the :, /, or ? prompt
3439 for (i = strlen((char *) buf); i < BUFSIZ;) {
3440 c = get_one_char(); // read user input
3441 if (c == '\n' || c == '\r' || c == 27)
3442 break; // is this end of input
3443 if (c == erase_char) { // user wants to erase prev char
3444 i--; // backup to prev char
3445 buf[i] = '\0'; // erase the char
3446 buf[i + 1] = '\0'; // null terminate buffer
3447 write(1, "
\b \b", 3); // erase char on screen
3448 if (i <= 0) { // user backs up before b-o-l, exit
3452 buf[i] = c; // save char in buffer
3453 buf[i + 1] = '\0'; // make sure buffer is null terminated
3454 write(1, buf + i, 1); // echo the char back to user
3461 obufp = (Byte *) strdup((char *) buf);
3465 static int file_size(Byte * fn) // what is the byte size of "fn"
3470 if (fn == 0 || strlen(fn) <= 0)
3473 sr = stat((char *) fn, &st_buf); // see if file exists
3475 cnt = (int) st_buf.st_size;
3480 static int file_insert(Byte * fn, Byte * p, int size)
3485 #ifdef BB_FEATURE_VI_READONLY
3487 #endif /* BB_FEATURE_VI_READONLY */
3488 if (fn == 0 || strlen((char*) fn) <= 0) {
3489 psbs("No filename given");
3493 // OK- this is just a no-op
3498 psbs("Trying to insert a negative number (%d) of characters", size);
3501 if (p < text || p > end) {
3502 psbs("Trying to insert file outside of memory");
3506 // see if we can open the file
3507 #ifdef BB_FEATURE_VI_READONLY
3508 if (vi_readonly == TRUE) goto fi1; // do not try write-mode
3510 fd = open((char *) fn, O_RDWR); // assume read & write
3512 // could not open for writing- maybe file is read only
3513 #ifdef BB_FEATURE_VI_READONLY
3516 fd = open((char *) fn, O_RDONLY); // try read-only
3518 psbs("\"%s\" %s", fn, "could not open file");
3521 #ifdef BB_FEATURE_VI_READONLY
3522 // got the file- read-only
3524 #endif /* BB_FEATURE_VI_READONLY */
3526 p = text_hole_make(p, size);
3527 cnt = read(fd, p, size);
3531 p = text_hole_delete(p, p + size - 1); // un-do buffer insert
3532 psbs("could not read file \"%s\"", fn);
3533 } else if (cnt < size) {
3534 // There was a partial read, shrink unused space text[]
3535 p = text_hole_delete(p + cnt, p + (size - cnt) - 1); // un-do buffer insert
3536 psbs("could not read all of file \"%s\"", fn);
3539 file_modified = TRUE;
3544 static int file_write(Byte * fn, Byte * first, Byte * last)
3546 int fd, cnt, charcnt;
3549 psbs("No current filename");
3553 // FIXIT- use the correct umask()
3554 fd = open((char *) fn, (O_RDWR | O_CREAT | O_TRUNC), 0664);
3557 cnt = last - first + 1;
3558 charcnt = write(fd, first, cnt);
3559 if (charcnt == cnt) {
3561 //file_modified= FALSE; // the file has not been modified
3569 //----- Terminal Drawing ---------------------------------------
3570 // The terminal is made up of 'rows' line of 'columns' columns.
3571 // classicly this would be 24 x 80.
3572 // screen coordinates
3578 // 23,0 ... 23,79 status line
3581 //----- Move the cursor to row x col (count from 0, not 1) -------
3582 static void place_cursor(int row, int col, int opti)
3587 #ifdef BB_FEATURE_VI_OPTIMIZE_CURSOR
3590 // char cm3[BUFSIZ];
3592 #endif /* BB_FEATURE_VI_OPTIMIZE_CURSOR */
3594 memset(cm1, '\0', BUFSIZ - 1); // clear the buffer
3596 if (row < 0) row = 0;
3597 if (row >= rows) row = rows - 1;
3598 if (col < 0) col = 0;
3599 if (col >= columns) col = columns - 1;
3601 //----- 1. Try the standard terminal ESC sequence
3602 sprintf((char *) cm1, CMrc, row + 1, col + 1);
3604 if (opti == FALSE) goto pc0;
3606 #ifdef BB_FEATURE_VI_OPTIMIZE_CURSOR
3607 //----- find the minimum # of chars to move cursor -------------
3608 //----- 2. Try moving with discreet chars (Newline, [back]space, ...)
3609 memset(cm2, '\0', BUFSIZ - 1); // clear the buffer
3611 // move to the correct row
3612 while (row < Rrow) {
3613 // the cursor has to move up
3617 while (row > Rrow) {
3618 // the cursor has to move down
3619 strcat(cm2, CMdown);
3623 // now move to the correct column
3624 strcat(cm2, "\r"); // start at col 0
3625 // just send out orignal source char to get to correct place
3626 screenp = &screen[row * columns]; // start of screen line
3627 strncat(cm2, screenp, col);
3629 //----- 3. Try some other way of moving cursor
3630 //---------------------------------------------
3632 // pick the shortest cursor motion to send out
3634 if (strlen(cm2) < strlen(cm)) {
3636 } /* else if (strlen(cm3) < strlen(cm)) {
3639 #endif /* BB_FEATURE_VI_OPTIMIZE_CURSOR */
3642 if (l) write(1, cm, l); // move the cursor
3645 //----- Erase from cursor to end of line -----------------------
3646 static void clear_to_eol()
3648 write(1, Ceol, strlen(Ceol)); // Erase from cursor to end of line
3651 //----- Erase from cursor to end of screen -----------------------
3652 static void clear_to_eos()
3654 write(1, Ceos, strlen(Ceos)); // Erase from cursor to end of screen
3657 //----- Start standout mode ------------------------------------
3658 static void standout_start() // send "start reverse video" sequence
3660 write(1, SOs, strlen(SOs)); // Start reverse video mode
3663 //----- End standout mode --------------------------------------
3664 static void standout_end() // send "end reverse video" sequence
3666 write(1, SOn, strlen(SOn)); // End reverse video mode
3669 //----- Flash the screen --------------------------------------
3670 static void flash(int h)
3672 standout_start(); // send "start reverse video" sequence
3675 standout_end(); // send "end reverse video" sequence
3681 write(1, bell, strlen(bell)); // send out a bell character
3684 static void indicate_error(char c)
3686 #ifdef BB_FEATURE_VI_CRASHME
3688 return; // generate a random command
3689 #endif /* BB_FEATURE_VI_CRASHME */
3690 if (err_method == 0) {
3697 //----- Screen[] Routines --------------------------------------
3698 //----- Erase the Screen[] memory ------------------------------
3699 static void screen_erase()
3701 memset(screen, ' ', screensize); // clear new screen
3704 //----- Draw the status line at bottom of the screen -------------
3705 static void show_status_line(void)
3707 static int last_cksum;
3710 cnt = strlen((char *) status_buffer);
3711 for (cksum= l= 0; l < cnt; l++) { cksum += (int)(status_buffer[l]); }
3712 // don't write the status line unless it changes
3713 if (cnt > 0 && last_cksum != cksum) {
3714 last_cksum= cksum; // remember if we have seen this line
3715 place_cursor(rows - 1, 0, FALSE); // put cursor on status line
3716 write(1, status_buffer, cnt);
3718 place_cursor(crow, ccol, FALSE); // put cursor back in correct place
3722 //----- format the status buffer, the bottom line of screen ------
3723 // print status buffer, with STANDOUT mode
3724 static void psbs(char *format, ...)
3728 va_start(args, format);
3729 strcpy((char *) status_buffer, SOs); // Terminal standout mode on
3730 vsprintf((char *) status_buffer + strlen((char *) status_buffer), format,
3732 strcat((char *) status_buffer, SOn); // Terminal standout mode off
3738 // print status buffer
3739 static void psb(char *format, ...)
3743 va_start(args, format);
3744 vsprintf((char *) status_buffer, format, args);
3749 static void ni(Byte * s) // display messages
3753 print_literal(buf, s);
3754 psbs("\'%s\' is not implemented", buf);
3757 static void edit_status(void) // show file status on status line
3759 int cur, tot, percent;
3761 cur = count_lines(text, dot);
3762 tot = count_lines(text, end - 1);
3763 // current line percent
3764 // ------------- ~~ ----------
3767 percent = (100 * cur) / tot;
3773 #ifdef BB_FEATURE_VI_READONLY
3775 #endif /* BB_FEATURE_VI_READONLY */
3776 "%s line %d of %d --%d%%--",
3777 (cfn != 0 ? (char *) cfn : "No file"),
3778 #ifdef BB_FEATURE_VI_READONLY
3779 ((vi_readonly == TRUE || readonly == TRUE) ? " [Read only]" : ""),
3780 #endif /* BB_FEATURE_VI_READONLY */
3781 (file_modified == TRUE ? " [modified]" : ""),
3785 //----- Force refresh of all Lines -----------------------------
3786 static void redraw(int full_screen)
3788 place_cursor(0, 0, FALSE); // put cursor in correct place
3789 clear_to_eos(); // tel terminal to erase display
3790 screen_erase(); // erase the internal screen buffer
3791 refresh(full_screen); // this will redraw the entire display
3794 //----- Format a text[] line into a buffer ---------------------
3795 static void format_line(Byte *dest, Byte *src, int li)
3800 for (co= 0; co < MAX_SCR_COLS; co++) {
3801 c= ' '; // assume blank
3802 if (li > 0 && co == 0) {
3803 c = '~'; // not first line, assume Tilde
3805 // are there chars in text[] and have we gone past the end
3806 if (text < end && src < end) {
3811 if (c < ' ' || c > '~') {
3815 for (; (co % tabstop) != (tabstop - 1); co++) {
3820 c |= '@'; // make it visible
3821 c &= 0x7f; // get rid of hi bit
3824 // the co++ is done here so that the column will
3825 // not be overwritten when we blank-out the rest of line
3832 //----- Refresh the changed screen lines -----------------------
3833 // Copy the source line from text[] into the buffer and note
3834 // if the current screenline is different from the new buffer.
3835 // If they differ then that line needs redrawing on the terminal.
3837 static void refresh(int full_screen)
3839 static int old_offset;
3841 Byte buf[MAX_SCR_COLS];
3842 Byte *tp, *sp; // pointer into text[] and screen[]
3843 #ifdef BB_FEATURE_VI_OPTIMIZE_CURSOR
3844 int last_li= -2; // last line that changed- for optimizing cursor movement
3845 #endif /* BB_FEATURE_VI_OPTIMIZE_CURSOR */
3847 #ifdef BB_FEATURE_VI_WIN_RESIZE
3849 #endif /* BB_FEATURE_VI_WIN_RESIZE */
3850 sync_cursor(dot, &crow, &ccol); // where cursor will be (on "dot")
3851 tp = screenbegin; // index into text[] of top line
3853 // compare text[] to screen[] and mark screen[] lines that need updating
3854 for (li = 0; li < rows - 1; li++) {
3855 int cs, ce; // column start & end
3856 memset(buf, ' ', MAX_SCR_COLS); // blank-out the buffer
3857 buf[MAX_SCR_COLS-1] = 0; // NULL terminate the buffer
3858 // format current text line into buf
3859 format_line(buf, tp, li);
3861 // skip to the end of the current text[] line
3862 while (tp < end && *tp++ != '\n') /*no-op*/ ;
3864 // see if there are any changes between vitual screen and buf
3865 changed = FALSE; // assume no change
3868 sp = &screen[li * columns]; // start of screen line
3869 if (full_screen == TRUE) {
3870 // force re-draw of every single column from 0 - columns-1
3873 // compare newly formatted buffer with virtual screen
3874 // look forward for first difference between buf and screen
3875 for ( ; cs <= ce; cs++) {
3876 if (buf[cs + offset] != sp[cs]) {
3877 changed = TRUE; // mark for redraw
3882 // look backward for last difference between buf and screen
3883 for ( ; ce >= cs; ce--) {
3884 if (buf[ce + offset] != sp[ce]) {
3885 changed = TRUE; // mark for redraw
3889 // now, cs is index of first diff, and ce is index of last diff
3891 // if horz offset has changed, force a redraw
3892 if (offset != old_offset) {
3897 // make a sanity check of columns indexes
3899 if (ce > columns-1) ce= columns-1;
3900 if (cs > ce) { cs= 0; ce= columns-1; }
3901 // is there a change between vitual screen and buf
3902 if (changed == TRUE) {
3903 // copy changed part of buffer to virtual screen
3904 memmove(sp+cs, buf+(cs+offset), ce-cs+1);
3906 // move cursor to column of first change
3907 if (offset != old_offset) {
3908 // opti_cur_move is still too stupid
3909 // to handle offsets correctly
3910 place_cursor(li, cs, FALSE);
3912 #ifdef BB_FEATURE_VI_OPTIMIZE_CURSOR
3913 // if this just the next line
3914 // try to optimize cursor movement
3915 // otherwise, use standard ESC sequence
3916 place_cursor(li, cs, li == (last_li+1) ? TRUE : FALSE);
3918 #else /* BB_FEATURE_VI_OPTIMIZE_CURSOR */
3919 place_cursor(li, cs, FALSE); // use standard ESC sequence
3920 #endif /* BB_FEATURE_VI_OPTIMIZE_CURSOR */
3923 // write line out to terminal
3924 write(1, sp+cs, ce-cs+1);
3925 #ifdef BB_FEATURE_VI_OPTIMIZE_CURSOR
3927 #endif /* BB_FEATURE_VI_OPTIMIZE_CURSOR */
3931 #ifdef BB_FEATURE_VI_OPTIMIZE_CURSOR
3932 place_cursor(crow, ccol, (crow == last_row) ? TRUE : FALSE);
3935 place_cursor(crow, ccol, FALSE);
3936 #endif /* BB_FEATURE_VI_OPTIMIZE_CURSOR */
3938 if (offset != old_offset)
3939 old_offset = offset;