aboutsummaryrefslogtreecommitdiff
path: root/busybox/editors/vi.c
diff options
context:
space:
mode:
Diffstat (limited to 'busybox/editors/vi.c')
-rw-r--r--busybox/editors/vi.c3983
1 files changed, 3983 insertions, 0 deletions
diff --git a/busybox/editors/vi.c b/busybox/editors/vi.c
new file mode 100644
index 000000000..cd6cf0ea1
--- /dev/null
+++ b/busybox/editors/vi.c
@@ -0,0 +1,3983 @@
1/* vi: set sw=8 ts=8: */
2/*
3 * tiny vi.c: A small 'vi' clone
4 * Copyright (C) 2000, 2001 Sterling Huxley <sterling@europa.com>
5 *
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.
10 *
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.
15 *
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.
19 */
20
21static const char vi_Version[] =
22 "$Id: vi.c,v 1.38 2004/08/19 19:15:06 andersen Exp $";
23
24/*
25 * To compile for standalone use:
26 * gcc -Wall -Os -s -DSTANDALONE -o vi vi.c
27 * or
28 * gcc -Wall -Os -s -DSTANDALONE -DCONFIG_FEATURE_VI_CRASHME -o vi vi.c # include testing features
29 * strip vi
30 */
31
32/*
33 * Things To Do:
34 * EXINIT
35 * $HOME/.exrc and ./.exrc
36 * add magic to search /foo.*bar
37 * add :help command
38 * :map macros
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"
46 */
47
48//---- Feature -------------- Bytes to implement
49#ifdef STANDALONE
50#define vi_main main
51#define CONFIG_FEATURE_VI_COLON // 4288
52#define CONFIG_FEATURE_VI_YANKMARK // 1408
53#define CONFIG_FEATURE_VI_SEARCH // 1088
54#define CONFIG_FEATURE_VI_USE_SIGNALS // 1056
55#define CONFIG_FEATURE_VI_DOT_CMD // 576
56#define CONFIG_FEATURE_VI_READONLY // 128
57#define CONFIG_FEATURE_VI_SETOPTS // 576
58#define CONFIG_FEATURE_VI_SET // 224
59#define CONFIG_FEATURE_VI_WIN_RESIZE // 256 WIN_RESIZE
60// To test editor using CRASHME:
61// vi -C filename
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 CONFIG_FEATURE_VI_CRASHME // randomly pick commands to execute
66#endif /* STANDALONE */
67
68#include <stdio.h>
69#include <stdlib.h>
70#include <string.h>
71#include <termios.h>
72#include <unistd.h>
73#include <sys/ioctl.h>
74#include <sys/time.h>
75#include <sys/types.h>
76#include <sys/stat.h>
77#include <time.h>
78#include <fcntl.h>
79#include <signal.h>
80#include <setjmp.h>
81#include <regex.h>
82#include <ctype.h>
83#include <assert.h>
84#include <errno.h>
85#include <stdarg.h>
86#ifndef STANDALONE
87#include "busybox.h"
88#endif /* STANDALONE */
89
90#ifdef CONFIG_LOCALE_SUPPORT
91#define Isprint(c) isprint((c))
92#else
93#define Isprint(c) ( (c) >= ' ' && (c) != 127 && (c) != ((unsigned char)'\233') )
94#endif
95
96#ifndef TRUE
97#define TRUE ((int)1)
98#define FALSE ((int)0)
99#endif /* TRUE */
100#define MAX_SCR_COLS BUFSIZ
101
102// Misc. non-Ascii keys that report an escape sequence
103#define VI_K_UP 128 // cursor key Up
104#define VI_K_DOWN 129 // cursor key Down
105#define VI_K_RIGHT 130 // Cursor Key Right
106#define VI_K_LEFT 131 // cursor key Left
107#define VI_K_HOME 132 // Cursor Key Home
108#define VI_K_END 133 // Cursor Key End
109#define VI_K_INSERT 134 // Cursor Key Insert
110#define VI_K_PAGEUP 135 // Cursor Key Page Up
111#define VI_K_PAGEDOWN 136 // Cursor Key Page Down
112#define VI_K_FUN1 137 // Function Key F1
113#define VI_K_FUN2 138 // Function Key F2
114#define VI_K_FUN3 139 // Function Key F3
115#define VI_K_FUN4 140 // Function Key F4
116#define VI_K_FUN5 141 // Function Key F5
117#define VI_K_FUN6 142 // Function Key F6
118#define VI_K_FUN7 143 // Function Key F7
119#define VI_K_FUN8 144 // Function Key F8
120#define VI_K_FUN9 145 // Function Key F9
121#define VI_K_FUN10 146 // Function Key F10
122#define VI_K_FUN11 147 // Function Key F11
123#define VI_K_FUN12 148 // Function Key F12
124
125/* vt102 typical ESC sequence */
126/* terminal standout start/normal ESC sequence */
127static const char SOs[] = "\033[7m";
128static const char SOn[] = "\033[0m";
129/* terminal bell sequence */
130static const char bell[] = "\007";
131/* Clear-end-of-line and Clear-end-of-screen ESC sequence */
132static const char Ceol[] = "\033[0K";
133static const char Ceos [] = "\033[0J";
134/* Cursor motion arbitrary destination ESC sequence */
135static const char CMrc[] = "\033[%d;%dH";
136/* Cursor motion up and down ESC sequence */
137static const char CMup[] = "\033[A";
138static const char CMdown[] = "\n";
139
140
141static const int YANKONLY = FALSE;
142static const int YANKDEL = TRUE;
143static const int FORWARD = 1; // code depends on "1" for array index
144static const int BACK = -1; // code depends on "-1" for array index
145static const int LIMITED = 0; // how much of text[] in char_search
146static const int FULL = 1; // how much of text[] in char_search
147
148static const int S_BEFORE_WS = 1; // used in skip_thing() for moving "dot"
149static const int S_TO_WS = 2; // used in skip_thing() for moving "dot"
150static const int S_OVER_WS = 3; // used in skip_thing() for moving "dot"
151static const int S_END_PUNCT = 4; // used in skip_thing() for moving "dot"
152static const int S_END_ALNUM = 5; // used in skip_thing() for moving "dot"
153
154typedef unsigned char Byte;
155
156static int vi_setops;
157#define VI_AUTOINDENT 1
158#define VI_SHOWMATCH 2
159#define VI_IGNORECASE 4
160#define VI_ERR_METHOD 8
161#define autoindent (vi_setops & VI_AUTOINDENT)
162#define showmatch (vi_setops & VI_SHOWMATCH )
163#define ignorecase (vi_setops & VI_IGNORECASE)
164/* indicate error with beep or flash */
165#define err_method (vi_setops & VI_ERR_METHOD)
166
167
168static int editing; // >0 while we are editing a file
169static int cmd_mode; // 0=command 1=insert
170static int file_modified; // buffer contents changed
171static int fn_start; // index of first cmd line file name
172static int save_argc; // how many file names on cmd line
173static int cmdcnt; // repetition count
174static fd_set rfds; // use select() for small sleeps
175static struct timeval tv; // use select() for small sleeps
176static int rows, columns; // the terminal screen is this size
177static int crow, ccol, offset; // cursor is on Crow x Ccol with Horz Ofset
178static Byte *status_buffer; // mesages to the user
179static Byte *cfn; // previous, current, and next file name
180static Byte *text, *end, *textend; // pointers to the user data in memory
181static Byte *screen; // pointer to the virtual screen buffer
182static int screensize; // and its size
183static Byte *screenbegin; // index into text[], of top line on the screen
184static Byte *dot; // where all the action takes place
185static int tabstop;
186static struct termios term_orig, term_vi; // remember what the cooked mode was
187static Byte erase_char; // the users erase character
188static Byte last_input_char; // last char read from user
189static Byte last_forward_char; // last char searched for with 'f'
190
191#ifdef CONFIG_FEATURE_VI_OPTIMIZE_CURSOR
192static int last_row; // where the cursor was last moved to
193#endif /* CONFIG_FEATURE_VI_OPTIMIZE_CURSOR */
194#ifdef CONFIG_FEATURE_VI_USE_SIGNALS
195static jmp_buf restart; // catch_sig()
196#endif /* CONFIG_FEATURE_VI_USE_SIGNALS */
197#if defined(CONFIG_FEATURE_VI_USE_SIGNALS) || defined(CONFIG_FEATURE_VI_CRASHME)
198static int my_pid;
199#endif
200#ifdef CONFIG_FEATURE_VI_DOT_CMD
201static int adding2q; // are we currently adding user input to q
202static Byte *last_modifying_cmd; // last modifying cmd for "."
203static Byte *ioq, *ioq_start; // pointer to string for get_one_char to "read"
204#endif /* CONFIG_FEATURE_VI_DOT_CMD */
205#if defined(CONFIG_FEATURE_VI_DOT_CMD) || defined(CONFIG_FEATURE_VI_YANKMARK)
206static Byte *modifying_cmds; // cmds that modify text[]
207#endif /* CONFIG_FEATURE_VI_DOT_CMD || CONFIG_FEATURE_VI_YANKMARK */
208#ifdef CONFIG_FEATURE_VI_READONLY
209static int vi_readonly, readonly;
210#endif /* CONFIG_FEATURE_VI_READONLY */
211#ifdef CONFIG_FEATURE_VI_YANKMARK
212static Byte *reg[28]; // named register a-z, "D", and "U" 0-25,26,27
213static int YDreg, Ureg; // default delete register and orig line for "U"
214static Byte *mark[28]; // user marks points somewhere in text[]- a-z and previous context ''
215static Byte *context_start, *context_end;
216#endif /* CONFIG_FEATURE_VI_YANKMARK */
217#ifdef CONFIG_FEATURE_VI_SEARCH
218static Byte *last_search_pattern; // last pattern from a '/' or '?' search
219#endif /* CONFIG_FEATURE_VI_SEARCH */
220
221
222static void edit_file(Byte *); // edit one file
223static void do_cmd(Byte); // execute a command
224static void sync_cursor(Byte *, int *, int *); // synchronize the screen cursor to dot
225static Byte *begin_line(Byte *); // return pointer to cur line B-o-l
226static Byte *end_line(Byte *); // return pointer to cur line E-o-l
227static Byte *prev_line(Byte *); // return pointer to prev line B-o-l
228static Byte *next_line(Byte *); // return pointer to next line B-o-l
229static Byte *end_screen(void); // get pointer to last char on screen
230static int count_lines(Byte *, Byte *); // count line from start to stop
231static Byte *find_line(int); // find begining of line #li
232static Byte *move_to_col(Byte *, int); // move "p" to column l
233static int isblnk(Byte); // is the char a blank or tab
234static void dot_left(void); // move dot left- dont leave line
235static void dot_right(void); // move dot right- dont leave line
236static void dot_begin(void); // move dot to B-o-l
237static void dot_end(void); // move dot to E-o-l
238static void dot_next(void); // move dot to next line B-o-l
239static void dot_prev(void); // move dot to prev line B-o-l
240static void dot_scroll(int, int); // move the screen up or down
241static void dot_skip_over_ws(void); // move dot pat WS
242static void dot_delete(void); // delete the char at 'dot'
243static Byte *bound_dot(Byte *); // make sure text[0] <= P < "end"
244static Byte *new_screen(int, int); // malloc virtual screen memory
245static Byte *new_text(int); // malloc memory for text[] buffer
246static Byte *char_insert(Byte *, Byte); // insert the char c at 'p'
247static Byte *stupid_insert(Byte *, Byte); // stupidly insert the char c at 'p'
248static Byte find_range(Byte **, Byte **, Byte); // return pointers for an object
249static int st_test(Byte *, int, int, Byte *); // helper for skip_thing()
250static Byte *skip_thing(Byte *, int, int, int); // skip some object
251static Byte *find_pair(Byte *, Byte); // find matching pair () [] {}
252static Byte *text_hole_delete(Byte *, Byte *); // at "p", delete a 'size' byte hole
253static Byte *text_hole_make(Byte *, int); // at "p", make a 'size' byte hole
254static Byte *yank_delete(Byte *, Byte *, int, int); // yank text[] into register then delete
255static void show_help(void); // display some help info
256static void rawmode(void); // set "raw" mode on tty
257static void cookmode(void); // return to "cooked" mode on tty
258static int mysleep(int); // sleep for 'h' 1/100 seconds
259static Byte readit(void); // read (maybe cursor) key from stdin
260static Byte get_one_char(void); // read 1 char from stdin
261static int file_size(const Byte *); // what is the byte size of "fn"
262static int file_insert(Byte *, Byte *, int);
263static int file_write(Byte *, Byte *, Byte *);
264static void place_cursor(int, int, int);
265static void screen_erase(void);
266static void clear_to_eol(void);
267static void clear_to_eos(void);
268static void standout_start(void); // send "start reverse video" sequence
269static void standout_end(void); // send "end reverse video" sequence
270static void flash(int); // flash the terminal screen
271static void show_status_line(void); // put a message on the bottom line
272static void psb(const char *, ...); // Print Status Buf
273static void psbs(const char *, ...); // Print Status Buf in standout mode
274static void ni(Byte *); // display messages
275static void edit_status(void); // show file status on status line
276static void redraw(int); // force a full screen refresh
277static void format_line(Byte*, Byte*, int);
278static void refresh(int); // update the terminal from screen[]
279
280static void Indicate_Error(void); // use flash or beep to indicate error
281#define indicate_error(c) Indicate_Error()
282
283#ifdef CONFIG_FEATURE_VI_SEARCH
284static Byte *char_search(Byte *, Byte *, int, int); // search for pattern starting at p
285static int mycmp(Byte *, Byte *, int); // string cmp based in "ignorecase"
286#endif /* CONFIG_FEATURE_VI_SEARCH */
287#ifdef CONFIG_FEATURE_VI_COLON
288static void Hit_Return(void);
289static Byte *get_one_address(Byte *, int *); // get colon addr, if present
290static Byte *get_address(Byte *, int *, int *); // get two colon addrs, if present
291static void colon(Byte *); // execute the "colon" mode cmds
292#endif /* CONFIG_FEATURE_VI_COLON */
293#ifdef CONFIG_FEATURE_VI_USE_SIGNALS
294static void winch_sig(int); // catch window size changes
295static void suspend_sig(int); // catch ctrl-Z
296static void catch_sig(int); // catch ctrl-C and alarm time-outs
297static void core_sig(int); // catch a core dump signal
298#endif /* CONFIG_FEATURE_VI_USE_SIGNALS */
299#ifdef CONFIG_FEATURE_VI_DOT_CMD
300static void start_new_cmd_q(Byte); // new queue for command
301static void end_cmd_q(void); // stop saving input chars
302#else /* CONFIG_FEATURE_VI_DOT_CMD */
303#define end_cmd_q()
304#endif /* CONFIG_FEATURE_VI_DOT_CMD */
305#ifdef CONFIG_FEATURE_VI_WIN_RESIZE
306static void window_size_get(int); // find out what size the window is
307#endif /* CONFIG_FEATURE_VI_WIN_RESIZE */
308#ifdef CONFIG_FEATURE_VI_SETOPTS
309static void showmatching(Byte *); // show the matching pair () [] {}
310#endif /* CONFIG_FEATURE_VI_SETOPTS */
311#if defined(CONFIG_FEATURE_VI_YANKMARK) || defined(CONFIG_FEATURE_VI_COLON) || defined(CONFIG_FEATURE_VI_CRASHME)
312static Byte *string_insert(Byte *, Byte *); // insert the string at 'p'
313#endif /* CONFIG_FEATURE_VI_YANKMARK || CONFIG_FEATURE_VI_COLON || CONFIG_FEATURE_VI_CRASHME */
314#ifdef CONFIG_FEATURE_VI_YANKMARK
315static Byte *text_yank(Byte *, Byte *, int); // save copy of "p" into a register
316static Byte what_reg(void); // what is letter of current YDreg
317static void check_context(Byte); // remember context for '' command
318#endif /* CONFIG_FEATURE_VI_YANKMARK */
319#ifdef CONFIG_FEATURE_VI_CRASHME
320static void crash_dummy();
321static void crash_test();
322static int crashme = 0;
323#endif /* CONFIG_FEATURE_VI_CRASHME */
324
325
326static void write1(const char *out)
327{
328 fputs(out, stdout);
329}
330
331extern int vi_main(int argc, char **argv)
332{
333 int c;
334 RESERVE_CONFIG_BUFFER(STATUS_BUFFER, 200);
335
336#ifdef CONFIG_FEATURE_VI_YANKMARK
337 int i;
338#endif /* CONFIG_FEATURE_VI_YANKMARK */
339#if defined(CONFIG_FEATURE_VI_USE_SIGNALS) || defined(CONFIG_FEATURE_VI_CRASHME)
340 my_pid = getpid();
341#endif
342#ifdef CONFIG_FEATURE_VI_CRASHME
343 (void) srand((long) my_pid);
344#endif /* CONFIG_FEATURE_VI_CRASHME */
345
346 status_buffer = STATUS_BUFFER;
347
348#ifdef CONFIG_FEATURE_VI_READONLY
349 vi_readonly = readonly = FALSE;
350 if (strncmp(argv[0], "view", 4) == 0) {
351 readonly = TRUE;
352 vi_readonly = TRUE;
353 }
354#endif /* CONFIG_FEATURE_VI_READONLY */
355 vi_setops = VI_AUTOINDENT | VI_SHOWMATCH | VI_IGNORECASE | VI_ERR_METHOD;
356#ifdef CONFIG_FEATURE_VI_YANKMARK
357 for (i = 0; i < 28; i++) {
358 reg[i] = 0;
359 } // init the yank regs
360#endif /* CONFIG_FEATURE_VI_YANKMARK */
361#if defined(CONFIG_FEATURE_VI_DOT_CMD) || defined(CONFIG_FEATURE_VI_YANKMARK)
362 modifying_cmds = (Byte *) "aAcCdDiIJoOpPrRsxX<>~"; // cmds modifying text[]
363#endif /* CONFIG_FEATURE_VI_DOT_CMD */
364
365 // 1- process $HOME/.exrc file
366 // 2- process EXINIT variable from environment
367 // 3- process command line args
368 while ((c = getopt(argc, argv, "hCR")) != -1) {
369 switch (c) {
370#ifdef CONFIG_FEATURE_VI_CRASHME
371 case 'C':
372 crashme = 1;
373 break;
374#endif /* CONFIG_FEATURE_VI_CRASHME */
375#ifdef CONFIG_FEATURE_VI_READONLY
376 case 'R': // Read-only flag
377 readonly = TRUE;
378 vi_readonly = TRUE;
379 break;
380#endif /* CONFIG_FEATURE_VI_READONLY */
381 //case 'r': // recover flag- ignore- we don't use tmp file
382 //case 'x': // encryption flag- ignore
383 //case 'c': // execute command first
384 //case 'h': // help -- just use default
385 default:
386 show_help();
387 return 1;
388 }
389 }
390
391 // The argv array can be used by the ":next" and ":rewind" commands
392 // save optind.
393 fn_start = optind; // remember first file name for :next and :rew
394 save_argc = argc;
395
396 //----- This is the main file handling loop --------------
397 if (optind >= argc) {
398 editing = 1; // 0= exit, 1= one file, 2= multiple files
399 edit_file(0);
400 } else {
401 for (; optind < argc; optind++) {
402 editing = 1; // 0=exit, 1=one file, 2+ =many files
403 free(cfn);
404 cfn = (Byte *) bb_xstrdup(argv[optind]);
405 edit_file(cfn);
406 }
407 }
408 //-----------------------------------------------------------
409
410 return (0);
411}
412
413#ifdef CONFIG_FEATURE_VI_WIN_RESIZE
414//----- See what the window size currently is --------------------
415static inline void window_size_get(int fd)
416{
417 get_terminal_width_height(fd, &columns, &rows);
418}
419#endif /* CONFIG_FEATURE_VI_WIN_RESIZE */
420
421static void edit_file(Byte * fn)
422{
423 Byte c;
424 int cnt, size, ch;
425
426#ifdef CONFIG_FEATURE_VI_USE_SIGNALS
427 int sig;
428#endif /* CONFIG_FEATURE_VI_USE_SIGNALS */
429#ifdef CONFIG_FEATURE_VI_YANKMARK
430 static Byte *cur_line;
431#endif /* CONFIG_FEATURE_VI_YANKMARK */
432
433 rawmode();
434 rows = 24;
435 columns = 80;
436 ch= -1;
437#ifdef CONFIG_FEATURE_VI_WIN_RESIZE
438 window_size_get(0);
439#endif /* CONFIG_FEATURE_VI_WIN_RESIZE */
440 new_screen(rows, columns); // get memory for virtual screen
441
442 cnt = file_size(fn); // file size
443 size = 2 * cnt; // 200% of file size
444 new_text(size); // get a text[] buffer
445 screenbegin = dot = end = text;
446 if (fn != 0) {
447 ch= file_insert(fn, text, cnt);
448 }
449 if (ch < 1) {
450 (void) char_insert(text, '\n'); // start empty buf with dummy line
451 }
452 file_modified = FALSE;
453#ifdef CONFIG_FEATURE_VI_YANKMARK
454 YDreg = 26; // default Yank/Delete reg
455 Ureg = 27; // hold orig line for "U" cmd
456 for (cnt = 0; cnt < 28; cnt++) {
457 mark[cnt] = 0;
458 } // init the marks
459 mark[26] = mark[27] = text; // init "previous context"
460#endif /* CONFIG_FEATURE_VI_YANKMARK */
461
462 last_forward_char = last_input_char = '\0';
463 crow = 0;
464 ccol = 0;
465 edit_status();
466
467#ifdef CONFIG_FEATURE_VI_USE_SIGNALS
468 catch_sig(0);
469 core_sig(0);
470 signal(SIGWINCH, winch_sig);
471 signal(SIGTSTP, suspend_sig);
472 sig = setjmp(restart);
473 if (sig != 0) {
474 const char *msg = "";
475
476 if (sig == SIGWINCH)
477 msg = "(window resize)";
478 if (sig == SIGHUP)
479 msg = "(hangup)";
480 if (sig == SIGINT)
481 msg = "(interrupt)";
482 if (sig == SIGTERM)
483 msg = "(terminate)";
484 if (sig == SIGBUS)
485 msg = "(bus error)";
486 if (sig == SIGSEGV)
487 msg = "(I tried to touch invalid memory)";
488 if (sig == SIGALRM)
489 msg = "(alarm)";
490
491 psbs("-- caught signal %d %s--", sig, msg);
492 screenbegin = dot = text;
493 }
494#endif /* CONFIG_FEATURE_VI_USE_SIGNALS */
495
496 editing = 1;
497 cmd_mode = 0; // 0=command 1=insert 2='R'eplace
498 cmdcnt = 0;
499 tabstop = 8;
500 offset = 0; // no horizontal offset
501 c = '\0';
502#ifdef CONFIG_FEATURE_VI_DOT_CMD
503 free(last_modifying_cmd);
504 free(ioq_start);
505 ioq = ioq_start = last_modifying_cmd = 0;
506 adding2q = 0;
507#endif /* CONFIG_FEATURE_VI_DOT_CMD */
508 redraw(FALSE); // dont force every col re-draw
509 show_status_line();
510
511 //------This is the main Vi cmd handling loop -----------------------
512 while (editing > 0) {
513#ifdef CONFIG_FEATURE_VI_CRASHME
514 if (crashme > 0) {
515 if ((end - text) > 1) {
516 crash_dummy(); // generate a random command
517 } else {
518 crashme = 0;
519 dot =
520 string_insert(text, (Byte *) "\n\n##### Ran out of text to work on. #####\n\n"); // insert the string
521 refresh(FALSE);
522 }
523 }
524#endif /* CONFIG_FEATURE_VI_CRASHME */
525 last_input_char = c = get_one_char(); // get a cmd from user
526#ifdef CONFIG_FEATURE_VI_YANKMARK
527 // save a copy of the current line- for the 'U" command
528 if (begin_line(dot) != cur_line) {
529 cur_line = begin_line(dot);
530 text_yank(begin_line(dot), end_line(dot), Ureg);
531 }
532#endif /* CONFIG_FEATURE_VI_YANKMARK */
533#ifdef CONFIG_FEATURE_VI_DOT_CMD
534 // These are commands that change text[].
535 // Remember the input for the "." command
536 if (!adding2q && ioq_start == 0
537 && strchr((char *) modifying_cmds, c) != NULL) {
538 start_new_cmd_q(c);
539 }
540#endif /* CONFIG_FEATURE_VI_DOT_CMD */
541 do_cmd(c); // execute the user command
542 //
543 // poll to see if there is input already waiting. if we are
544 // not able to display output fast enough to keep up, skip
545 // the display update until we catch up with input.
546 if (mysleep(0) == 0) {
547 // no input pending- so update output
548 refresh(FALSE);
549 show_status_line();
550 }
551#ifdef CONFIG_FEATURE_VI_CRASHME
552 if (crashme > 0)
553 crash_test(); // test editor variables
554#endif /* CONFIG_FEATURE_VI_CRASHME */
555 }
556 //-------------------------------------------------------------------
557
558 place_cursor(rows, 0, FALSE); // go to bottom of screen
559 clear_to_eol(); // Erase to end of line
560 cookmode();
561}
562
563//----- The Colon commands -------------------------------------
564#ifdef CONFIG_FEATURE_VI_COLON
565static Byte *get_one_address(Byte * p, int *addr) // get colon addr, if present
566{
567 int st;
568 Byte *q;
569
570#ifdef CONFIG_FEATURE_VI_YANKMARK
571 Byte c;
572#endif /* CONFIG_FEATURE_VI_YANKMARK */
573#ifdef CONFIG_FEATURE_VI_SEARCH
574 Byte *pat, buf[BUFSIZ];
575#endif /* CONFIG_FEATURE_VI_SEARCH */
576
577 *addr = -1; // assume no addr
578 if (*p == '.') { // the current line
579 p++;
580 q = begin_line(dot);
581 *addr = count_lines(text, q);
582#ifdef CONFIG_FEATURE_VI_YANKMARK
583 } else if (*p == '\'') { // is this a mark addr
584 p++;
585 c = tolower(*p);
586 p++;
587 if (c >= 'a' && c <= 'z') {
588 // we have a mark
589 c = c - 'a';
590 q = mark[(int) c];
591 if (q != NULL) { // is mark valid
592 *addr = count_lines(text, q); // count lines
593 }
594 }
595#endif /* CONFIG_FEATURE_VI_YANKMARK */
596#ifdef CONFIG_FEATURE_VI_SEARCH
597 } else if (*p == '/') { // a search pattern
598 q = buf;
599 for (p++; *p; p++) {
600 if (*p == '/')
601 break;
602 *q++ = *p;
603 *q = '\0';
604 }
605 pat = (Byte *) bb_xstrdup((char *) buf); // save copy of pattern
606 if (*p == '/')
607 p++;
608 q = char_search(dot, pat, FORWARD, FULL);
609 if (q != NULL) {
610 *addr = count_lines(text, q);
611 }
612 free(pat);
613#endif /* CONFIG_FEATURE_VI_SEARCH */
614 } else if (*p == '$') { // the last line in file
615 p++;
616 q = begin_line(end - 1);
617 *addr = count_lines(text, q);
618 } else if (isdigit(*p)) { // specific line number
619 sscanf((char *) p, "%d%n", addr, &st);
620 p += st;
621 } else { // I don't reconise this
622 // unrecognised address- assume -1
623 *addr = -1;
624 }
625 return (p);
626}
627
628static Byte *get_address(Byte *p, int *b, int *e) // get two colon addrs, if present
629{
630 //----- get the address' i.e., 1,3 'a,'b -----
631 // get FIRST addr, if present
632 while (isblnk(*p))
633 p++; // skip over leading spaces
634 if (*p == '%') { // alias for 1,$
635 p++;
636 *b = 1;
637 *e = count_lines(text, end-1);
638 goto ga0;
639 }
640 p = get_one_address(p, b);
641 while (isblnk(*p))
642 p++;
643 if (*p == ',') { // is there a address separator
644 p++;
645 while (isblnk(*p))
646 p++;
647 // get SECOND addr, if present
648 p = get_one_address(p, e);
649 }
650ga0:
651 while (isblnk(*p))
652 p++; // skip over trailing spaces
653 return (p);
654}
655
656#ifdef CONFIG_FEATURE_VI_SETOPTS
657static void setops(const Byte *args, const char *opname, int flg_no,
658 const char *short_opname, int opt)
659{
660 const char *a = (char *) args + flg_no;
661 int l = strlen(opname) - 1; /* opname have + ' ' */
662
663 if (strncasecmp(a, opname, l) == 0 ||
664 strncasecmp(a, short_opname, 2) == 0) {
665 if(flg_no)
666 vi_setops &= ~opt;
667 else
668 vi_setops |= opt;
669 }
670}
671#endif
672
673static void colon(Byte * buf)
674{
675 Byte c, *orig_buf, *buf1, *q, *r;
676 Byte *fn, cmd[BUFSIZ], args[BUFSIZ];
677 int i, l, li, ch, st, b, e;
678 int useforce = FALSE, forced = FALSE;
679 struct stat st_buf;
680
681 // :3154 // if (-e line 3154) goto it else stay put
682 // :4,33w! foo // write a portion of buffer to file "foo"
683 // :w // write all of buffer to current file
684 // :q // quit
685 // :q! // quit- dont care about modified file
686 // :'a,'z!sort -u // filter block through sort
687 // :'f // goto mark "f"
688 // :'fl // list literal the mark "f" line
689 // :.r bar // read file "bar" into buffer before dot
690 // :/123/,/abc/d // delete lines from "123" line to "abc" line
691 // :/xyz/ // goto the "xyz" line
692 // :s/find/replace/ // substitute pattern "find" with "replace"
693 // :!<cmd> // run <cmd> then return
694 //
695
696 if (strlen((char *) buf) <= 0)
697 goto vc1;
698 if (*buf == ':')
699 buf++; // move past the ':'
700
701 li = st = ch = i = 0;
702 b = e = -1;
703 q = text; // assume 1,$ for the range
704 r = end - 1;
705 li = count_lines(text, end - 1);
706 fn = cfn; // default to current file
707 memset(cmd, '\0', BUFSIZ); // clear cmd[]
708 memset(args, '\0', BUFSIZ); // clear args[]
709
710 // look for optional address(es) :. :1 :1,9 :'q,'a :%
711 buf = get_address(buf, &b, &e);
712
713 // remember orig command line
714 orig_buf = buf;
715
716 // get the COMMAND into cmd[]
717 buf1 = cmd;
718 while (*buf != '\0') {
719 if (isspace(*buf))
720 break;
721 *buf1++ = *buf++;
722 }
723 // get any ARGuments
724 while (isblnk(*buf))
725 buf++;
726 strcpy((char *) args, (char *) buf);
727 buf1 = last_char_is((char *)cmd, '!');
728 if (buf1) {
729 useforce = TRUE;
730 *buf1 = '\0'; // get rid of !
731 }
732 if (b >= 0) {
733 // if there is only one addr, then the addr
734 // is the line number of the single line the
735 // user wants. So, reset the end
736 // pointer to point at end of the "b" line
737 q = find_line(b); // what line is #b
738 r = end_line(q);
739 li = 1;
740 }
741 if (e >= 0) {
742 // we were given two addrs. change the
743 // end pointer to the addr given by user.
744 r = find_line(e); // what line is #e
745 r = end_line(r);
746 li = e - b + 1;
747 }
748 // ------------ now look for the command ------------
749 i = strlen((char *) cmd);
750 if (i == 0) { // :123CR goto line #123
751 if (b >= 0) {
752 dot = find_line(b); // what line is #b
753 dot_skip_over_ws();
754 }
755 } else if (strncmp((char *) cmd, "!", 1) == 0) { // run a cmd
756 // :!ls run the <cmd>
757 (void) alarm(0); // wait for input- no alarms
758 place_cursor(rows - 1, 0, FALSE); // go to Status line
759 clear_to_eol(); // clear the line
760 cookmode();
761 system(orig_buf+1); // run the cmd
762 rawmode();
763 Hit_Return(); // let user see results
764 (void) alarm(3); // done waiting for input
765 } else if (strncmp((char *) cmd, "=", i) == 0) { // where is the address
766 if (b < 0) { // no addr given- use defaults
767 b = e = count_lines(text, dot);
768 }
769 psb("%d", b);
770 } else if (strncasecmp((char *) cmd, "delete", i) == 0) { // delete lines
771 if (b < 0) { // no addr given- use defaults
772 q = begin_line(dot); // assume .,. for the range
773 r = end_line(dot);
774 }
775 dot = yank_delete(q, r, 1, YANKDEL); // save, then delete lines
776 dot_skip_over_ws();
777 } else if (strncasecmp((char *) cmd, "edit", i) == 0) { // Edit a file
778 int sr;
779 sr= 0;
780 // don't edit, if the current file has been modified
781 if (file_modified && ! useforce) {
782 psbs("No write since last change (:edit! overrides)");
783 goto vc1;
784 }
785 if (strlen(args) > 0) {
786 // the user supplied a file name
787 fn= args;
788 } else if (cfn != 0 && strlen(cfn) > 0) {
789 // no user supplied name- use the current filename
790 fn= cfn;
791 goto vc5;
792 } else {
793 // no user file name, no current name- punt
794 psbs("No current filename");
795 goto vc1;
796 }
797
798 // see if file exists- if not, its just a new file request
799 if ((sr=stat((char*)fn, &st_buf)) < 0) {
800 // This is just a request for a new file creation.
801 // The file_insert below will fail but we get
802 // an empty buffer with a file name. Then the "write"
803 // command can do the create.
804 } else {
805 if ((st_buf.st_mode & (S_IFREG)) == 0) {
806 // This is not a regular file
807 psbs("\"%s\" is not a regular file", fn);
808 goto vc1;
809 }
810 if ((st_buf.st_mode & (S_IRUSR | S_IRGRP | S_IROTH)) == 0) {
811 // dont have any read permissions
812 psbs("\"%s\" is not readable", fn);
813 goto vc1;
814 }
815 }
816
817 // There is a read-able regular file
818 // make this the current file
819 q = (Byte *) bb_xstrdup((char *) fn); // save the cfn
820 free(cfn); // free the old name
821 cfn = q; // remember new cfn
822
823 vc5:
824 // delete all the contents of text[]
825 new_text(2 * file_size(fn));
826 screenbegin = dot = end = text;
827
828 // insert new file
829 ch = file_insert(fn, text, file_size(fn));
830
831 if (ch < 1) {
832 // start empty buf with dummy line
833 (void) char_insert(text, '\n');
834 ch= 1;
835 }
836 file_modified = FALSE;
837#ifdef CONFIG_FEATURE_VI_YANKMARK
838 if (Ureg >= 0 && Ureg < 28 && reg[Ureg] != 0) {
839 free(reg[Ureg]); // free orig line reg- for 'U'
840 reg[Ureg]= 0;
841 }
842 if (YDreg >= 0 && YDreg < 28 && reg[YDreg] != 0) {
843 free(reg[YDreg]); // free default yank/delete register
844 reg[YDreg]= 0;
845 }
846 for (li = 0; li < 28; li++) {
847 mark[li] = 0;
848 } // init the marks
849#endif /* CONFIG_FEATURE_VI_YANKMARK */
850 // how many lines in text[]?
851 li = count_lines(text, end - 1);
852 psb("\"%s\"%s"
853#ifdef CONFIG_FEATURE_VI_READONLY
854 "%s"
855#endif /* CONFIG_FEATURE_VI_READONLY */
856 " %dL, %dC", cfn,
857 (sr < 0 ? " [New file]" : ""),
858#ifdef CONFIG_FEATURE_VI_READONLY
859 ((vi_readonly || readonly) ? " [Read only]" : ""),
860#endif /* CONFIG_FEATURE_VI_READONLY */
861 li, ch);
862 } else if (strncasecmp((char *) cmd, "file", i) == 0) { // what File is this
863 if (b != -1 || e != -1) {
864 ni((Byte *) "No address allowed on this command");
865 goto vc1;
866 }
867 if (strlen((char *) args) > 0) {
868 // user wants a new filename
869 free(cfn);
870 cfn = (Byte *) bb_xstrdup((char *) args);
871 } else {
872 // user wants file status info
873 edit_status();
874 }
875 } else if (strncasecmp((char *) cmd, "features", i) == 0) { // what features are available
876 // print out values of all features
877 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
878 clear_to_eol(); // clear the line
879 cookmode();
880 show_help();
881 rawmode();
882 Hit_Return();
883 } else if (strncasecmp((char *) cmd, "list", i) == 0) { // literal print line
884 if (b < 0) { // no addr given- use defaults
885 q = begin_line(dot); // assume .,. for the range
886 r = end_line(dot);
887 }
888 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
889 clear_to_eol(); // clear the line
890 puts("\r");
891 for (; q <= r; q++) {
892 int c_is_no_print;
893
894 c = *q;
895 c_is_no_print = c > 127 && !Isprint(c);
896 if (c_is_no_print) {
897 c = '.';
898 standout_start();
899 }
900 if (c == '\n') {
901 write1("$\r");
902 } else if (c < ' ' || c == 127) {
903 putchar('^');
904 if(c == 127)
905 c = '?';
906 else
907 c += '@';
908 }
909 putchar(c);
910 if (c_is_no_print)
911 standout_end();
912 }
913#ifdef CONFIG_FEATURE_VI_SET
914 vc2:
915#endif /* CONFIG_FEATURE_VI_SET */
916 Hit_Return();
917 } else if ((strncasecmp((char *) cmd, "quit", i) == 0) || // Quit
918 (strncasecmp((char *) cmd, "next", i) == 0)) { // edit next file
919 if (useforce) {
920 // force end of argv list
921 if (*cmd == 'q') {
922 optind = save_argc;
923 }
924 editing = 0;
925 goto vc1;
926 }
927 // don't exit if the file been modified
928 if (file_modified) {
929 psbs("No write since last change (:%s! overrides)",
930 (*cmd == 'q' ? "quit" : "next"));
931 goto vc1;
932 }
933 // are there other file to edit
934 if (*cmd == 'q' && optind < save_argc - 1) {
935 psbs("%d more file to edit", (save_argc - optind - 1));
936 goto vc1;
937 }
938 if (*cmd == 'n' && optind >= save_argc - 1) {
939 psbs("No more files to edit");
940 goto vc1;
941 }
942 editing = 0;
943 } else if (strncasecmp((char *) cmd, "read", i) == 0) { // read file into text[]
944 fn = args;
945 if (strlen((char *) fn) <= 0) {
946 psbs("No filename given");
947 goto vc1;
948 }
949 if (b < 0) { // no addr given- use defaults
950 q = begin_line(dot); // assume "dot"
951 }
952 // read after current line- unless user said ":0r foo"
953 if (b != 0)
954 q = next_line(q);
955#ifdef CONFIG_FEATURE_VI_READONLY
956 l= readonly; // remember current files' status
957#endif
958 ch = file_insert(fn, q, file_size(fn));
959#ifdef CONFIG_FEATURE_VI_READONLY
960 readonly= l;
961#endif
962 if (ch < 0)
963 goto vc1; // nothing was inserted
964 // how many lines in text[]?
965 li = count_lines(q, q + ch - 1);
966 psb("\"%s\""
967#ifdef CONFIG_FEATURE_VI_READONLY
968 "%s"
969#endif /* CONFIG_FEATURE_VI_READONLY */
970 " %dL, %dC", fn,
971#ifdef CONFIG_FEATURE_VI_READONLY
972 ((vi_readonly || readonly) ? " [Read only]" : ""),
973#endif /* CONFIG_FEATURE_VI_READONLY */
974 li, ch);
975 if (ch > 0) {
976 // if the insert is before "dot" then we need to update
977 if (q <= dot)
978 dot += ch;
979 file_modified = TRUE;
980 }
981 } else if (strncasecmp((char *) cmd, "rewind", i) == 0) { // rewind cmd line args
982 if (file_modified && ! useforce) {
983 psbs("No write since last change (:rewind! overrides)");
984 } else {
985 // reset the filenames to edit
986 optind = fn_start - 1;
987 editing = 0;
988 }
989#ifdef CONFIG_FEATURE_VI_SET
990 } else if (strncasecmp((char *) cmd, "set", i) == 0) { // set or clear features
991 i = 0; // offset into args
992 if (strlen((char *) args) == 0) {
993 // print out values of all options
994 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
995 clear_to_eol(); // clear the line
996 printf("----------------------------------------\r\n");
997#ifdef CONFIG_FEATURE_VI_SETOPTS
998 if (!autoindent)
999 printf("no");
1000 printf("autoindent ");
1001 if (!err_method)
1002 printf("no");
1003 printf("flash ");
1004 if (!ignorecase)
1005 printf("no");
1006 printf("ignorecase ");
1007 if (!showmatch)
1008 printf("no");
1009 printf("showmatch ");
1010 printf("tabstop=%d ", tabstop);
1011#endif /* CONFIG_FEATURE_VI_SETOPTS */
1012 printf("\r\n");
1013 goto vc2;
1014 }
1015 if (strncasecmp((char *) args, "no", 2) == 0)
1016 i = 2; // ":set noautoindent"
1017#ifdef CONFIG_FEATURE_VI_SETOPTS
1018 setops(args, "autoindent ", i, "ai", VI_AUTOINDENT);
1019 setops(args, "flash ", i, "fl", VI_ERR_METHOD);
1020 setops(args, "ignorecase ", i, "ic", VI_IGNORECASE);
1021 setops(args, "showmatch ", i, "ic", VI_SHOWMATCH);
1022 if (strncasecmp((char *) args + i, "tabstop=%d ", 7) == 0) {
1023 sscanf(strchr((char *) args + i, '='), "=%d", &ch);
1024 if (ch > 0 && ch < columns - 1)
1025 tabstop = ch;
1026 }
1027#endif /* CONFIG_FEATURE_VI_SETOPTS */
1028#endif /* CONFIG_FEATURE_VI_SET */
1029#ifdef CONFIG_FEATURE_VI_SEARCH
1030 } else if (strncasecmp((char *) cmd, "s", 1) == 0) { // substitute a pattern with a replacement pattern
1031 Byte *ls, *F, *R;
1032 int gflag;
1033
1034 // F points to the "find" pattern
1035 // R points to the "replace" pattern
1036 // replace the cmd line delimiters "/" with NULLs
1037 gflag = 0; // global replace flag
1038 c = orig_buf[1]; // what is the delimiter
1039 F = orig_buf + 2; // start of "find"
1040 R = (Byte *) strchr((char *) F, c); // middle delimiter
1041 if (!R) goto colon_s_fail;
1042 *R++ = '\0'; // terminate "find"
1043 buf1 = (Byte *) strchr((char *) R, c);
1044 if (!buf1) goto colon_s_fail;
1045 *buf1++ = '\0'; // terminate "replace"
1046 if (*buf1 == 'g') { // :s/foo/bar/g
1047 buf1++;
1048 gflag++; // turn on gflag
1049 }
1050 q = begin_line(q);
1051 if (b < 0) { // maybe :s/foo/bar/
1052 q = begin_line(dot); // start with cur line
1053 b = count_lines(text, q); // cur line number
1054 }
1055 if (e < 0)
1056 e = b; // maybe :.s/foo/bar/
1057 for (i = b; i <= e; i++) { // so, :20,23 s \0 find \0 replace \0
1058 ls = q; // orig line start
1059 vc4:
1060 buf1 = char_search(q, F, FORWARD, LIMITED); // search cur line only for "find"
1061 if (buf1 != NULL) {
1062 // we found the "find" pattern- delete it
1063 (void) text_hole_delete(buf1, buf1 + strlen((char *) F) - 1);
1064 // inset the "replace" patern
1065 (void) string_insert(buf1, R); // insert the string
1066 // check for "global" :s/foo/bar/g
1067 if (gflag == 1) {
1068 if ((buf1 + strlen((char *) R)) < end_line(ls)) {
1069 q = buf1 + strlen((char *) R);
1070 goto vc4; // don't let q move past cur line
1071 }
1072 }
1073 }
1074 q = next_line(ls);
1075 }
1076#endif /* CONFIG_FEATURE_VI_SEARCH */
1077 } else if (strncasecmp((char *) cmd, "version", i) == 0) { // show software version
1078 psb("%s", vi_Version);
1079 } else if ((strncasecmp((char *) cmd, "write", i) == 0) || // write text to file
1080 (strncasecmp((char *) cmd, "wq", i) == 0) ||
1081 (strncasecmp((char *) cmd, "x", i) == 0)) {
1082 // is there a file name to write to?
1083 if (strlen((char *) args) > 0) {
1084 fn = args;
1085 }
1086#ifdef CONFIG_FEATURE_VI_READONLY
1087 if ((vi_readonly || readonly) && ! useforce) {
1088 psbs("\"%s\" File is read only", fn);
1089 goto vc3;
1090 }
1091#endif /* CONFIG_FEATURE_VI_READONLY */
1092 // how many lines in text[]?
1093 li = count_lines(q, r);
1094 ch = r - q + 1;
1095 // see if file exists- if not, its just a new file request
1096 if (useforce) {
1097 // if "fn" is not write-able, chmod u+w
1098 // sprintf(syscmd, "chmod u+w %s", fn);
1099 // system(syscmd);
1100 forced = TRUE;
1101 }
1102 l = file_write(fn, q, r);
1103 if (useforce && forced) {
1104 // chmod u-w
1105 // sprintf(syscmd, "chmod u-w %s", fn);
1106 // system(syscmd);
1107 forced = FALSE;
1108 }
1109 psb("\"%s\" %dL, %dC", fn, li, l);
1110 if (q == text && r == end - 1 && l == ch)
1111 file_modified = FALSE;
1112 if ((cmd[0] == 'x' || cmd[1] == 'q') && l == ch) {
1113 editing = 0;
1114 }
1115#ifdef CONFIG_FEATURE_VI_READONLY
1116 vc3:;
1117#endif /* CONFIG_FEATURE_VI_READONLY */
1118#ifdef CONFIG_FEATURE_VI_YANKMARK
1119 } else if (strncasecmp((char *) cmd, "yank", i) == 0) { // yank lines
1120 if (b < 0) { // no addr given- use defaults
1121 q = begin_line(dot); // assume .,. for the range
1122 r = end_line(dot);
1123 }
1124 text_yank(q, r, YDreg);
1125 li = count_lines(q, r);
1126 psb("Yank %d lines (%d chars) into [%c]",
1127 li, strlen((char *) reg[YDreg]), what_reg());
1128#endif /* CONFIG_FEATURE_VI_YANKMARK */
1129 } else {
1130 // cmd unknown
1131 ni((Byte *) cmd);
1132 }
1133 vc1:
1134 dot = bound_dot(dot); // make sure "dot" is valid
1135 return;
1136#ifdef CONFIG_FEATURE_VI_SEARCH
1137colon_s_fail:
1138 psb(":s expression missing delimiters");
1139#endif
1140}
1141
1142static void Hit_Return(void)
1143{
1144 char c;
1145
1146 standout_start(); // start reverse video
1147 write1("[Hit return to continue]");
1148 standout_end(); // end reverse video
1149 while ((c = get_one_char()) != '\n' && c != '\r') /*do nothing */
1150 ;
1151 redraw(TRUE); // force redraw all
1152}
1153#endif /* CONFIG_FEATURE_VI_COLON */
1154
1155//----- Synchronize the cursor to Dot --------------------------
1156static void sync_cursor(Byte * d, int *row, int *col)
1157{
1158 Byte *beg_cur, *end_cur; // begin and end of "d" line
1159 Byte *beg_scr, *end_scr; // begin and end of screen
1160 Byte *tp;
1161 int cnt, ro, co;
1162
1163 beg_cur = begin_line(d); // first char of cur line
1164 end_cur = end_line(d); // last char of cur line
1165
1166 beg_scr = end_scr = screenbegin; // first char of screen
1167 end_scr = end_screen(); // last char of screen
1168
1169 if (beg_cur < screenbegin) {
1170 // "d" is before top line on screen
1171 // how many lines do we have to move
1172 cnt = count_lines(beg_cur, screenbegin);
1173 sc1:
1174 screenbegin = beg_cur;
1175 if (cnt > (rows - 1) / 2) {
1176 // we moved too many lines. put "dot" in middle of screen
1177 for (cnt = 0; cnt < (rows - 1) / 2; cnt++) {
1178 screenbegin = prev_line(screenbegin);
1179 }
1180 }
1181 } else if (beg_cur > end_scr) {
1182 // "d" is after bottom line on screen
1183 // how many lines do we have to move
1184 cnt = count_lines(end_scr, beg_cur);
1185 if (cnt > (rows - 1) / 2)
1186 goto sc1; // too many lines
1187 for (ro = 0; ro < cnt - 1; ro++) {
1188 // move screen begin the same amount
1189 screenbegin = next_line(screenbegin);
1190 // now, move the end of screen
1191 end_scr = next_line(end_scr);
1192 end_scr = end_line(end_scr);
1193 }
1194 }
1195 // "d" is on screen- find out which row
1196 tp = screenbegin;
1197 for (ro = 0; ro < rows - 1; ro++) { // drive "ro" to correct row
1198 if (tp == beg_cur)
1199 break;
1200 tp = next_line(tp);
1201 }
1202
1203 // find out what col "d" is on
1204 co = 0;
1205 do { // drive "co" to correct column
1206 if (*tp == '\n' || *tp == '\0')
1207 break;
1208 if (*tp == '\t') {
1209 // 7 - (co % 8 )
1210 co += ((tabstop - 1) - (co % tabstop));
1211 } else if (*tp < ' ' || *tp == 127) {
1212 co++; // display as ^X, use 2 columns
1213 }
1214 } while (tp++ < d && ++co);
1215
1216 // "co" is the column where "dot" is.
1217 // The screen has "columns" columns.
1218 // The currently displayed columns are 0+offset -- columns+ofset
1219 // |-------------------------------------------------------------|
1220 // ^ ^ ^
1221 // offset | |------- columns ----------------|
1222 //
1223 // If "co" is already in this range then we do not have to adjust offset
1224 // but, we do have to subtract the "offset" bias from "co".
1225 // If "co" is outside this range then we have to change "offset".
1226 // If the first char of a line is a tab the cursor will try to stay
1227 // in column 7, but we have to set offset to 0.
1228
1229 if (co < 0 + offset) {
1230 offset = co;
1231 }
1232 if (co >= columns + offset) {
1233 offset = co - columns + 1;
1234 }
1235 // if the first char of the line is a tab, and "dot" is sitting on it
1236 // force offset to 0.
1237 if (d == beg_cur && *d == '\t') {
1238 offset = 0;
1239 }
1240 co -= offset;
1241
1242 *row = ro;
1243 *col = co;
1244}
1245
1246//----- Text Movement Routines ---------------------------------
1247static Byte *begin_line(Byte * p) // return pointer to first char cur line
1248{
1249 while (p > text && p[-1] != '\n')
1250 p--; // go to cur line B-o-l
1251 return (p);
1252}
1253
1254static Byte *end_line(Byte * p) // return pointer to NL of cur line line
1255{
1256 while (p < end - 1 && *p != '\n')
1257 p++; // go to cur line E-o-l
1258 return (p);
1259}
1260
1261static inline Byte *dollar_line(Byte * p) // return pointer to just before NL line
1262{
1263 while (p < end - 1 && *p != '\n')
1264 p++; // go to cur line E-o-l
1265 // Try to stay off of the Newline
1266 if (*p == '\n' && (p - begin_line(p)) > 0)
1267 p--;
1268 return (p);
1269}
1270
1271static Byte *prev_line(Byte * p) // return pointer first char prev line
1272{
1273 p = begin_line(p); // goto begining of cur line
1274 if (p[-1] == '\n' && p > text)
1275 p--; // step to prev line
1276 p = begin_line(p); // goto begining of prev line
1277 return (p);
1278}
1279
1280static Byte *next_line(Byte * p) // return pointer first char next line
1281{
1282 p = end_line(p);
1283 if (*p == '\n' && p < end - 1)
1284 p++; // step to next line
1285 return (p);
1286}
1287
1288//----- Text Information Routines ------------------------------
1289static Byte *end_screen(void)
1290{
1291 Byte *q;
1292 int cnt;
1293
1294 // find new bottom line
1295 q = screenbegin;
1296 for (cnt = 0; cnt < rows - 2; cnt++)
1297 q = next_line(q);
1298 q = end_line(q);
1299 return (q);
1300}
1301
1302static int count_lines(Byte * start, Byte * stop) // count line from start to stop
1303{
1304 Byte *q;
1305 int cnt;
1306
1307 if (stop < start) { // start and stop are backwards- reverse them
1308 q = start;
1309 start = stop;
1310 stop = q;
1311 }
1312 cnt = 0;
1313 stop = end_line(stop); // get to end of this line
1314 for (q = start; q <= stop && q <= end - 1; q++) {
1315 if (*q == '\n')
1316 cnt++;
1317 }
1318 return (cnt);
1319}
1320
1321static Byte *find_line(int li) // find begining of line #li
1322{
1323 Byte *q;
1324
1325 for (q = text; li > 1; li--) {
1326 q = next_line(q);
1327 }
1328 return (q);
1329}
1330
1331//----- Dot Movement Routines ----------------------------------
1332static void dot_left(void)
1333{
1334 if (dot > text && dot[-1] != '\n')
1335 dot--;
1336}
1337
1338static void dot_right(void)
1339{
1340 if (dot < end - 1 && *dot != '\n')
1341 dot++;
1342}
1343
1344static void dot_begin(void)
1345{
1346 dot = begin_line(dot); // return pointer to first char cur line
1347}
1348
1349static void dot_end(void)
1350{
1351 dot = end_line(dot); // return pointer to last char cur line
1352}
1353
1354static Byte *move_to_col(Byte * p, int l)
1355{
1356 int co;
1357
1358 p = begin_line(p);
1359 co = 0;
1360 do {
1361 if (*p == '\n' || *p == '\0')
1362 break;
1363 if (*p == '\t') {
1364 // 7 - (co % 8 )
1365 co += ((tabstop - 1) - (co % tabstop));
1366 } else if (*p < ' ' || *p == 127) {
1367 co++; // display as ^X, use 2 columns
1368 }
1369 } while (++co <= l && p++ < end);
1370 return (p);
1371}
1372
1373static void dot_next(void)
1374{
1375 dot = next_line(dot);
1376}
1377
1378static void dot_prev(void)
1379{
1380 dot = prev_line(dot);
1381}
1382
1383static void dot_scroll(int cnt, int dir)
1384{
1385 Byte *q;
1386
1387 for (; cnt > 0; cnt--) {
1388 if (dir < 0) {
1389 // scroll Backwards
1390 // ctrl-Y scroll up one line
1391 screenbegin = prev_line(screenbegin);
1392 } else {
1393 // scroll Forwards
1394 // ctrl-E scroll down one line
1395 screenbegin = next_line(screenbegin);
1396 }
1397 }
1398 // make sure "dot" stays on the screen so we dont scroll off
1399 if (dot < screenbegin)
1400 dot = screenbegin;
1401 q = end_screen(); // find new bottom line
1402 if (dot > q)
1403 dot = begin_line(q); // is dot is below bottom line?
1404 dot_skip_over_ws();
1405}
1406
1407static void dot_skip_over_ws(void)
1408{
1409 // skip WS
1410 while (isspace(*dot) && *dot != '\n' && dot < end - 1)
1411 dot++;
1412}
1413
1414static void dot_delete(void) // delete the char at 'dot'
1415{
1416 (void) text_hole_delete(dot, dot);
1417}
1418
1419static Byte *bound_dot(Byte * p) // make sure text[0] <= P < "end"
1420{
1421 if (p >= end && end > text) {
1422 p = end - 1;
1423 indicate_error('1');
1424 }
1425 if (p < text) {
1426 p = text;
1427 indicate_error('2');
1428 }
1429 return (p);
1430}
1431
1432//----- Helper Utility Routines --------------------------------
1433
1434//----------------------------------------------------------------
1435//----- Char Routines --------------------------------------------
1436/* Chars that are part of a word-
1437 * 0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
1438 * Chars that are Not part of a word (stoppers)
1439 * !"#$%&'()*+,-./:;<=>?@[\]^`{|}~
1440 * Chars that are WhiteSpace
1441 * TAB NEWLINE VT FF RETURN SPACE
1442 * DO NOT COUNT NEWLINE AS WHITESPACE
1443 */
1444
1445static Byte *new_screen(int ro, int co)
1446{
1447 int li;
1448
1449 free(screen);
1450 screensize = ro * co + 8;
1451 screen = (Byte *) xmalloc(screensize);
1452 // initialize the new screen. assume this will be a empty file.
1453 screen_erase();
1454 // non-existent text[] lines start with a tilde (~).
1455 for (li = 1; li < ro - 1; li++) {
1456 screen[(li * co) + 0] = '~';
1457 }
1458 return (screen);
1459}
1460
1461static Byte *new_text(int size)
1462{
1463 if (size < 10240)
1464 size = 10240; // have a minimum size for new files
1465 free(text);
1466 text = (Byte *) xmalloc(size + 8);
1467 memset(text, '\0', size); // clear new text[]
1468 //text += 4; // leave some room for "oops"
1469 textend = text + size - 1;
1470 //textend -= 4; // leave some root for "oops"
1471 return (text);
1472}
1473
1474#ifdef CONFIG_FEATURE_VI_SEARCH
1475static int mycmp(Byte * s1, Byte * s2, int len)
1476{
1477 int i;
1478
1479 i = strncmp((char *) s1, (char *) s2, len);
1480#ifdef CONFIG_FEATURE_VI_SETOPTS
1481 if (ignorecase) {
1482 i = strncasecmp((char *) s1, (char *) s2, len);
1483 }
1484#endif /* CONFIG_FEATURE_VI_SETOPTS */
1485 return (i);
1486}
1487
1488static Byte *char_search(Byte * p, Byte * pat, int dir, int range) // search for pattern starting at p
1489{
1490#ifndef REGEX_SEARCH
1491 Byte *start, *stop;
1492 int len;
1493
1494 len = strlen((char *) pat);
1495 if (dir == FORWARD) {
1496 stop = end - 1; // assume range is p - end-1
1497 if (range == LIMITED)
1498 stop = next_line(p); // range is to next line
1499 for (start = p; start < stop; start++) {
1500 if (mycmp(start, pat, len) == 0) {
1501 return (start);
1502 }
1503 }
1504 } else if (dir == BACK) {
1505 stop = text; // assume range is text - p
1506 if (range == LIMITED)
1507 stop = prev_line(p); // range is to prev line
1508 for (start = p - len; start >= stop; start--) {
1509 if (mycmp(start, pat, len) == 0) {
1510 return (start);
1511 }
1512 }
1513 }
1514 // pattern not found
1515 return (NULL);
1516#else /*REGEX_SEARCH */
1517 char *q;
1518 struct re_pattern_buffer preg;
1519 int i;
1520 int size, range;
1521
1522 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1523 preg.translate = 0;
1524 preg.fastmap = 0;
1525 preg.buffer = 0;
1526 preg.allocated = 0;
1527
1528 // assume a LIMITED forward search
1529 q = next_line(p);
1530 q = end_line(q);
1531 q = end - 1;
1532 if (dir == BACK) {
1533 q = prev_line(p);
1534 q = text;
1535 }
1536 // count the number of chars to search over, forward or backward
1537 size = q - p;
1538 if (size < 0)
1539 size = p - q;
1540 // RANGE could be negative if we are searching backwards
1541 range = q - p;
1542
1543 q = (char *) re_compile_pattern(pat, strlen((char *) pat), &preg);
1544 if (q != 0) {
1545 // The pattern was not compiled
1546 psbs("bad search pattern: \"%s\": %s", pat, q);
1547 i = 0; // return p if pattern not compiled
1548 goto cs1;
1549 }
1550
1551 q = p;
1552 if (range < 0) {
1553 q = p - size;
1554 if (q < text)
1555 q = text;
1556 }
1557 // search for the compiled pattern, preg, in p[]
1558 // range < 0- search backward
1559 // range > 0- search forward
1560 // 0 < start < size
1561 // re_search() < 0 not found or error
1562 // re_search() > 0 index of found pattern
1563 // struct pattern char int int int struct reg
1564 // re_search (*pattern_buffer, *string, size, start, range, *regs)
1565 i = re_search(&preg, q, size, 0, range, 0);
1566 if (i == -1) {
1567 p = 0;
1568 i = 0; // return NULL if pattern not found
1569 }
1570 cs1:
1571 if (dir == FORWARD) {
1572 p = p + i;
1573 } else {
1574 p = p - i;
1575 }
1576 return (p);
1577#endif /*REGEX_SEARCH */
1578}
1579#endif /* CONFIG_FEATURE_VI_SEARCH */
1580
1581static Byte *char_insert(Byte * p, Byte c) // insert the char c at 'p'
1582{
1583 if (c == 22) { // Is this an ctrl-V?
1584 p = stupid_insert(p, '^'); // use ^ to indicate literal next
1585 p--; // backup onto ^
1586 refresh(FALSE); // show the ^
1587 c = get_one_char();
1588 *p = c;
1589 p++;
1590 file_modified = TRUE; // has the file been modified
1591 } else if (c == 27) { // Is this an ESC?
1592 cmd_mode = 0;
1593 cmdcnt = 0;
1594 end_cmd_q(); // stop adding to q
1595 strcpy((char *) status_buffer, " "); // clear the status buffer
1596 if ((p[-1] != '\n') && (dot>text)) {
1597 p--;
1598 }
1599 } else if (c == erase_char) { // Is this a BS
1600 // 123456789
1601 if ((p[-1] != '\n') && (dot>text)) {
1602 p--;
1603 p = text_hole_delete(p, p); // shrink buffer 1 char
1604#ifdef CONFIG_FEATURE_VI_DOT_CMD
1605 // also rmove char from last_modifying_cmd
1606 if (last_modifying_cmd != 0 && strlen((char *) last_modifying_cmd) > 0) {
1607 Byte *q;
1608
1609 q = last_modifying_cmd;
1610 q[strlen((char *) q) - 1] = '\0'; // erase BS
1611 q[strlen((char *) q) - 1] = '\0'; // erase prev char
1612 }
1613#endif /* CONFIG_FEATURE_VI_DOT_CMD */
1614 }
1615 } else {
1616 // insert a char into text[]
1617 Byte *sp; // "save p"
1618
1619 if (c == 13)
1620 c = '\n'; // translate \r to \n
1621 sp = p; // remember addr of insert
1622 p = stupid_insert(p, c); // insert the char
1623#ifdef CONFIG_FEATURE_VI_SETOPTS
1624 if (showmatch && strchr(")]}", *sp) != NULL) {
1625 showmatching(sp);
1626 }
1627 if (autoindent && c == '\n') { // auto indent the new line
1628 Byte *q;
1629
1630 q = prev_line(p); // use prev line as templet
1631 for (; isblnk(*q); q++) {
1632 p = stupid_insert(p, *q); // insert the char
1633 }
1634 }
1635#endif /* CONFIG_FEATURE_VI_SETOPTS */
1636 }
1637 return (p);
1638}
1639
1640static Byte *stupid_insert(Byte * p, Byte c) // stupidly insert the char c at 'p'
1641{
1642 p = text_hole_make(p, 1);
1643 if (p != 0) {
1644 *p = c;
1645 file_modified = TRUE; // has the file been modified
1646 p++;
1647 }
1648 return (p);
1649}
1650
1651static Byte find_range(Byte ** start, Byte ** stop, Byte c)
1652{
1653 Byte *save_dot, *p, *q;
1654 int cnt;
1655
1656 save_dot = dot;
1657 p = q = dot;
1658
1659 if (strchr("cdy><", c)) {
1660 // these cmds operate on whole lines
1661 p = q = begin_line(p);
1662 for (cnt = 1; cnt < cmdcnt; cnt++) {
1663 q = next_line(q);
1664 }
1665 q = end_line(q);
1666 } else if (strchr("^%$0bBeEft", c)) {
1667 // These cmds operate on char positions
1668 do_cmd(c); // execute movement cmd
1669 q = dot;
1670 } else if (strchr("wW", c)) {
1671 do_cmd(c); // execute movement cmd
1672 // if we are at the next word's first char
1673 // step back one char
1674 // but check the possibilities when it is true
1675 if (dot > text && ((isspace(dot[-1]) && !isspace(dot[0]))
1676 || (ispunct(dot[-1]) && !ispunct(dot[0]))
1677 || (isalnum(dot[-1]) && !isalnum(dot[0]))))
1678 dot--; // move back off of next word
1679 if (dot > text && *dot == '\n')
1680 dot--; // stay off NL
1681 q = dot;
1682 } else if (strchr("H-k{", c)) {
1683 // these operate on multi-lines backwards
1684 q = end_line(dot); // find NL
1685 do_cmd(c); // execute movement cmd
1686 dot_begin();
1687 p = dot;
1688 } else if (strchr("L+j}\r\n", c)) {
1689 // these operate on multi-lines forwards
1690 p = begin_line(dot);
1691 do_cmd(c); // execute movement cmd
1692 dot_end(); // find NL
1693 q = dot;
1694 } else {
1695 c = 27; // error- return an ESC char
1696 //break;
1697 }
1698 *start = p;
1699 *stop = q;
1700 if (q < p) {
1701 *start = q;
1702 *stop = p;
1703 }
1704 dot = save_dot;
1705 return (c);
1706}
1707
1708static int st_test(Byte * p, int type, int dir, Byte * tested)
1709{
1710 Byte c, c0, ci;
1711 int test, inc;
1712
1713 inc = dir;
1714 c = c0 = p[0];
1715 ci = p[inc];
1716 test = 0;
1717
1718 if (type == S_BEFORE_WS) {
1719 c = ci;
1720 test = ((!isspace(c)) || c == '\n');
1721 }
1722 if (type == S_TO_WS) {
1723 c = c0;
1724 test = ((!isspace(c)) || c == '\n');
1725 }
1726 if (type == S_OVER_WS) {
1727 c = c0;
1728 test = ((isspace(c)));
1729 }
1730 if (type == S_END_PUNCT) {
1731 c = ci;
1732 test = ((ispunct(c)));
1733 }
1734 if (type == S_END_ALNUM) {
1735 c = ci;
1736 test = ((isalnum(c)) || c == '_');
1737 }
1738 *tested = c;
1739 return (test);
1740}
1741
1742static Byte *skip_thing(Byte * p, int linecnt, int dir, int type)
1743{
1744 Byte c;
1745
1746 while (st_test(p, type, dir, &c)) {
1747 // make sure we limit search to correct number of lines
1748 if (c == '\n' && --linecnt < 1)
1749 break;
1750 if (dir >= 0 && p >= end - 1)
1751 break;
1752 if (dir < 0 && p <= text)
1753 break;
1754 p += dir; // move to next char
1755 }
1756 return (p);
1757}
1758
1759// find matching char of pair () [] {}
1760static Byte *find_pair(Byte * p, Byte c)
1761{
1762 Byte match, *q;
1763 int dir, level;
1764
1765 match = ')';
1766 level = 1;
1767 dir = 1; // assume forward
1768 switch (c) {
1769 case '(':
1770 match = ')';
1771 break;
1772 case '[':
1773 match = ']';
1774 break;
1775 case '{':
1776 match = '}';
1777 break;
1778 case ')':
1779 match = '(';
1780 dir = -1;
1781 break;
1782 case ']':
1783 match = '[';
1784 dir = -1;
1785 break;
1786 case '}':
1787 match = '{';
1788 dir = -1;
1789 break;
1790 }
1791 for (q = p + dir; text <= q && q < end; q += dir) {
1792 // look for match, count levels of pairs (( ))
1793 if (*q == c)
1794 level++; // increase pair levels
1795 if (*q == match)
1796 level--; // reduce pair level
1797 if (level == 0)
1798 break; // found matching pair
1799 }
1800 if (level != 0)
1801 q = NULL; // indicate no match
1802 return (q);
1803}
1804
1805#ifdef CONFIG_FEATURE_VI_SETOPTS
1806// show the matching char of a pair, () [] {}
1807static void showmatching(Byte * p)
1808{
1809 Byte *q, *save_dot;
1810
1811 // we found half of a pair
1812 q = find_pair(p, *p); // get loc of matching char
1813 if (q == NULL) {
1814 indicate_error('3'); // no matching char
1815 } else {
1816 // "q" now points to matching pair
1817 save_dot = dot; // remember where we are
1818 dot = q; // go to new loc
1819 refresh(FALSE); // let the user see it
1820 (void) mysleep(40); // give user some time
1821 dot = save_dot; // go back to old loc
1822 refresh(FALSE);
1823 }
1824}
1825#endif /* CONFIG_FEATURE_VI_SETOPTS */
1826
1827// open a hole in text[]
1828static Byte *text_hole_make(Byte * p, int size) // at "p", make a 'size' byte hole
1829{
1830 Byte *src, *dest;
1831 int cnt;
1832
1833 if (size <= 0)
1834 goto thm0;
1835 src = p;
1836 dest = p + size;
1837 cnt = end - src; // the rest of buffer
1838 if (memmove(dest, src, cnt) != dest) {
1839 psbs("can't create room for new characters");
1840 }
1841 memset(p, ' ', size); // clear new hole
1842 end = end + size; // adjust the new END
1843 file_modified = TRUE; // has the file been modified
1844 thm0:
1845 return (p);
1846}
1847
1848// close a hole in text[]
1849static Byte *text_hole_delete(Byte * p, Byte * q) // delete "p" thru "q", inclusive
1850{
1851 Byte *src, *dest;
1852 int cnt, hole_size;
1853
1854 // move forwards, from beginning
1855 // assume p <= q
1856 src = q + 1;
1857 dest = p;
1858 if (q < p) { // they are backward- swap them
1859 src = p + 1;
1860 dest = q;
1861 }
1862 hole_size = q - p + 1;
1863 cnt = end - src;
1864 if (src < text || src > end)
1865 goto thd0;
1866 if (dest < text || dest >= end)
1867 goto thd0;
1868 if (src >= end)
1869 goto thd_atend; // just delete the end of the buffer
1870 if (memmove(dest, src, cnt) != dest) {
1871 psbs("can't delete the character");
1872 }
1873 thd_atend:
1874 end = end - hole_size; // adjust the new END
1875 if (dest >= end)
1876 dest = end - 1; // make sure dest in below end-1
1877 if (end <= text)
1878 dest = end = text; // keep pointers valid
1879 file_modified = TRUE; // has the file been modified
1880 thd0:
1881 return (dest);
1882}
1883
1884// copy text into register, then delete text.
1885// if dist <= 0, do not include, or go past, a NewLine
1886//
1887static Byte *yank_delete(Byte * start, Byte * stop, int dist, int yf)
1888{
1889 Byte *p;
1890
1891 // make sure start <= stop
1892 if (start > stop) {
1893 // they are backwards, reverse them
1894 p = start;
1895 start = stop;
1896 stop = p;
1897 }
1898 if (dist <= 0) {
1899 // we can not cross NL boundaries
1900 p = start;
1901 if (*p == '\n')
1902 return (p);
1903 // dont go past a NewLine
1904 for (; p + 1 <= stop; p++) {
1905 if (p[1] == '\n') {
1906 stop = p; // "stop" just before NewLine
1907 break;
1908 }
1909 }
1910 }
1911 p = start;
1912#ifdef CONFIG_FEATURE_VI_YANKMARK
1913 text_yank(start, stop, YDreg);
1914#endif /* CONFIG_FEATURE_VI_YANKMARK */
1915 if (yf == YANKDEL) {
1916 p = text_hole_delete(start, stop);
1917 } // delete lines
1918 return (p);
1919}
1920
1921static void show_help(void)
1922{
1923 puts("These features are available:"
1924#ifdef CONFIG_FEATURE_VI_SEARCH
1925 "\n\tPattern searches with / and ?"
1926#endif /* CONFIG_FEATURE_VI_SEARCH */
1927#ifdef CONFIG_FEATURE_VI_DOT_CMD
1928 "\n\tLast command repeat with \'.\'"
1929#endif /* CONFIG_FEATURE_VI_DOT_CMD */
1930#ifdef CONFIG_FEATURE_VI_YANKMARK
1931 "\n\tLine marking with 'x"
1932 "\n\tNamed buffers with \"x"
1933#endif /* CONFIG_FEATURE_VI_YANKMARK */
1934#ifdef CONFIG_FEATURE_VI_READONLY
1935 "\n\tReadonly if vi is called as \"view\""
1936 "\n\tReadonly with -R command line arg"
1937#endif /* CONFIG_FEATURE_VI_READONLY */
1938#ifdef CONFIG_FEATURE_VI_SET
1939 "\n\tSome colon mode commands with \':\'"
1940#endif /* CONFIG_FEATURE_VI_SET */
1941#ifdef CONFIG_FEATURE_VI_SETOPTS
1942 "\n\tSettable options with \":set\""
1943#endif /* CONFIG_FEATURE_VI_SETOPTS */
1944#ifdef CONFIG_FEATURE_VI_USE_SIGNALS
1945 "\n\tSignal catching- ^C"
1946 "\n\tJob suspend and resume with ^Z"
1947#endif /* CONFIG_FEATURE_VI_USE_SIGNALS */
1948#ifdef CONFIG_FEATURE_VI_WIN_RESIZE
1949 "\n\tAdapt to window re-sizes"
1950#endif /* CONFIG_FEATURE_VI_WIN_RESIZE */
1951 );
1952}
1953
1954static inline void print_literal(Byte * buf, Byte * s) // copy s to buf, convert unprintable
1955{
1956 Byte c, b[2];
1957
1958 b[1] = '\0';
1959 strcpy((char *) buf, ""); // init buf
1960 if (strlen((char *) s) <= 0)
1961 s = (Byte *) "(NULL)";
1962 for (; *s > '\0'; s++) {
1963 int c_is_no_print;
1964
1965 c = *s;
1966 c_is_no_print = c > 127 && !Isprint(c);
1967 if (c_is_no_print) {
1968 strcat((char *) buf, SOn);
1969 c = '.';
1970 }
1971 if (c < ' ' || c == 127) {
1972 strcat((char *) buf, "^");
1973 if(c == 127)
1974 c = '?';
1975 else
1976 c += '@';
1977 }
1978 b[0] = c;
1979 strcat((char *) buf, (char *) b);
1980 if (c_is_no_print)
1981 strcat((char *) buf, SOs);
1982 if (*s == '\n') {
1983 strcat((char *) buf, "$");
1984 }
1985 }
1986}
1987
1988#ifdef CONFIG_FEATURE_VI_DOT_CMD
1989static void start_new_cmd_q(Byte c)
1990{
1991 // release old cmd
1992 free(last_modifying_cmd);
1993 // get buffer for new cmd
1994 last_modifying_cmd = (Byte *) xmalloc(BUFSIZ);
1995 memset(last_modifying_cmd, '\0', BUFSIZ); // clear new cmd queue
1996 // if there is a current cmd count put it in the buffer first
1997 if (cmdcnt > 0)
1998 sprintf((char *) last_modifying_cmd, "%d", cmdcnt);
1999 // save char c onto queue
2000 last_modifying_cmd[strlen((char *) last_modifying_cmd)] = c;
2001 adding2q = 1;
2002 return;
2003}
2004
2005static void end_cmd_q(void)
2006{
2007#ifdef CONFIG_FEATURE_VI_YANKMARK
2008 YDreg = 26; // go back to default Yank/Delete reg
2009#endif /* CONFIG_FEATURE_VI_YANKMARK */
2010 adding2q = 0;
2011 return;
2012}
2013#endif /* CONFIG_FEATURE_VI_DOT_CMD */
2014
2015#if defined(CONFIG_FEATURE_VI_YANKMARK) || defined(CONFIG_FEATURE_VI_COLON) || defined(CONFIG_FEATURE_VI_CRASHME)
2016static Byte *string_insert(Byte * p, Byte * s) // insert the string at 'p'
2017{
2018 int cnt, i;
2019
2020 i = strlen((char *) s);
2021 p = text_hole_make(p, i);
2022 strncpy((char *) p, (char *) s, i);
2023 for (cnt = 0; *s != '\0'; s++) {
2024 if (*s == '\n')
2025 cnt++;
2026 }
2027#ifdef CONFIG_FEATURE_VI_YANKMARK
2028 psb("Put %d lines (%d chars) from [%c]", cnt, i, what_reg());
2029#endif /* CONFIG_FEATURE_VI_YANKMARK */
2030 return (p);
2031}
2032#endif /* CONFIG_FEATURE_VI_YANKMARK || CONFIG_FEATURE_VI_COLON || CONFIG_FEATURE_VI_CRASHME */
2033
2034#ifdef CONFIG_FEATURE_VI_YANKMARK
2035static Byte *text_yank(Byte * p, Byte * q, int dest) // copy text into a register
2036{
2037 Byte *t;
2038 int cnt;
2039
2040 if (q < p) { // they are backwards- reverse them
2041 t = q;
2042 q = p;
2043 p = t;
2044 }
2045 cnt = q - p + 1;
2046 t = reg[dest];
2047 free(t); // if already a yank register, free it
2048 t = (Byte *) xmalloc(cnt + 1); // get a new register
2049 memset(t, '\0', cnt + 1); // clear new text[]
2050 strncpy((char *) t, (char *) p, cnt); // copy text[] into bufer
2051 reg[dest] = t;
2052 return (p);
2053}
2054
2055static Byte what_reg(void)
2056{
2057 Byte c;
2058 int i;
2059
2060 i = 0;
2061 c = 'D'; // default to D-reg
2062 if (0 <= YDreg && YDreg <= 25)
2063 c = 'a' + (Byte) YDreg;
2064 if (YDreg == 26)
2065 c = 'D';
2066 if (YDreg == 27)
2067 c = 'U';
2068 return (c);
2069}
2070
2071static void check_context(Byte cmd)
2072{
2073 // A context is defined to be "modifying text"
2074 // Any modifying command establishes a new context.
2075
2076 if (dot < context_start || dot > context_end) {
2077 if (strchr((char *) modifying_cmds, cmd) != NULL) {
2078 // we are trying to modify text[]- make this the current context
2079 mark[27] = mark[26]; // move cur to prev
2080 mark[26] = dot; // move local to cur
2081 context_start = prev_line(prev_line(dot));
2082 context_end = next_line(next_line(dot));
2083 //loiter= start_loiter= now;
2084 }
2085 }
2086 return;
2087}
2088
2089static inline Byte *swap_context(Byte * p) // goto new context for '' command make this the current context
2090{
2091 Byte *tmp;
2092
2093 // the current context is in mark[26]
2094 // the previous context is in mark[27]
2095 // only swap context if other context is valid
2096 if (text <= mark[27] && mark[27] <= end - 1) {
2097 tmp = mark[27];
2098 mark[27] = mark[26];
2099 mark[26] = tmp;
2100 p = mark[26]; // where we are going- previous context
2101 context_start = prev_line(prev_line(prev_line(p)));
2102 context_end = next_line(next_line(next_line(p)));
2103 }
2104 return (p);
2105}
2106#endif /* CONFIG_FEATURE_VI_YANKMARK */
2107
2108static int isblnk(Byte c) // is the char a blank or tab
2109{
2110 return (c == ' ' || c == '\t');
2111}
2112
2113//----- Set terminal attributes --------------------------------
2114static void rawmode(void)
2115{
2116 tcgetattr(0, &term_orig);
2117 term_vi = term_orig;
2118 term_vi.c_lflag &= (~ICANON & ~ECHO); // leave ISIG ON- allow intr's
2119 term_vi.c_iflag &= (~IXON & ~ICRNL);
2120 term_vi.c_oflag &= (~ONLCR);
2121 term_vi.c_cc[VMIN] = 1;
2122 term_vi.c_cc[VTIME] = 0;
2123 erase_char = term_vi.c_cc[VERASE];
2124 tcsetattr(0, TCSANOW, &term_vi);
2125}
2126
2127static void cookmode(void)
2128{
2129 fflush(stdout);
2130 tcsetattr(0, TCSANOW, &term_orig);
2131}
2132
2133//----- Come here when we get a window resize signal ---------
2134#ifdef CONFIG_FEATURE_VI_USE_SIGNALS
2135static void winch_sig(int sig)
2136{
2137 signal(SIGWINCH, winch_sig);
2138#ifdef CONFIG_FEATURE_VI_WIN_RESIZE
2139 window_size_get(0);
2140#endif /* CONFIG_FEATURE_VI_WIN_RESIZE */
2141 new_screen(rows, columns); // get memory for virtual screen
2142 redraw(TRUE); // re-draw the screen
2143}
2144
2145//----- Come here when we get a continue signal -------------------
2146static void cont_sig(int sig)
2147{
2148 rawmode(); // terminal to "raw"
2149 *status_buffer = '\0'; // clear the status buffer
2150 redraw(TRUE); // re-draw the screen
2151
2152 signal(SIGTSTP, suspend_sig);
2153 signal(SIGCONT, SIG_DFL);
2154 kill(my_pid, SIGCONT);
2155}
2156
2157//----- Come here when we get a Suspend signal -------------------
2158static void suspend_sig(int sig)
2159{
2160 place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
2161 clear_to_eol(); // Erase to end of line
2162 cookmode(); // terminal to "cooked"
2163
2164 signal(SIGCONT, cont_sig);
2165 signal(SIGTSTP, SIG_DFL);
2166 kill(my_pid, SIGTSTP);
2167}
2168
2169//----- Come here when we get a signal ---------------------------
2170static void catch_sig(int sig)
2171{
2172 signal(SIGHUP, catch_sig);
2173 signal(SIGINT, catch_sig);
2174 signal(SIGTERM, catch_sig);
2175 signal(SIGALRM, catch_sig);
2176 if(sig)
2177 longjmp(restart, sig);
2178}
2179
2180//----- Come here when we get a core dump signal -----------------
2181static void core_sig(int sig)
2182{
2183 signal(SIGQUIT, core_sig);
2184 signal(SIGILL, core_sig);
2185 signal(SIGTRAP, core_sig);
2186 signal(SIGIOT, core_sig);
2187 signal(SIGABRT, core_sig);
2188 signal(SIGFPE, core_sig);
2189 signal(SIGBUS, core_sig);
2190 signal(SIGSEGV, core_sig);
2191#ifdef SIGSYS
2192 signal(SIGSYS, core_sig);
2193#endif
2194
2195 if(sig) { // signaled
2196 dot = bound_dot(dot); // make sure "dot" is valid
2197
2198 longjmp(restart, sig);
2199 }
2200}
2201#endif /* CONFIG_FEATURE_VI_USE_SIGNALS */
2202
2203static int mysleep(int hund) // sleep for 'h' 1/100 seconds
2204{
2205 // Don't hang- Wait 5/100 seconds- 1 Sec= 1000000
2206 fflush(stdout);
2207 FD_ZERO(&rfds);
2208 FD_SET(0, &rfds);
2209 tv.tv_sec = 0;
2210 tv.tv_usec = hund * 10000;
2211 select(1, &rfds, NULL, NULL, &tv);
2212 return (FD_ISSET(0, &rfds));
2213}
2214
2215static Byte readbuffer[BUFSIZ];
2216static int readed_for_parse;
2217
2218//----- IO Routines --------------------------------------------
2219static Byte readit(void) // read (maybe cursor) key from stdin
2220{
2221 Byte c;
2222 int n;
2223 struct esc_cmds {
2224 const char *seq;
2225 Byte val;
2226 };
2227
2228 static const struct esc_cmds esccmds[] = {
2229 {"OA", (Byte) VI_K_UP}, // cursor key Up
2230 {"OB", (Byte) VI_K_DOWN}, // cursor key Down
2231 {"OC", (Byte) VI_K_RIGHT}, // Cursor Key Right
2232 {"OD", (Byte) VI_K_LEFT}, // cursor key Left
2233 {"OH", (Byte) VI_K_HOME}, // Cursor Key Home
2234 {"OF", (Byte) VI_K_END}, // Cursor Key End
2235 {"[A", (Byte) VI_K_UP}, // cursor key Up
2236 {"[B", (Byte) VI_K_DOWN}, // cursor key Down
2237 {"[C", (Byte) VI_K_RIGHT}, // Cursor Key Right
2238 {"[D", (Byte) VI_K_LEFT}, // cursor key Left
2239 {"[H", (Byte) VI_K_HOME}, // Cursor Key Home
2240 {"[F", (Byte) VI_K_END}, // Cursor Key End
2241 {"[1~", (Byte) VI_K_HOME}, // Cursor Key Home
2242 {"[2~", (Byte) VI_K_INSERT}, // Cursor Key Insert
2243 {"[4~", (Byte) VI_K_END}, // Cursor Key End
2244 {"[5~", (Byte) VI_K_PAGEUP}, // Cursor Key Page Up
2245 {"[6~", (Byte) VI_K_PAGEDOWN}, // Cursor Key Page Down
2246 {"OP", (Byte) VI_K_FUN1}, // Function Key F1
2247 {"OQ", (Byte) VI_K_FUN2}, // Function Key F2
2248 {"OR", (Byte) VI_K_FUN3}, // Function Key F3
2249 {"OS", (Byte) VI_K_FUN4}, // Function Key F4
2250 {"[15~", (Byte) VI_K_FUN5}, // Function Key F5
2251 {"[17~", (Byte) VI_K_FUN6}, // Function Key F6
2252 {"[18~", (Byte) VI_K_FUN7}, // Function Key F7
2253 {"[19~", (Byte) VI_K_FUN8}, // Function Key F8
2254 {"[20~", (Byte) VI_K_FUN9}, // Function Key F9
2255 {"[21~", (Byte) VI_K_FUN10}, // Function Key F10
2256 {"[23~", (Byte) VI_K_FUN11}, // Function Key F11
2257 {"[24~", (Byte) VI_K_FUN12}, // Function Key F12
2258 {"[11~", (Byte) VI_K_FUN1}, // Function Key F1
2259 {"[12~", (Byte) VI_K_FUN2}, // Function Key F2
2260 {"[13~", (Byte) VI_K_FUN3}, // Function Key F3
2261 {"[14~", (Byte) VI_K_FUN4}, // Function Key F4
2262 };
2263
2264#define ESCCMDS_COUNT (sizeof(esccmds)/sizeof(struct esc_cmds))
2265
2266 (void) alarm(0); // turn alarm OFF while we wait for input
2267 fflush(stdout);
2268 n = readed_for_parse;
2269 // get input from User- are there already input chars in Q?
2270 if (n <= 0) {
2271 ri0:
2272 // the Q is empty, wait for a typed char
2273 n = read(0, readbuffer, BUFSIZ - 1);
2274 if (n < 0) {
2275 if (errno == EINTR)
2276 goto ri0; // interrupted sys call
2277 if (errno == EBADF)
2278 editing = 0;
2279 if (errno == EFAULT)
2280 editing = 0;
2281 if (errno == EINVAL)
2282 editing = 0;
2283 if (errno == EIO)
2284 editing = 0;
2285 errno = 0;
2286 }
2287 if(n <= 0)
2288 return 0; // error
2289 if (readbuffer[0] == 27) {
2290 // This is an ESC char. Is this Esc sequence?
2291 // Could be bare Esc key. See if there are any
2292 // more chars to read after the ESC. This would
2293 // be a Function or Cursor Key sequence.
2294 FD_ZERO(&rfds);
2295 FD_SET(0, &rfds);
2296 tv.tv_sec = 0;
2297 tv.tv_usec = 50000; // Wait 5/100 seconds- 1 Sec=1000000
2298
2299 // keep reading while there are input chars and room in buffer
2300 while (select(1, &rfds, NULL, NULL, &tv) > 0 && n <= (BUFSIZ - 5)) {
2301 // read the rest of the ESC string
2302 int r = read(0, (void *) (readbuffer + n), BUFSIZ - n);
2303 if (r > 0) {
2304 n += r;
2305 }
2306 }
2307 }
2308 readed_for_parse = n;
2309 }
2310 c = readbuffer[0];
2311 if(c == 27 && n > 1) {
2312 // Maybe cursor or function key?
2313 const struct esc_cmds *eindex;
2314
2315 for (eindex = esccmds; eindex < &esccmds[ESCCMDS_COUNT]; eindex++) {
2316 int cnt = strlen(eindex->seq);
2317
2318 if(n <= cnt)
2319 continue;
2320 if(strncmp(eindex->seq, (char *) readbuffer + 1, cnt))
2321 continue;
2322 // is a Cursor key- put derived value back into Q
2323 c = eindex->val;
2324 // for squeeze out the ESC sequence
2325 n = cnt + 1;
2326 break;
2327 }
2328 if(eindex == &esccmds[ESCCMDS_COUNT]) {
2329 /* defined ESC sequence not found, set only one ESC */
2330 n = 1;
2331 }
2332 } else {
2333 n = 1;
2334 }
2335 // remove key sequence from Q
2336 readed_for_parse -= n;
2337 memmove(readbuffer, readbuffer + n, BUFSIZ - n);
2338 (void) alarm(3); // we are done waiting for input, turn alarm ON
2339 return (c);
2340}
2341
2342//----- IO Routines --------------------------------------------
2343static Byte get_one_char()
2344{
2345 static Byte c;
2346
2347#ifdef CONFIG_FEATURE_VI_DOT_CMD
2348 // ! adding2q && ioq == 0 read()
2349 // ! adding2q && ioq != 0 *ioq
2350 // adding2q *last_modifying_cmd= read()
2351 if (!adding2q) {
2352 // we are not adding to the q.
2353 // but, we may be reading from a q
2354 if (ioq == 0) {
2355 // there is no current q, read from STDIN
2356 c = readit(); // get the users input
2357 } else {
2358 // there is a queue to get chars from first
2359 c = *ioq++;
2360 if (c == '\0') {
2361 // the end of the q, read from STDIN
2362 free(ioq_start);
2363 ioq_start = ioq = 0;
2364 c = readit(); // get the users input
2365 }
2366 }
2367 } else {
2368 // adding STDIN chars to q
2369 c = readit(); // get the users input
2370 if (last_modifying_cmd != 0) {
2371 int len = strlen((char *) last_modifying_cmd);
2372 if (len + 1 >= BUFSIZ) {
2373 psbs("last_modifying_cmd overrun");
2374 } else {
2375 // add new char to q
2376 last_modifying_cmd[len] = c;
2377 }
2378 }
2379 }
2380#else /* CONFIG_FEATURE_VI_DOT_CMD */
2381 c = readit(); // get the users input
2382#endif /* CONFIG_FEATURE_VI_DOT_CMD */
2383 return (c); // return the char, where ever it came from
2384}
2385
2386static Byte *get_input_line(Byte * prompt) // get input line- use "status line"
2387{
2388 Byte buf[BUFSIZ];
2389 Byte c;
2390 int i;
2391 static Byte *obufp = NULL;
2392
2393 strcpy((char *) buf, (char *) prompt);
2394 *status_buffer = '\0'; // clear the status buffer
2395 place_cursor(rows - 1, 0, FALSE); // go to Status line, bottom of screen
2396 clear_to_eol(); // clear the line
2397 write1(prompt); // write out the :, /, or ? prompt
2398
2399 for (i = strlen((char *) buf); i < BUFSIZ;) {
2400 c = get_one_char(); // read user input
2401 if (c == '\n' || c == '\r' || c == 27)
2402 break; // is this end of input
2403 if (c == erase_char) { // user wants to erase prev char
2404 i--; // backup to prev char
2405 buf[i] = '\0'; // erase the char
2406 buf[i + 1] = '\0'; // null terminate buffer
2407 write1("\b \b"); // erase char on screen
2408 if (i <= 0) { // user backs up before b-o-l, exit
2409 break;
2410 }
2411 } else {
2412 buf[i] = c; // save char in buffer
2413 buf[i + 1] = '\0'; // make sure buffer is null terminated
2414 putchar(c); // echo the char back to user
2415 i++;
2416 }
2417 }
2418 refresh(FALSE);
2419 free(obufp);
2420 obufp = (Byte *) bb_xstrdup((char *) buf);
2421 return (obufp);
2422}
2423
2424static int file_size(const Byte * fn) // what is the byte size of "fn"
2425{
2426 struct stat st_buf;
2427 int cnt, sr;
2428
2429 if (fn == 0 || strlen(fn) <= 0)
2430 return (-1);
2431 cnt = -1;
2432 sr = stat((char *) fn, &st_buf); // see if file exists
2433 if (sr >= 0) {
2434 cnt = (int) st_buf.st_size;
2435 }
2436 return (cnt);
2437}
2438
2439static int file_insert(Byte * fn, Byte * p, int size)
2440{
2441 int fd, cnt;
2442
2443 cnt = -1;
2444#ifdef CONFIG_FEATURE_VI_READONLY
2445 readonly = FALSE;
2446#endif /* CONFIG_FEATURE_VI_READONLY */
2447 if (fn == 0 || strlen((char*) fn) <= 0) {
2448 psbs("No filename given");
2449 goto fi0;
2450 }
2451 if (size == 0) {
2452 // OK- this is just a no-op
2453 cnt = 0;
2454 goto fi0;
2455 }
2456 if (size < 0) {
2457 psbs("Trying to insert a negative number (%d) of characters", size);
2458 goto fi0;
2459 }
2460 if (p < text || p > end) {
2461 psbs("Trying to insert file outside of memory");
2462 goto fi0;
2463 }
2464
2465 // see if we can open the file
2466#ifdef CONFIG_FEATURE_VI_READONLY
2467 if (vi_readonly) goto fi1; // do not try write-mode
2468#endif
2469 fd = open((char *) fn, O_RDWR); // assume read & write
2470 if (fd < 0) {
2471 // could not open for writing- maybe file is read only
2472#ifdef CONFIG_FEATURE_VI_READONLY
2473 fi1:
2474#endif
2475 fd = open((char *) fn, O_RDONLY); // try read-only
2476 if (fd < 0) {
2477 psbs("\"%s\" %s", fn, "could not open file");
2478 goto fi0;
2479 }
2480#ifdef CONFIG_FEATURE_VI_READONLY
2481 // got the file- read-only
2482 readonly = TRUE;
2483#endif /* CONFIG_FEATURE_VI_READONLY */
2484 }
2485 p = text_hole_make(p, size);
2486 cnt = read(fd, p, size);
2487 close(fd);
2488 if (cnt < 0) {
2489 cnt = -1;
2490 p = text_hole_delete(p, p + size - 1); // un-do buffer insert
2491 psbs("could not read file \"%s\"", fn);
2492 } else if (cnt < size) {
2493 // There was a partial read, shrink unused space text[]
2494 p = text_hole_delete(p + cnt, p + (size - cnt) - 1); // un-do buffer insert
2495 psbs("could not read all of file \"%s\"", fn);
2496 }
2497 if (cnt >= size)
2498 file_modified = TRUE;
2499 fi0:
2500 return (cnt);
2501}
2502
2503static int file_write(Byte * fn, Byte * first, Byte * last)
2504{
2505 int fd, cnt, charcnt;
2506
2507 if (fn == 0) {
2508 psbs("No current filename");
2509 return (-1);
2510 }
2511 charcnt = 0;
2512 // FIXIT- use the correct umask()
2513 fd = open((char *) fn, (O_WRONLY | O_CREAT | O_TRUNC), 0664);
2514 if (fd < 0)
2515 return (-1);
2516 cnt = last - first + 1;
2517 charcnt = write(fd, first, cnt);
2518 if (charcnt == cnt) {
2519 // good write
2520 //file_modified= FALSE; // the file has not been modified
2521 } else {
2522 charcnt = 0;
2523 }
2524 close(fd);
2525 return (charcnt);
2526}
2527
2528//----- Terminal Drawing ---------------------------------------
2529// The terminal is made up of 'rows' line of 'columns' columns.
2530// classically this would be 24 x 80.
2531// screen coordinates
2532// 0,0 ... 0,79
2533// 1,0 ... 1,79
2534// . ... .
2535// . ... .
2536// 22,0 ... 22,79
2537// 23,0 ... 23,79 status line
2538//
2539
2540//----- Move the cursor to row x col (count from 0, not 1) -------
2541static void place_cursor(int row, int col, int opti)
2542{
2543 char cm1[BUFSIZ];
2544 char *cm;
2545#ifdef CONFIG_FEATURE_VI_OPTIMIZE_CURSOR
2546 char cm2[BUFSIZ];
2547 Byte *screenp;
2548 // char cm3[BUFSIZ];
2549 int Rrow= last_row;
2550#endif /* CONFIG_FEATURE_VI_OPTIMIZE_CURSOR */
2551
2552 memset(cm1, '\0', BUFSIZ - 1); // clear the buffer
2553
2554 if (row < 0) row = 0;
2555 if (row >= rows) row = rows - 1;
2556 if (col < 0) col = 0;
2557 if (col >= columns) col = columns - 1;
2558
2559 //----- 1. Try the standard terminal ESC sequence
2560 sprintf((char *) cm1, CMrc, row + 1, col + 1);
2561 cm= cm1;
2562 if (! opti) goto pc0;
2563
2564#ifdef CONFIG_FEATURE_VI_OPTIMIZE_CURSOR
2565 //----- find the minimum # of chars to move cursor -------------
2566 //----- 2. Try moving with discreet chars (Newline, [back]space, ...)
2567 memset(cm2, '\0', BUFSIZ - 1); // clear the buffer
2568
2569 // move to the correct row
2570 while (row < Rrow) {
2571 // the cursor has to move up
2572 strcat(cm2, CMup);
2573 Rrow--;
2574 }
2575 while (row > Rrow) {
2576 // the cursor has to move down
2577 strcat(cm2, CMdown);
2578 Rrow++;
2579 }
2580
2581 // now move to the correct column
2582 strcat(cm2, "\r"); // start at col 0
2583 // just send out orignal source char to get to correct place
2584 screenp = &screen[row * columns]; // start of screen line
2585 strncat(cm2, screenp, col);
2586
2587 //----- 3. Try some other way of moving cursor
2588 //---------------------------------------------
2589
2590 // pick the shortest cursor motion to send out
2591 cm= cm1;
2592 if (strlen(cm2) < strlen(cm)) {
2593 cm= cm2;
2594 } /* else if (strlen(cm3) < strlen(cm)) {
2595 cm= cm3;
2596 } */
2597#endif /* CONFIG_FEATURE_VI_OPTIMIZE_CURSOR */
2598 pc0:
2599 write1(cm); // move the cursor
2600}
2601
2602//----- Erase from cursor to end of line -----------------------
2603static void clear_to_eol()
2604{
2605 write1(Ceol); // Erase from cursor to end of line
2606}
2607
2608//----- Erase from cursor to end of screen -----------------------
2609static void clear_to_eos()
2610{
2611 write1(Ceos); // Erase from cursor to end of screen
2612}
2613
2614//----- Start standout mode ------------------------------------
2615static void standout_start() // send "start reverse video" sequence
2616{
2617 write1(SOs); // Start reverse video mode
2618}
2619
2620//----- End standout mode --------------------------------------
2621static void standout_end() // send "end reverse video" sequence
2622{
2623 write1(SOn); // End reverse video mode
2624}
2625
2626//----- Flash the screen --------------------------------------
2627static void flash(int h)
2628{
2629 standout_start(); // send "start reverse video" sequence
2630 redraw(TRUE);
2631 (void) mysleep(h);
2632 standout_end(); // send "end reverse video" sequence
2633 redraw(TRUE);
2634}
2635
2636static void Indicate_Error(void)
2637{
2638#ifdef CONFIG_FEATURE_VI_CRASHME
2639 if (crashme > 0)
2640 return; // generate a random command
2641#endif /* CONFIG_FEATURE_VI_CRASHME */
2642 if (!err_method) {
2643 write1(bell); // send out a bell character
2644 } else {
2645 flash(10);
2646 }
2647}
2648
2649//----- Screen[] Routines --------------------------------------
2650//----- Erase the Screen[] memory ------------------------------
2651static void screen_erase()
2652{
2653 memset(screen, ' ', screensize); // clear new screen
2654}
2655
2656//----- Draw the status line at bottom of the screen -------------
2657static void show_status_line(void)
2658{
2659 static int last_cksum;
2660 int l, cnt, cksum;
2661
2662 edit_status();
2663 cnt = strlen((char *) status_buffer);
2664 for (cksum= l= 0; l < cnt; l++) { cksum += (int)(status_buffer[l]); }
2665 // don't write the status line unless it changes
2666 if (cnt > 0 && last_cksum != cksum) {
2667 last_cksum= cksum; // remember if we have seen this line
2668 place_cursor(rows - 1, 0, FALSE); // put cursor on status line
2669 write1(status_buffer);
2670 clear_to_eol();
2671 place_cursor(crow, ccol, FALSE); // put cursor back in correct place
2672 }
2673 fflush(stdout);
2674}
2675
2676//----- format the status buffer, the bottom line of screen ------
2677// print status buffer, with STANDOUT mode
2678static void psbs(const char *format, ...)
2679{
2680 va_list args;
2681
2682 va_start(args, format);
2683 strcpy((char *) status_buffer, SOs); // Terminal standout mode on
2684 vsprintf((char *) status_buffer + strlen((char *) status_buffer), format,
2685 args);
2686 strcat((char *) status_buffer, SOn); // Terminal standout mode off
2687 va_end(args);
2688
2689 return;
2690}
2691
2692// print status buffer
2693static void psb(const char *format, ...)
2694{
2695 va_list args;
2696
2697 va_start(args, format);
2698 vsprintf((char *) status_buffer, format, args);
2699 va_end(args);
2700 return;
2701}
2702
2703static void ni(Byte * s) // display messages
2704{
2705 Byte buf[BUFSIZ];
2706
2707 print_literal(buf, s);
2708 psbs("\'%s\' is not implemented", buf);
2709}
2710
2711static void edit_status(void) // show file status on status line
2712{
2713 int cur, tot, percent;
2714
2715 cur = count_lines(text, dot);
2716 tot = count_lines(text, end - 1);
2717 // current line percent
2718 // ------------- ~~ ----------
2719 // total lines 100
2720 if (tot > 0) {
2721 percent = (100 * cur) / tot;
2722 } else {
2723 cur = tot = 0;
2724 percent = 100;
2725 }
2726 psb("\"%s\""
2727#ifdef CONFIG_FEATURE_VI_READONLY
2728 "%s"
2729#endif /* CONFIG_FEATURE_VI_READONLY */
2730 "%s line %d of %d --%d%%--",
2731 (cfn != 0 ? (char *) cfn : "No file"),
2732#ifdef CONFIG_FEATURE_VI_READONLY
2733 ((vi_readonly || readonly) ? " [Read only]" : ""),
2734#endif /* CONFIG_FEATURE_VI_READONLY */
2735 (file_modified ? " [modified]" : ""),
2736 cur, tot, percent);
2737}
2738
2739//----- Force refresh of all Lines -----------------------------
2740static void redraw(int full_screen)
2741{
2742 place_cursor(0, 0, FALSE); // put cursor in correct place
2743 clear_to_eos(); // tel terminal to erase display
2744 screen_erase(); // erase the internal screen buffer
2745 refresh(full_screen); // this will redraw the entire display
2746}
2747
2748//----- Format a text[] line into a buffer ---------------------
2749static void format_line(Byte *dest, Byte *src, int li)
2750{
2751 int co;
2752 Byte c;
2753
2754 for (co= 0; co < MAX_SCR_COLS; co++) {
2755 c= ' '; // assume blank
2756 if (li > 0 && co == 0) {
2757 c = '~'; // not first line, assume Tilde
2758 }
2759 // are there chars in text[] and have we gone past the end
2760 if (text < end && src < end) {
2761 c = *src++;
2762 }
2763 if (c == '\n')
2764 break;
2765 if (c > 127 && !Isprint(c)) {
2766 c = '.';
2767 }
2768 if (c < ' ' || c == 127) {
2769 if (c == '\t') {
2770 c = ' ';
2771 // co % 8 != 7
2772 for (; (co % tabstop) != (tabstop - 1); co++) {
2773 dest[co] = c;
2774 }
2775 } else {
2776 dest[co++] = '^';
2777 if(c == 127)
2778 c = '?';
2779 else
2780 c += '@'; // make it visible
2781 }
2782 }
2783 // the co++ is done here so that the column will
2784 // not be overwritten when we blank-out the rest of line
2785 dest[co] = c;
2786 if (src >= end)
2787 break;
2788 }
2789}
2790
2791//----- Refresh the changed screen lines -----------------------
2792// Copy the source line from text[] into the buffer and note
2793// if the current screenline is different from the new buffer.
2794// If they differ then that line needs redrawing on the terminal.
2795//
2796static void refresh(int full_screen)
2797{
2798 static int old_offset;
2799 int li, changed;
2800 Byte buf[MAX_SCR_COLS];
2801 Byte *tp, *sp; // pointer into text[] and screen[]
2802#ifdef CONFIG_FEATURE_VI_OPTIMIZE_CURSOR
2803 int last_li= -2; // last line that changed- for optimizing cursor movement
2804#endif /* CONFIG_FEATURE_VI_OPTIMIZE_CURSOR */
2805
2806#ifdef CONFIG_FEATURE_VI_WIN_RESIZE
2807 window_size_get(0);
2808#endif /* CONFIG_FEATURE_VI_WIN_RESIZE */
2809 sync_cursor(dot, &crow, &ccol); // where cursor will be (on "dot")
2810 tp = screenbegin; // index into text[] of top line
2811
2812 // compare text[] to screen[] and mark screen[] lines that need updating
2813 for (li = 0; li < rows - 1; li++) {
2814 int cs, ce; // column start & end
2815 memset(buf, ' ', MAX_SCR_COLS); // blank-out the buffer
2816 buf[MAX_SCR_COLS-1] = 0; // NULL terminate the buffer
2817 // format current text line into buf
2818 format_line(buf, tp, li);
2819
2820 // skip to the end of the current text[] line
2821 while (tp < end && *tp++ != '\n') /*no-op*/ ;
2822
2823 // see if there are any changes between vitual screen and buf
2824 changed = FALSE; // assume no change
2825 cs= 0;
2826 ce= columns-1;
2827 sp = &screen[li * columns]; // start of screen line
2828 if (full_screen) {
2829 // force re-draw of every single column from 0 - columns-1
2830 goto re0;
2831 }
2832 // compare newly formatted buffer with virtual screen
2833 // look forward for first difference between buf and screen
2834 for ( ; cs <= ce; cs++) {
2835 if (buf[cs + offset] != sp[cs]) {
2836 changed = TRUE; // mark for redraw
2837 break;
2838 }
2839 }
2840
2841 // look backward for last difference between buf and screen
2842 for ( ; ce >= cs; ce--) {
2843 if (buf[ce + offset] != sp[ce]) {
2844 changed = TRUE; // mark for redraw
2845 break;
2846 }
2847 }
2848 // now, cs is index of first diff, and ce is index of last diff
2849
2850 // if horz offset has changed, force a redraw
2851 if (offset != old_offset) {
2852 re0:
2853 changed = TRUE;
2854 }
2855
2856 // make a sanity check of columns indexes
2857 if (cs < 0) cs= 0;
2858 if (ce > columns-1) ce= columns-1;
2859 if (cs > ce) { cs= 0; ce= columns-1; }
2860 // is there a change between vitual screen and buf
2861 if (changed) {
2862 // copy changed part of buffer to virtual screen
2863 memmove(sp+cs, buf+(cs+offset), ce-cs+1);
2864
2865 // move cursor to column of first change
2866 if (offset != old_offset) {
2867 // opti_cur_move is still too stupid
2868 // to handle offsets correctly
2869 place_cursor(li, cs, FALSE);
2870 } else {
2871#ifdef CONFIG_FEATURE_VI_OPTIMIZE_CURSOR
2872 // if this just the next line
2873 // try to optimize cursor movement
2874 // otherwise, use standard ESC sequence
2875 place_cursor(li, cs, li == (last_li+1) ? TRUE : FALSE);
2876 last_li= li;
2877#else /* CONFIG_FEATURE_VI_OPTIMIZE_CURSOR */
2878 place_cursor(li, cs, FALSE); // use standard ESC sequence
2879#endif /* CONFIG_FEATURE_VI_OPTIMIZE_CURSOR */
2880 }
2881
2882 // write line out to terminal
2883 {
2884 int nic = ce-cs+1;
2885 char *out = sp+cs;
2886
2887 while(nic-- > 0) {
2888 putchar(*out);
2889 out++;
2890 }
2891 }
2892#ifdef CONFIG_FEATURE_VI_OPTIMIZE_CURSOR
2893 last_row = li;
2894#endif /* CONFIG_FEATURE_VI_OPTIMIZE_CURSOR */
2895 }
2896 }
2897
2898#ifdef CONFIG_FEATURE_VI_OPTIMIZE_CURSOR
2899 place_cursor(crow, ccol, (crow == last_row) ? TRUE : FALSE);
2900 last_row = crow;
2901#else
2902 place_cursor(crow, ccol, FALSE);
2903#endif /* CONFIG_FEATURE_VI_OPTIMIZE_CURSOR */
2904
2905 if (offset != old_offset)
2906 old_offset = offset;
2907}
2908
2909//---------------------------------------------------------------------
2910//----- the Ascii Chart -----------------------------------------------
2911//
2912// 00 nul 01 soh 02 stx 03 etx 04 eot 05 enq 06 ack 07 bel
2913// 08 bs 09 ht 0a nl 0b vt 0c np 0d cr 0e so 0f si
2914// 10 dle 11 dc1 12 dc2 13 dc3 14 dc4 15 nak 16 syn 17 etb
2915// 18 can 19 em 1a sub 1b esc 1c fs 1d gs 1e rs 1f us
2916// 20 sp 21 ! 22 " 23 # 24 $ 25 % 26 & 27 '
2917// 28 ( 29 ) 2a * 2b + 2c , 2d - 2e . 2f /
2918// 30 0 31 1 32 2 33 3 34 4 35 5 36 6 37 7
2919// 38 8 39 9 3a : 3b ; 3c < 3d = 3e > 3f ?
2920// 40 @ 41 A 42 B 43 C 44 D 45 E 46 F 47 G
2921// 48 H 49 I 4a J 4b K 4c L 4d M 4e N 4f O
2922// 50 P 51 Q 52 R 53 S 54 T 55 U 56 V 57 W
2923// 58 X 59 Y 5a Z 5b [ 5c \ 5d ] 5e ^ 5f _
2924// 60 ` 61 a 62 b 63 c 64 d 65 e 66 f 67 g
2925// 68 h 69 i 6a j 6b k 6c l 6d m 6e n 6f o
2926// 70 p 71 q 72 r 73 s 74 t 75 u 76 v 77 w
2927// 78 x 79 y 7a z 7b { 7c | 7d } 7e ~ 7f del
2928//---------------------------------------------------------------------
2929
2930//----- Execute a Vi Command -----------------------------------
2931static void do_cmd(Byte c)
2932{
2933 Byte c1, *p, *q, *msg, buf[9], *save_dot;
2934 int cnt, i, j, dir, yf;
2935
2936 c1 = c; // quiet the compiler
2937 cnt = yf = dir = 0; // quiet the compiler
2938 p = q = save_dot = msg = buf; // quiet the compiler
2939 memset(buf, '\0', 9); // clear buf
2940
2941 /* if this is a cursor key, skip these checks */
2942 switch (c) {
2943 case VI_K_UP:
2944 case VI_K_DOWN:
2945 case VI_K_LEFT:
2946 case VI_K_RIGHT:
2947 case VI_K_HOME:
2948 case VI_K_END:
2949 case VI_K_PAGEUP:
2950 case VI_K_PAGEDOWN:
2951 goto key_cmd_mode;
2952 }
2953
2954 if (cmd_mode == 2) {
2955 // flip-flop Insert/Replace mode
2956 if (c == VI_K_INSERT) goto dc_i;
2957 // we are 'R'eplacing the current *dot with new char
2958 if (*dot == '\n') {
2959 // don't Replace past E-o-l
2960 cmd_mode = 1; // convert to insert
2961 } else {
2962 if (1 <= c || Isprint(c)) {
2963 if (c != 27)
2964 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
2965 dot = char_insert(dot, c); // insert new char
2966 }
2967 goto dc1;
2968 }
2969 }
2970 if (cmd_mode == 1) {
2971 // hitting "Insert" twice means "R" replace mode
2972 if (c == VI_K_INSERT) goto dc5;
2973 // insert the char c at "dot"
2974 if (1 <= c || Isprint(c)) {
2975 dot = char_insert(dot, c);
2976 }
2977 goto dc1;
2978 }
2979
2980key_cmd_mode:
2981 switch (c) {
2982 //case 0x01: // soh
2983 //case 0x09: // ht
2984 //case 0x0b: // vt
2985 //case 0x0e: // so
2986 //case 0x0f: // si
2987 //case 0x10: // dle
2988 //case 0x11: // dc1
2989 //case 0x13: // dc3
2990#ifdef CONFIG_FEATURE_VI_CRASHME
2991 case 0x14: // dc4 ctrl-T
2992 crashme = (crashme == 0) ? 1 : 0;
2993 break;
2994#endif /* CONFIG_FEATURE_VI_CRASHME */
2995 //case 0x16: // syn
2996 //case 0x17: // etb
2997 //case 0x18: // can
2998 //case 0x1c: // fs
2999 //case 0x1d: // gs
3000 //case 0x1e: // rs
3001 //case 0x1f: // us
3002 //case '!': // !-
3003 //case '#': // #-
3004 //case '&': // &-
3005 //case '(': // (-
3006 //case ')': // )-
3007 //case '*': // *-
3008 //case ',': // ,-
3009 //case '=': // =-
3010 //case '@': // @-
3011 //case 'F': // F-
3012 //case 'K': // K-
3013 //case 'Q': // Q-
3014 //case 'S': // S-
3015 //case 'T': // T-
3016 //case 'V': // V-
3017 //case '[': // [-
3018 //case '\\': // \-
3019 //case ']': // ]-
3020 //case '_': // _-
3021 //case '`': // `-
3022 //case 'g': // g-
3023 //case 'u': // u- FIXME- there is no undo
3024 //case 'v': // v-
3025 default: // unrecognised command
3026 buf[0] = c;
3027 buf[1] = '\0';
3028 if (c < ' ') {
3029 buf[0] = '^';
3030 buf[1] = c + '@';
3031 buf[2] = '\0';
3032 }
3033 ni((Byte *) buf);
3034 end_cmd_q(); // stop adding to q
3035 case 0x00: // nul- ignore
3036 break;
3037 case 2: // ctrl-B scroll up full screen
3038 case VI_K_PAGEUP: // Cursor Key Page Up
3039 dot_scroll(rows - 2, -1);
3040 break;
3041#ifdef CONFIG_FEATURE_VI_USE_SIGNALS
3042 case 0x03: // ctrl-C interrupt
3043 longjmp(restart, 1);
3044 break;
3045 case 26: // ctrl-Z suspend
3046 suspend_sig(SIGTSTP);
3047 break;
3048#endif /* CONFIG_FEATURE_VI_USE_SIGNALS */
3049 case 4: // ctrl-D scroll down half screen
3050 dot_scroll((rows - 2) / 2, 1);
3051 break;
3052 case 5: // ctrl-E scroll down one line
3053 dot_scroll(1, 1);
3054 break;
3055 case 6: // ctrl-F scroll down full screen
3056 case VI_K_PAGEDOWN: // Cursor Key Page Down
3057 dot_scroll(rows - 2, 1);
3058 break;
3059 case 7: // ctrl-G show current status
3060 edit_status();
3061 break;
3062 case 'h': // h- move left
3063 case VI_K_LEFT: // cursor key Left
3064 case 8: // ctrl-H- move left (This may be ERASE char)
3065 case 127: // DEL- move left (This may be ERASE char)
3066 if (cmdcnt-- > 1) {
3067 do_cmd(c);
3068 } // repeat cnt
3069 dot_left();
3070 break;
3071 case 10: // Newline ^J
3072 case 'j': // j- goto next line, same col
3073 case VI_K_DOWN: // cursor key Down
3074 if (cmdcnt-- > 1) {
3075 do_cmd(c);
3076 } // repeat cnt
3077 dot_next(); // go to next B-o-l
3078 dot = move_to_col(dot, ccol + offset); // try stay in same col
3079 break;
3080 case 12: // ctrl-L force redraw whole screen
3081 case 18: // ctrl-R force redraw
3082 place_cursor(0, 0, FALSE); // put cursor in correct place
3083 clear_to_eos(); // tel terminal to erase display
3084 (void) mysleep(10);
3085 screen_erase(); // erase the internal screen buffer
3086 refresh(TRUE); // this will redraw the entire display
3087 break;
3088 case 13: // Carriage Return ^M
3089 case '+': // +- goto next line
3090 if (cmdcnt-- > 1) {
3091 do_cmd(c);
3092 } // repeat cnt
3093 dot_next();
3094 dot_skip_over_ws();
3095 break;
3096 case 21: // ctrl-U scroll up half screen
3097 dot_scroll((rows - 2) / 2, -1);
3098 break;
3099 case 25: // ctrl-Y scroll up one line
3100 dot_scroll(1, -1);
3101 break;
3102 case 27: // esc
3103 if (cmd_mode == 0)
3104 indicate_error(c);
3105 cmd_mode = 0; // stop insrting
3106 end_cmd_q();
3107 *status_buffer = '\0'; // clear status buffer
3108 break;
3109 case ' ': // move right
3110 case 'l': // move right
3111 case VI_K_RIGHT: // Cursor Key Right
3112 if (cmdcnt-- > 1) {
3113 do_cmd(c);
3114 } // repeat cnt
3115 dot_right();
3116 break;
3117#ifdef CONFIG_FEATURE_VI_YANKMARK
3118 case '"': // "- name a register to use for Delete/Yank
3119 c1 = get_one_char();
3120 c1 = tolower(c1);
3121 if (islower(c1)) {
3122 YDreg = c1 - 'a';
3123 } else {
3124 indicate_error(c);
3125 }
3126 break;
3127 case '\'': // '- goto a specific mark
3128 c1 = get_one_char();
3129 c1 = tolower(c1);
3130 if (islower(c1)) {
3131 c1 = c1 - 'a';
3132 // get the b-o-l
3133 q = mark[(int) c1];
3134 if (text <= q && q < end) {
3135 dot = q;
3136 dot_begin(); // go to B-o-l
3137 dot_skip_over_ws();
3138 }
3139 } else if (c1 == '\'') { // goto previous context
3140 dot = swap_context(dot); // swap current and previous context
3141 dot_begin(); // go to B-o-l
3142 dot_skip_over_ws();
3143 } else {
3144 indicate_error(c);
3145 }
3146 break;
3147 case 'm': // m- Mark a line
3148 // this is really stupid. If there are any inserts or deletes
3149 // between text[0] and dot then this mark will not point to the
3150 // correct location! It could be off by many lines!
3151 // Well..., at least its quick and dirty.
3152 c1 = get_one_char();
3153 c1 = tolower(c1);
3154 if (islower(c1)) {
3155 c1 = c1 - 'a';
3156 // remember the line
3157 mark[(int) c1] = dot;
3158 } else {
3159 indicate_error(c);
3160 }
3161 break;
3162 case 'P': // P- Put register before
3163 case 'p': // p- put register after
3164 p = reg[YDreg];
3165 if (p == 0) {
3166 psbs("Nothing in register %c", what_reg());
3167 break;
3168 }
3169 // are we putting whole lines or strings
3170 if (strchr((char *) p, '\n') != NULL) {
3171 if (c == 'P') {
3172 dot_begin(); // putting lines- Put above
3173 }
3174 if (c == 'p') {
3175 // are we putting after very last line?
3176 if (end_line(dot) == (end - 1)) {
3177 dot = end; // force dot to end of text[]
3178 } else {
3179 dot_next(); // next line, then put before
3180 }
3181 }
3182 } else {
3183 if (c == 'p')
3184 dot_right(); // move to right, can move to NL
3185 }
3186 dot = string_insert(dot, p); // insert the string
3187 end_cmd_q(); // stop adding to q
3188 break;
3189 case 'U': // U- Undo; replace current line with original version
3190 if (reg[Ureg] != 0) {
3191 p = begin_line(dot);
3192 q = end_line(dot);
3193 p = text_hole_delete(p, q); // delete cur line
3194 p = string_insert(p, reg[Ureg]); // insert orig line
3195 dot = p;
3196 dot_skip_over_ws();
3197 }
3198 break;
3199#endif /* CONFIG_FEATURE_VI_YANKMARK */
3200 case '$': // $- goto end of line
3201 case VI_K_END: // Cursor Key End
3202 if (cmdcnt-- > 1) {
3203 do_cmd(c);
3204 } // repeat cnt
3205 dot = end_line(dot);
3206 break;
3207 case '%': // %- find matching char of pair () [] {}
3208 for (q = dot; q < end && *q != '\n'; q++) {
3209 if (strchr("()[]{}", *q) != NULL) {
3210 // we found half of a pair
3211 p = find_pair(q, *q);
3212 if (p == NULL) {
3213 indicate_error(c);
3214 } else {
3215 dot = p;
3216 }
3217 break;
3218 }
3219 }
3220 if (*q == '\n')
3221 indicate_error(c);
3222 break;
3223 case 'f': // f- forward to a user specified char
3224 last_forward_char = get_one_char(); // get the search char
3225 //
3226 // dont separate these two commands. 'f' depends on ';'
3227 //
3228 //**** fall thru to ... 'i'
3229 case ';': // ;- look at rest of line for last forward char
3230 if (cmdcnt-- > 1) {
3231 do_cmd(';');
3232 } // repeat cnt
3233 if (last_forward_char == 0) break;
3234 q = dot + 1;
3235 while (q < end - 1 && *q != '\n' && *q != last_forward_char) {
3236 q++;
3237 }
3238 if (*q == last_forward_char)
3239 dot = q;
3240 break;
3241 case '-': // -- goto prev line
3242 if (cmdcnt-- > 1) {
3243 do_cmd(c);
3244 } // repeat cnt
3245 dot_prev();
3246 dot_skip_over_ws();
3247 break;
3248#ifdef CONFIG_FEATURE_VI_DOT_CMD
3249 case '.': // .- repeat the last modifying command
3250 // Stuff the last_modifying_cmd back into stdin
3251 // and let it be re-executed.
3252 if (last_modifying_cmd != 0) {
3253 ioq = ioq_start = (Byte *) bb_xstrdup((char *) last_modifying_cmd);
3254 }
3255 break;
3256#endif /* CONFIG_FEATURE_VI_DOT_CMD */
3257#ifdef CONFIG_FEATURE_VI_SEARCH
3258 case '?': // /- search for a pattern
3259 case '/': // /- search for a pattern
3260 buf[0] = c;
3261 buf[1] = '\0';
3262 q = get_input_line(buf); // get input line- use "status line"
3263 if (strlen((char *) q) == 1)
3264 goto dc3; // if no pat re-use old pat
3265 if (strlen((char *) q) > 1) { // new pat- save it and find
3266 // there is a new pat
3267 free(last_search_pattern);
3268 last_search_pattern = (Byte *) bb_xstrdup((char *) q);
3269 goto dc3; // now find the pattern
3270 }
3271 // user changed mind and erased the "/"- do nothing
3272 break;
3273 case 'N': // N- backward search for last pattern
3274 if (cmdcnt-- > 1) {
3275 do_cmd(c);
3276 } // repeat cnt
3277 dir = BACK; // assume BACKWARD search
3278 p = dot - 1;
3279 if (last_search_pattern[0] == '?') {
3280 dir = FORWARD;
3281 p = dot + 1;
3282 }
3283 goto dc4; // now search for pattern
3284 break;
3285 case 'n': // n- repeat search for last pattern
3286 // search rest of text[] starting at next char
3287 // if search fails return orignal "p" not the "p+1" address
3288 if (cmdcnt-- > 1) {
3289 do_cmd(c);
3290 } // repeat cnt
3291 dc3:
3292 if (last_search_pattern == 0) {
3293 msg = (Byte *) "No previous regular expression";
3294 goto dc2;
3295 }
3296 if (last_search_pattern[0] == '/') {
3297 dir = FORWARD; // assume FORWARD search
3298 p = dot + 1;
3299 }
3300 if (last_search_pattern[0] == '?') {
3301 dir = BACK;
3302 p = dot - 1;
3303 }
3304 dc4:
3305 q = char_search(p, last_search_pattern + 1, dir, FULL);
3306 if (q != NULL) {
3307 dot = q; // good search, update "dot"
3308 msg = (Byte *) "";
3309 goto dc2;
3310 }
3311 // no pattern found between "dot" and "end"- continue at top
3312 p = text;
3313 if (dir == BACK) {
3314 p = end - 1;
3315 }
3316 q = char_search(p, last_search_pattern + 1, dir, FULL);
3317 if (q != NULL) { // found something
3318 dot = q; // found new pattern- goto it
3319 msg = (Byte *) "search hit BOTTOM, continuing at TOP";
3320 if (dir == BACK) {
3321 msg = (Byte *) "search hit TOP, continuing at BOTTOM";
3322 }
3323 } else {
3324 msg = (Byte *) "Pattern not found";
3325 }
3326 dc2:
3327 psbs("%s", msg);
3328 break;
3329 case '{': // {- move backward paragraph
3330 q = char_search(dot, (Byte *) "\n\n", BACK, FULL);
3331 if (q != NULL) { // found blank line
3332 dot = next_line(q); // move to next blank line
3333 }
3334 break;
3335 case '}': // }- move forward paragraph
3336 q = char_search(dot, (Byte *) "\n\n", FORWARD, FULL);
3337 if (q != NULL) { // found blank line
3338 dot = next_line(q); // move to next blank line
3339 }
3340 break;
3341#endif /* CONFIG_FEATURE_VI_SEARCH */
3342 case '0': // 0- goto begining of line
3343 case '1': // 1-
3344 case '2': // 2-
3345 case '3': // 3-
3346 case '4': // 4-
3347 case '5': // 5-
3348 case '6': // 6-
3349 case '7': // 7-
3350 case '8': // 8-
3351 case '9': // 9-
3352 if (c == '0' && cmdcnt < 1) {
3353 dot_begin(); // this was a standalone zero
3354 } else {
3355 cmdcnt = cmdcnt * 10 + (c - '0'); // this 0 is part of a number
3356 }
3357 break;
3358 case ':': // :- the colon mode commands
3359 p = get_input_line((Byte *) ":"); // get input line- use "status line"
3360#ifdef CONFIG_FEATURE_VI_COLON
3361 colon(p); // execute the command
3362#else /* CONFIG_FEATURE_VI_COLON */
3363 if (*p == ':')
3364 p++; // move past the ':'
3365 cnt = strlen((char *) p);
3366 if (cnt <= 0)
3367 break;
3368 if (strncasecmp((char *) p, "quit", cnt) == 0 ||
3369 strncasecmp((char *) p, "q!", cnt) == 0) { // delete lines
3370 if (file_modified && p[1] != '!') {
3371 psbs("No write since last change (:quit! overrides)");
3372 } else {
3373 editing = 0;
3374 }
3375 } else if (strncasecmp((char *) p, "write", cnt) == 0 ||
3376 strncasecmp((char *) p, "wq", cnt) == 0 ||
3377 strncasecmp((char *) p, "x", cnt) == 0) {
3378 cnt = file_write(cfn, text, end - 1);
3379 file_modified = FALSE;
3380 psb("\"%s\" %dL, %dC", cfn, count_lines(text, end - 1), cnt);
3381 if (p[0] == 'x' || p[1] == 'q') {
3382 editing = 0;
3383 }
3384 } else if (strncasecmp((char *) p, "file", cnt) == 0 ) {
3385 edit_status(); // show current file status
3386 } else if (sscanf((char *) p, "%d", &j) > 0) {
3387 dot = find_line(j); // go to line # j
3388 dot_skip_over_ws();
3389 } else { // unrecognised cmd
3390 ni((Byte *) p);
3391 }
3392#endif /* CONFIG_FEATURE_VI_COLON */
3393 break;
3394 case '<': // <- Left shift something
3395 case '>': // >- Right shift something
3396 cnt = count_lines(text, dot); // remember what line we are on
3397 c1 = get_one_char(); // get the type of thing to delete
3398 find_range(&p, &q, c1);
3399 (void) yank_delete(p, q, 1, YANKONLY); // save copy before change
3400 p = begin_line(p);
3401 q = end_line(q);
3402 i = count_lines(p, q); // # of lines we are shifting
3403 for ( ; i > 0; i--, p = next_line(p)) {
3404 if (c == '<') {
3405 // shift left- remove tab or 8 spaces
3406 if (*p == '\t') {
3407 // shrink buffer 1 char
3408 (void) text_hole_delete(p, p);
3409 } else if (*p == ' ') {
3410 // we should be calculating columns, not just SPACE
3411 for (j = 0; *p == ' ' && j < tabstop; j++) {
3412 (void) text_hole_delete(p, p);
3413 }
3414 }
3415 } else if (c == '>') {
3416 // shift right -- add tab or 8 spaces
3417 (void) char_insert(p, '\t');
3418 }
3419 }
3420 dot = find_line(cnt); // what line were we on
3421 dot_skip_over_ws();
3422 end_cmd_q(); // stop adding to q
3423 break;
3424 case 'A': // A- append at e-o-l
3425 dot_end(); // go to e-o-l
3426 //**** fall thru to ... 'a'
3427 case 'a': // a- append after current char
3428 if (*dot != '\n')
3429 dot++;
3430 goto dc_i;
3431 break;
3432 case 'B': // B- back a blank-delimited Word
3433 case 'E': // E- end of a blank-delimited word
3434 case 'W': // W- forward a blank-delimited word
3435 if (cmdcnt-- > 1) {
3436 do_cmd(c);
3437 } // repeat cnt
3438 dir = FORWARD;
3439 if (c == 'B')
3440 dir = BACK;
3441 if (c == 'W' || isspace(dot[dir])) {
3442 dot = skip_thing(dot, 1, dir, S_TO_WS);
3443 dot = skip_thing(dot, 2, dir, S_OVER_WS);
3444 }
3445 if (c != 'W')
3446 dot = skip_thing(dot, 1, dir, S_BEFORE_WS);
3447 break;
3448 case 'C': // C- Change to e-o-l
3449 case 'D': // D- delete to e-o-l
3450 save_dot = dot;
3451 dot = dollar_line(dot); // move to before NL
3452 // copy text into a register and delete
3453 dot = yank_delete(save_dot, dot, 0, YANKDEL); // delete to e-o-l
3454 if (c == 'C')
3455 goto dc_i; // start inserting
3456#ifdef CONFIG_FEATURE_VI_DOT_CMD
3457 if (c == 'D')
3458 end_cmd_q(); // stop adding to q
3459#endif /* CONFIG_FEATURE_VI_DOT_CMD */
3460 break;
3461 case 'G': // G- goto to a line number (default= E-O-F)
3462 dot = end - 1; // assume E-O-F
3463 if (cmdcnt > 0) {
3464 dot = find_line(cmdcnt); // what line is #cmdcnt
3465 }
3466 dot_skip_over_ws();
3467 break;
3468 case 'H': // H- goto top line on screen
3469 dot = screenbegin;
3470 if (cmdcnt > (rows - 1)) {
3471 cmdcnt = (rows - 1);
3472 }
3473 if (cmdcnt-- > 1) {
3474 do_cmd('+');
3475 } // repeat cnt
3476 dot_skip_over_ws();
3477 break;
3478 case 'I': // I- insert before first non-blank
3479 dot_begin(); // 0
3480 dot_skip_over_ws();
3481 //**** fall thru to ... 'i'
3482 case 'i': // i- insert before current char
3483 case VI_K_INSERT: // Cursor Key Insert
3484 dc_i:
3485 cmd_mode = 1; // start insrting
3486 psb("-- Insert --");
3487 break;
3488 case 'J': // J- join current and next lines together
3489 if (cmdcnt-- > 2) {
3490 do_cmd(c);
3491 } // repeat cnt
3492 dot_end(); // move to NL
3493 if (dot < end - 1) { // make sure not last char in text[]
3494 *dot++ = ' '; // replace NL with space
3495 while (isblnk(*dot)) { // delete leading WS
3496 dot_delete();
3497 }
3498 }
3499 end_cmd_q(); // stop adding to q
3500 break;
3501 case 'L': // L- goto bottom line on screen
3502 dot = end_screen();
3503 if (cmdcnt > (rows - 1)) {
3504 cmdcnt = (rows - 1);
3505 }
3506 if (cmdcnt-- > 1) {
3507 do_cmd('-');
3508 } // repeat cnt
3509 dot_begin();
3510 dot_skip_over_ws();
3511 break;
3512 case 'M': // M- goto middle line on screen
3513 dot = screenbegin;
3514 for (cnt = 0; cnt < (rows-1) / 2; cnt++)
3515 dot = next_line(dot);
3516 break;
3517 case 'O': // O- open a empty line above
3518 // 0i\n ESC -i
3519 p = begin_line(dot);
3520 if (p[-1] == '\n') {
3521 dot_prev();
3522 case 'o': // o- open a empty line below; Yes, I know it is in the middle of the "if (..."
3523 dot_end();
3524 dot = char_insert(dot, '\n');
3525 } else {
3526 dot_begin(); // 0
3527 dot = char_insert(dot, '\n'); // i\n ESC
3528 dot_prev(); // -
3529 }
3530 goto dc_i;
3531 break;
3532 case 'R': // R- continuous Replace char
3533 dc5:
3534 cmd_mode = 2;
3535 psb("-- Replace --");
3536 break;
3537 case 'X': // X- delete char before dot
3538 case 'x': // x- delete the current char
3539 case 's': // s- substitute the current char
3540 if (cmdcnt-- > 1) {
3541 do_cmd(c);
3542 } // repeat cnt
3543 dir = 0;
3544 if (c == 'X')
3545 dir = -1;
3546 if (dot[dir] != '\n') {
3547 if (c == 'X')
3548 dot--; // delete prev char
3549 dot = yank_delete(dot, dot, 0, YANKDEL); // delete char
3550 }
3551 if (c == 's')
3552 goto dc_i; // start insrting
3553 end_cmd_q(); // stop adding to q
3554 break;
3555 case 'Z': // Z- if modified, {write}; exit
3556 // ZZ means to save file (if necessary), then exit
3557 c1 = get_one_char();
3558 if (c1 != 'Z') {
3559 indicate_error(c);
3560 break;
3561 }
3562 if (file_modified
3563#ifdef CONFIG_FEATURE_VI_READONLY
3564 && ! vi_readonly
3565 && ! readonly
3566#endif /* CONFIG_FEATURE_VI_READONLY */
3567 ) {
3568 cnt = file_write(cfn, text, end - 1);
3569 if (cnt == (end - 1 - text + 1)) {
3570 editing = 0;
3571 }
3572 } else {
3573 editing = 0;
3574 }
3575 break;
3576 case '^': // ^- move to first non-blank on line
3577 dot_begin();
3578 dot_skip_over_ws();
3579 break;
3580 case 'b': // b- back a word
3581 case 'e': // e- end of word
3582 if (cmdcnt-- > 1) {
3583 do_cmd(c);
3584 } // repeat cnt
3585 dir = FORWARD;
3586 if (c == 'b')
3587 dir = BACK;
3588 if ((dot + dir) < text || (dot + dir) > end - 1)
3589 break;
3590 dot += dir;
3591 if (isspace(*dot)) {
3592 dot = skip_thing(dot, (c == 'e') ? 2 : 1, dir, S_OVER_WS);
3593 }
3594 if (isalnum(*dot) || *dot == '_') {
3595 dot = skip_thing(dot, 1, dir, S_END_ALNUM);
3596 } else if (ispunct(*dot)) {
3597 dot = skip_thing(dot, 1, dir, S_END_PUNCT);
3598 }
3599 break;
3600 case 'c': // c- change something
3601 case 'd': // d- delete something
3602#ifdef CONFIG_FEATURE_VI_YANKMARK
3603 case 'y': // y- yank something
3604 case 'Y': // Y- Yank a line
3605#endif /* CONFIG_FEATURE_VI_YANKMARK */
3606 yf = YANKDEL; // assume either "c" or "d"
3607#ifdef CONFIG_FEATURE_VI_YANKMARK
3608 if (c == 'y' || c == 'Y')
3609 yf = YANKONLY;
3610#endif /* CONFIG_FEATURE_VI_YANKMARK */
3611 c1 = 'y';
3612 if (c != 'Y')
3613 c1 = get_one_char(); // get the type of thing to delete
3614 find_range(&p, &q, c1);
3615 if (c1 == 27) { // ESC- user changed mind and wants out
3616 c = c1 = 27; // Escape- do nothing
3617 } else if (strchr("wW", c1)) {
3618 if (c == 'c') {
3619 // don't include trailing WS as part of word
3620 while (isblnk(*q)) {
3621 if (q <= text || q[-1] == '\n')
3622 break;
3623 q--;
3624 }
3625 }
3626 dot = yank_delete(p, q, 0, yf); // delete word
3627 } else if (strchr("^0bBeEft$", c1)) {
3628 // single line copy text into a register and delete
3629 dot = yank_delete(p, q, 0, yf); // delete word
3630 } else if (strchr("cdykjHL%+-{}\r\n", c1)) {
3631 // multiple line copy text into a register and delete
3632 dot = yank_delete(p, q, 1, yf); // delete lines
3633 if (c == 'c') {
3634 dot = char_insert(dot, '\n');
3635 // on the last line of file don't move to prev line
3636 if (dot != (end-1)) {
3637 dot_prev();
3638 }
3639 } else if (c == 'd') {
3640 dot_begin();
3641 dot_skip_over_ws();
3642 }
3643 } else {
3644 // could not recognize object
3645 c = c1 = 27; // error-
3646 indicate_error(c);
3647 }
3648 if (c1 != 27) {
3649 // if CHANGING, not deleting, start inserting after the delete
3650 if (c == 'c') {
3651 strcpy((char *) buf, "Change");
3652 goto dc_i; // start inserting
3653 }
3654 if (c == 'd') {
3655 strcpy((char *) buf, "Delete");
3656 }
3657#ifdef CONFIG_FEATURE_VI_YANKMARK
3658 if (c == 'y' || c == 'Y') {
3659 strcpy((char *) buf, "Yank");
3660 }
3661 p = reg[YDreg];
3662 q = p + strlen((char *) p);
3663 for (cnt = 0; p <= q; p++) {
3664 if (*p == '\n')
3665 cnt++;
3666 }
3667 psb("%s %d lines (%d chars) using [%c]",
3668 buf, cnt, strlen((char *) reg[YDreg]), what_reg());
3669#endif /* CONFIG_FEATURE_VI_YANKMARK */
3670 end_cmd_q(); // stop adding to q
3671 }
3672 break;
3673 case 'k': // k- goto prev line, same col
3674 case VI_K_UP: // cursor key Up
3675 if (cmdcnt-- > 1) {
3676 do_cmd(c);
3677 } // repeat cnt
3678 dot_prev();
3679 dot = move_to_col(dot, ccol + offset); // try stay in same col
3680 break;
3681 case 'r': // r- replace the current char with user input
3682 c1 = get_one_char(); // get the replacement char
3683 if (*dot != '\n') {
3684 *dot = c1;
3685 file_modified = TRUE; // has the file been modified
3686 }
3687 end_cmd_q(); // stop adding to q
3688 break;
3689 case 't': // t- move to char prior to next x
3690 last_forward_char = get_one_char();
3691 do_cmd(';');
3692 if (*dot == last_forward_char)
3693 dot_left();
3694 last_forward_char= 0;
3695 break;
3696 case 'w': // w- forward a word
3697 if (cmdcnt-- > 1) {
3698 do_cmd(c);
3699 } // repeat cnt
3700 if (isalnum(*dot) || *dot == '_') { // we are on ALNUM
3701 dot = skip_thing(dot, 1, FORWARD, S_END_ALNUM);
3702 } else if (ispunct(*dot)) { // we are on PUNCT
3703 dot = skip_thing(dot, 1, FORWARD, S_END_PUNCT);
3704 }
3705 if (dot < end - 1)
3706 dot++; // move over word
3707 if (isspace(*dot)) {
3708 dot = skip_thing(dot, 2, FORWARD, S_OVER_WS);
3709 }
3710 break;
3711 case 'z': // z-
3712 c1 = get_one_char(); // get the replacement char
3713 cnt = 0;
3714 if (c1 == '.')
3715 cnt = (rows - 2) / 2; // put dot at center
3716 if (c1 == '-')
3717 cnt = rows - 2; // put dot at bottom
3718 screenbegin = begin_line(dot); // start dot at top
3719 dot_scroll(cnt, -1);
3720 break;
3721 case '|': // |- move to column "cmdcnt"
3722 dot = move_to_col(dot, cmdcnt - 1); // try to move to column
3723 break;
3724 case '~': // ~- flip the case of letters a-z -> A-Z
3725 if (cmdcnt-- > 1) {
3726 do_cmd(c);
3727 } // repeat cnt
3728 if (islower(*dot)) {
3729 *dot = toupper(*dot);
3730 file_modified = TRUE; // has the file been modified
3731 } else if (isupper(*dot)) {
3732 *dot = tolower(*dot);
3733 file_modified = TRUE; // has the file been modified
3734 }
3735 dot_right();
3736 end_cmd_q(); // stop adding to q
3737 break;
3738 //----- The Cursor and Function Keys -----------------------------
3739 case VI_K_HOME: // Cursor Key Home
3740 dot_begin();
3741 break;
3742 // The Fn keys could point to do_macro which could translate them
3743 case VI_K_FUN1: // Function Key F1
3744 case VI_K_FUN2: // Function Key F2
3745 case VI_K_FUN3: // Function Key F3
3746 case VI_K_FUN4: // Function Key F4
3747 case VI_K_FUN5: // Function Key F5
3748 case VI_K_FUN6: // Function Key F6
3749 case VI_K_FUN7: // Function Key F7
3750 case VI_K_FUN8: // Function Key F8
3751 case VI_K_FUN9: // Function Key F9
3752 case VI_K_FUN10: // Function Key F10
3753 case VI_K_FUN11: // Function Key F11
3754 case VI_K_FUN12: // Function Key F12
3755 break;
3756 }
3757
3758 dc1:
3759 // if text[] just became empty, add back an empty line
3760 if (end == text) {
3761 (void) char_insert(text, '\n'); // start empty buf with dummy line
3762 dot = text;
3763 }
3764 // it is OK for dot to exactly equal to end, otherwise check dot validity
3765 if (dot != end) {
3766 dot = bound_dot(dot); // make sure "dot" is valid
3767 }
3768#ifdef CONFIG_FEATURE_VI_YANKMARK
3769 check_context(c); // update the current context
3770#endif /* CONFIG_FEATURE_VI_YANKMARK */
3771
3772 if (!isdigit(c))
3773 cmdcnt = 0; // cmd was not a number, reset cmdcnt
3774 cnt = dot - begin_line(dot);
3775 // Try to stay off of the Newline
3776 if (*dot == '\n' && cnt > 0 && cmd_mode == 0)
3777 dot--;
3778}
3779
3780#ifdef CONFIG_FEATURE_VI_CRASHME
3781static int totalcmds = 0;
3782static int Mp = 85; // Movement command Probability
3783static int Np = 90; // Non-movement command Probability
3784static int Dp = 96; // Delete command Probability
3785static int Ip = 97; // Insert command Probability
3786static int Yp = 98; // Yank command Probability
3787static int Pp = 99; // Put command Probability
3788static int M = 0, N = 0, I = 0, D = 0, Y = 0, P = 0, U = 0;
3789char chars[20] = "\t012345 abcdABCD-=.$";
3790char *words[20] = { "this", "is", "a", "test",
3791 "broadcast", "the", "emergency", "of",
3792 "system", "quick", "brown", "fox",
3793 "jumped", "over", "lazy", "dogs",
3794 "back", "January", "Febuary", "March"
3795};
3796char *lines[20] = {
3797 "You should have received a copy of the GNU General Public License\n",
3798 "char c, cm, *cmd, *cmd1;\n",
3799 "generate a command by percentages\n",
3800 "Numbers may be typed as a prefix to some commands.\n",
3801 "Quit, discarding changes!\n",
3802 "Forced write, if permission originally not valid.\n",
3803 "In general, any ex or ed command (such as substitute or delete).\n",
3804 "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
3805 "Please get w/ me and I will go over it with you.\n",
3806 "The following is a list of scheduled, committed changes.\n",
3807 "1. Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
3808 "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
3809 "Any question about transactions please contact Sterling Huxley.\n",
3810 "I will try to get back to you by Friday, December 31.\n",
3811 "This Change will be implemented on Friday.\n",
3812 "Let me know if you have problems accessing this;\n",
3813 "Sterling Huxley recently added you to the access list.\n",
3814 "Would you like to go to lunch?\n",
3815 "The last command will be automatically run.\n",
3816 "This is too much english for a computer geek.\n",
3817};
3818char *multilines[20] = {
3819 "You should have received a copy of the GNU General Public License\n",
3820 "char c, cm, *cmd, *cmd1;\n",
3821 "generate a command by percentages\n",
3822 "Numbers may be typed as a prefix to some commands.\n",
3823 "Quit, discarding changes!\n",
3824 "Forced write, if permission originally not valid.\n",
3825 "In general, any ex or ed command (such as substitute or delete).\n",
3826 "I have tickets available for the Blazers vs LA Clippers for Monday, Janurary 1 at 1:00pm.\n",
3827 "Please get w/ me and I will go over it with you.\n",
3828 "The following is a list of scheduled, committed changes.\n",
3829 "1. Launch Norton Antivirus (Start, Programs, Norton Antivirus)\n",
3830 "Reminder....Town Meeting in Central Perk cafe today at 3:00pm.\n",
3831 "Any question about transactions please contact Sterling Huxley.\n",
3832 "I will try to get back to you by Friday, December 31.\n",
3833 "This Change will be implemented on Friday.\n",
3834 "Let me know if you have problems accessing this;\n",
3835 "Sterling Huxley recently added you to the access list.\n",
3836 "Would you like to go to lunch?\n",
3837 "The last command will be automatically run.\n",
3838 "This is too much english for a computer geek.\n",
3839};
3840
3841// create a random command to execute
3842static void crash_dummy()
3843{
3844 static int sleeptime; // how long to pause between commands
3845 char c, cm, *cmd, *cmd1;
3846 int i, cnt, thing, rbi, startrbi, percent;
3847
3848 // "dot" movement commands
3849 cmd1 = " \n\r\002\004\005\006\025\0310^$-+wWeEbBhjklHL";
3850
3851 // is there already a command running?
3852 if (readed_for_parse > 0)
3853 goto cd1;
3854 cd0:
3855 startrbi = rbi = 0;
3856 sleeptime = 0; // how long to pause between commands
3857 memset(readbuffer, '\0', BUFSIZ); // clear the read buffer
3858 // generate a command by percentages
3859 percent = (int) lrand48() % 100; // get a number from 0-99
3860 if (percent < Mp) { // Movement commands
3861 // available commands
3862 cmd = cmd1;
3863 M++;
3864 } else if (percent < Np) { // non-movement commands
3865 cmd = "mz<>\'\""; // available commands
3866 N++;
3867 } else if (percent < Dp) { // Delete commands
3868 cmd = "dx"; // available commands
3869 D++;
3870 } else if (percent < Ip) { // Inset commands
3871 cmd = "iIaAsrJ"; // available commands
3872 I++;
3873 } else if (percent < Yp) { // Yank commands
3874 cmd = "yY"; // available commands
3875 Y++;
3876 } else if (percent < Pp) { // Put commands
3877 cmd = "pP"; // available commands
3878 P++;
3879 } else {
3880 // We do not know how to handle this command, try again
3881 U++;
3882 goto cd0;
3883 }
3884 // randomly pick one of the available cmds from "cmd[]"
3885 i = (int) lrand48() % strlen(cmd);
3886 cm = cmd[i];
3887 if (strchr(":\024", cm))
3888 goto cd0; // dont allow colon or ctrl-T commands
3889 readbuffer[rbi++] = cm; // put cmd into input buffer
3890
3891 // now we have the command-
3892 // there are 1, 2, and multi char commands
3893 // find out which and generate the rest of command as necessary
3894 if (strchr("dmryz<>\'\"", cm)) { // 2-char commands
3895 cmd1 = " \n\r0$^-+wWeEbBhjklHL";
3896 if (cm == 'm' || cm == '\'' || cm == '\"') { // pick a reg[]
3897 cmd1 = "abcdefghijklmnopqrstuvwxyz";
3898 }
3899 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
3900 c = cmd1[thing];
3901 readbuffer[rbi++] = c; // add movement to input buffer
3902 }
3903 if (strchr("iIaAsc", cm)) { // multi-char commands
3904 if (cm == 'c') {
3905 // change some thing
3906 thing = (int) lrand48() % strlen(cmd1); // pick a movement command
3907 c = cmd1[thing];
3908 readbuffer[rbi++] = c; // add movement to input buffer
3909 }
3910 thing = (int) lrand48() % 4; // what thing to insert
3911 cnt = (int) lrand48() % 10; // how many to insert
3912 for (i = 0; i < cnt; i++) {
3913 if (thing == 0) { // insert chars
3914 readbuffer[rbi++] = chars[((int) lrand48() % strlen(chars))];
3915 } else if (thing == 1) { // insert words
3916 strcat((char *) readbuffer, words[(int) lrand48() % 20]);
3917 strcat((char *) readbuffer, " ");
3918 sleeptime = 0; // how fast to type
3919 } else if (thing == 2) { // insert lines
3920 strcat((char *) readbuffer, lines[(int) lrand48() % 20]);
3921 sleeptime = 0; // how fast to type
3922 } else { // insert multi-lines
3923 strcat((char *) readbuffer, multilines[(int) lrand48() % 20]);
3924 sleeptime = 0; // how fast to type
3925 }
3926 }
3927 strcat((char *) readbuffer, "\033");
3928 }
3929 readed_for_parse = strlen(readbuffer);
3930 cd1:
3931 totalcmds++;
3932 if (sleeptime > 0)
3933 (void) mysleep(sleeptime); // sleep 1/100 sec
3934}
3935
3936// test to see if there are any errors
3937static void crash_test()
3938{
3939 static time_t oldtim;
3940 time_t tim;
3941 char d[2], msg[BUFSIZ];
3942
3943 msg[0] = '\0';
3944 if (end < text) {
3945 strcat((char *) msg, "end<text ");
3946 }
3947 if (end > textend) {
3948 strcat((char *) msg, "end>textend ");
3949 }
3950 if (dot < text) {
3951 strcat((char *) msg, "dot<text ");
3952 }
3953 if (dot > end) {
3954 strcat((char *) msg, "dot>end ");
3955 }
3956 if (screenbegin < text) {
3957 strcat((char *) msg, "screenbegin<text ");
3958 }
3959 if (screenbegin > end - 1) {
3960 strcat((char *) msg, "screenbegin>end-1 ");
3961 }
3962
3963 if (strlen(msg) > 0) {
3964 alarm(0);
3965 printf("\n\n%d: \'%c\' %s\n\n\n%s[Hit return to continue]%s",
3966 totalcmds, last_input_char, msg, SOs, SOn);
3967 fflush(stdout);
3968 while (read(0, d, 1) > 0) {
3969 if (d[0] == '\n' || d[0] == '\r')
3970 break;
3971 }
3972 alarm(3);
3973 }
3974 tim = (time_t) time((time_t *) 0);
3975 if (tim >= (oldtim + 3)) {
3976 sprintf((char *) status_buffer,
3977 "Tot=%d: M=%d N=%d I=%d D=%d Y=%d P=%d U=%d size=%d",
3978 totalcmds, M, N, I, D, Y, P, U, end - text + 1);
3979 oldtim = tim;
3980 }
3981 return;
3982}
3983#endif /* CONFIG_FEATURE_VI_CRASHME */