1 /*-
2 * Copyright (c) 1992, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1992, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
6 *
7 * See the LICENSE file for redistribution information.
8 */
9
10 #include "config.h"
11
12 #ifndef lint
13 static const char sccsid[] = "@(#)v_ex.c 10.42 (Berkeley) 6/28/96";
14 #endif /* not lint */
15
16 #include <sys/types.h>
17 #include <sys/queue.h>
18 #include <sys/time.h>
19
20 #include <bitstring.h>
21 #include <limits.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26
27 #include "../common/common.h"
28 #include "vi.h"
29
30 static int v_ecl __P((SCR *));
31 static int v_ecl_init __P((SCR *));
32 static int v_ecl_log __P((SCR *, TEXT *));
33 static int v_ex_done __P((SCR *, VICMD *));
34 static int v_exec_ex __P((SCR *, VICMD *, EXCMD *));
35
36 /*
37 * v_again -- &
38 * Repeat the previous substitution.
39 *
40 * PUBLIC: int v_again __P((SCR *, VICMD *));
41 */
42 int
v_again(sp,vp)43 v_again(sp, vp)
44 SCR *sp;
45 VICMD *vp;
46 {
47 ARGS *ap[2], a;
48 EXCMD cmd;
49
50 ex_cinit(&cmd, C_SUBAGAIN, 2, vp->m_start.lno, vp->m_start.lno, 1, ap);
51 ex_cadd(&cmd, &a, "", 1);
52
53 return (v_exec_ex(sp, vp, &cmd));
54 }
55
56 /*
57 * v_exmode -- Q
58 * Switch the editor into EX mode.
59 *
60 * PUBLIC: int v_exmode __P((SCR *, VICMD *));
61 */
62 int
v_exmode(sp,vp)63 v_exmode(sp, vp)
64 SCR *sp;
65 VICMD *vp;
66 {
67 GS *gp;
68
69 gp = sp->gp;
70
71 /* Try and switch screens -- the screen may not permit it. */
72 if (gp->scr_screen(sp, SC_EX)) {
73 msgq(sp, M_ERR,
74 "207|The Q command requires the ex terminal interface");
75 return (1);
76 }
77 (void)gp->scr_attr(sp, SA_ALTERNATE, 0);
78
79 /* Save the current cursor position. */
80 sp->frp->lno = sp->lno;
81 sp->frp->cno = sp->cno;
82 F_SET(sp->frp, FR_CURSORSET);
83
84 /* Switch to ex mode. */
85 F_CLR(sp, SC_VI | SC_SCR_VI);
86 F_SET(sp, SC_EX);
87
88 /* Move out of the vi screen. */
89 (void)ex_puts(sp, "\n");
90
91 return (0);
92 }
93
94 /*
95 * v_join -- [count]J
96 * Join lines together.
97 *
98 * PUBLIC: int v_join __P((SCR *, VICMD *));
99 */
100 int
v_join(sp,vp)101 v_join(sp, vp)
102 SCR *sp;
103 VICMD *vp;
104 {
105 EXCMD cmd;
106 int lno;
107
108 /*
109 * YASC.
110 * The general rule is that '#J' joins # lines, counting the current
111 * line. However, 'J' and '1J' are the same as '2J', i.e. join the
112 * current and next lines. This doesn't map well into the ex command
113 * (which takes two line numbers), so we handle it here. Note that
114 * we never test for EOF -- historically going past the end of file
115 * worked just fine.
116 */
117 lno = vp->m_start.lno + 1;
118 if (F_ISSET(vp, VC_C1SET) && vp->count > 2)
119 lno = vp->m_start.lno + (vp->count - 1);
120
121 ex_cinit(&cmd, C_JOIN, 2, vp->m_start.lno, lno, 0, NULL);
122 return (v_exec_ex(sp, vp, &cmd));
123 }
124
125 /*
126 * v_shiftl -- [count]<motion
127 * Shift lines left.
128 *
129 * PUBLIC: int v_shiftl __P((SCR *, VICMD *));
130 */
131 int
v_shiftl(sp,vp)132 v_shiftl(sp, vp)
133 SCR *sp;
134 VICMD *vp;
135 {
136 ARGS *ap[2], a;
137 EXCMD cmd;
138
139 ex_cinit(&cmd, C_SHIFTL, 2, vp->m_start.lno, vp->m_stop.lno, 0, ap);
140 ex_cadd(&cmd, &a, "<", 1);
141 return (v_exec_ex(sp, vp, &cmd));
142 }
143
144 /*
145 * v_shiftr -- [count]>motion
146 * Shift lines right.
147 *
148 * PUBLIC: int v_shiftr __P((SCR *, VICMD *));
149 */
150 int
v_shiftr(sp,vp)151 v_shiftr(sp, vp)
152 SCR *sp;
153 VICMD *vp;
154 {
155 ARGS *ap[2], a;
156 EXCMD cmd;
157
158 ex_cinit(&cmd, C_SHIFTR, 2, vp->m_start.lno, vp->m_stop.lno, 0, ap);
159 ex_cadd(&cmd, &a, ">", 1);
160 return (v_exec_ex(sp, vp, &cmd));
161 }
162
163 /*
164 * v_suspend -- ^Z
165 * Suspend vi.
166 *
167 * PUBLIC: int v_suspend __P((SCR *, VICMD *));
168 */
169 int
v_suspend(sp,vp)170 v_suspend(sp, vp)
171 SCR *sp;
172 VICMD *vp;
173 {
174 ARGS *ap[2], a;
175 EXCMD cmd;
176
177 ex_cinit(&cmd, C_STOP, 0, OOBLNO, OOBLNO, 0, ap);
178 ex_cadd(&cmd, &a, "suspend", sizeof("suspend") - 1);
179 return (v_exec_ex(sp, vp, &cmd));
180 }
181
182 /*
183 * v_switch -- ^^
184 * Switch to the previous file.
185 *
186 * PUBLIC: int v_switch __P((SCR *, VICMD *));
187 */
188 int
v_switch(sp,vp)189 v_switch(sp, vp)
190 SCR *sp;
191 VICMD *vp;
192 {
193 ARGS *ap[2], a;
194 EXCMD cmd;
195 char *name;
196
197 /*
198 * Try the alternate file name, then the previous file
199 * name. Use the real name, not the user's current name.
200 */
201 if ((name = sp->alt_name) == NULL) {
202 msgq(sp, M_ERR, "180|No previous file to edit");
203 return (1);
204 }
205
206 /* If autowrite is set, write out the file. */
207 if (file_m1(sp, 0, FS_ALL))
208 return (1);
209
210 ex_cinit(&cmd, C_EDIT, 0, OOBLNO, OOBLNO, 0, ap);
211 ex_cadd(&cmd, &a, name, strlen(name));
212 return (v_exec_ex(sp, vp, &cmd));
213 }
214
215 /*
216 * v_tagpush -- ^[
217 * Do a tag search on the cursor keyword.
218 *
219 * PUBLIC: int v_tagpush __P((SCR *, VICMD *));
220 */
221 int
v_tagpush(sp,vp)222 v_tagpush(sp, vp)
223 SCR *sp;
224 VICMD *vp;
225 {
226 ARGS *ap[2], a;
227 EXCMD cmd;
228
229 #ifdef GTAGS
230 if (O_ISSET(sp, O_GTAGSMODE) && vp->m_start.cno == 0)
231 ex_cinit(&cmd, C_RTAG, 0, OOBLNO, 0, 0, ap);
232 else
233 #endif
234 ex_cinit(&cmd, C_TAG, 0, OOBLNO, 0, 0, ap);
235 ex_cadd(&cmd, &a, VIP(sp)->keyw, strlen(VIP(sp)->keyw));
236 return (v_exec_ex(sp, vp, &cmd));
237 }
238
239 /*
240 * v_tagpop -- ^T
241 * Pop the tags stack.
242 *
243 * PUBLIC: int v_tagpop __P((SCR *, VICMD *));
244 */
245 int
v_tagpop(sp,vp)246 v_tagpop(sp, vp)
247 SCR *sp;
248 VICMD *vp;
249 {
250 EXCMD cmd;
251
252 ex_cinit(&cmd, C_TAGPOP, 0, OOBLNO, 0, 0, NULL);
253 return (v_exec_ex(sp, vp, &cmd));
254 }
255
256 /*
257 * v_filter -- [count]!motion command(s)
258 * Run range through shell commands, replacing text.
259 *
260 * PUBLIC: int v_filter __P((SCR *, VICMD *));
261 */
262 int
v_filter(sp,vp)263 v_filter(sp, vp)
264 SCR *sp;
265 VICMD *vp;
266 {
267 EXCMD cmd;
268 TEXT *tp;
269
270 /*
271 * !!!
272 * Historical vi permitted "!!" in an empty file, and it's handled
273 * as a special case in the ex_bang routine. Don't modify this setup
274 * without understanding that one. In particular, note that we're
275 * manipulating the ex argument structures behind ex's back.
276 *
277 * !!!
278 * Historical vi did not permit the '!' command to be associated with
279 * a non-line oriented motion command, in general, although it did
280 * with search commands. So, !f; and !w would fail, but !/;<CR>
281 * would succeed, even if they all moved to the same location in the
282 * current line. I don't see any reason to disallow '!' using any of
283 * the possible motion commands.
284 *
285 * !!!
286 * Historical vi ran the last bang command if N or n was used as the
287 * search motion.
288 */
289 if (F_ISSET(vp, VC_ISDOT) ||
290 ISCMD(vp->rkp, 'N') || ISCMD(vp->rkp, 'n')) {
291 ex_cinit(&cmd, C_BANG,
292 2, vp->m_start.lno, vp->m_stop.lno, 0, NULL);
293 EXP(sp)->argsoff = 0; /* XXX */
294
295 if (argv_exp1(sp, &cmd, "!", 1, 1))
296 return (1);
297 cmd.argc = EXP(sp)->argsoff; /* XXX */
298 cmd.argv = EXP(sp)->args; /* XXX */
299 return (v_exec_ex(sp, vp, &cmd));
300 }
301
302 /* Get the command from the user. */
303 if (v_tcmd(sp, vp,
304 '!', TXT_BS | TXT_CR | TXT_ESCAPE | TXT_FILEC | TXT_PROMPT))
305 return (1);
306
307 /*
308 * Check to see if the user changed their mind.
309 *
310 * !!!
311 * Entering <escape> on an empty line was historically an error,
312 * this implementation doesn't bother.
313 */
314 tp = sp->tiq.cqh_first;
315 if (tp->term != TERM_OK) {
316 vp->m_final.lno = sp->lno;
317 vp->m_final.cno = sp->cno;
318 return (0);
319 }
320
321 /* Home the cursor. */
322 vs_home(sp);
323
324 ex_cinit(&cmd, C_BANG, 2, vp->m_start.lno, vp->m_stop.lno, 0, NULL);
325 EXP(sp)->argsoff = 0; /* XXX */
326
327 if (argv_exp1(sp, &cmd, tp->lb + 1, tp->len - 1, 1))
328 return (1);
329 cmd.argc = EXP(sp)->argsoff; /* XXX */
330 cmd.argv = EXP(sp)->args; /* XXX */
331 return (v_exec_ex(sp, vp, &cmd));
332 }
333
334 /*
335 * v_event_exec --
336 * Execute some command(s) based on an event.
337 *
338 * PUBLIC: int v_event_exec __P((SCR *, VICMD *));
339 */
340 int
v_event_exec(sp,vp)341 v_event_exec(sp, vp)
342 SCR *sp;
343 VICMD *vp;
344 {
345 EXCMD cmd;
346
347 switch (vp->ev.e_event) {
348 case E_QUIT:
349 ex_cinit(&cmd, C_QUIT, 0, OOBLNO, OOBLNO, 0, NULL);
350 break;
351 case E_WRITE:
352 ex_cinit(&cmd, C_WRITE, 0, OOBLNO, OOBLNO, 0, NULL);
353 break;
354 default:
355 abort();
356 }
357 return (v_exec_ex(sp, vp, &cmd));
358 }
359
360 /*
361 * v_exec_ex --
362 * Execute an ex command.
363 */
364 static int
v_exec_ex(sp,vp,exp)365 v_exec_ex(sp, vp, exp)
366 SCR *sp;
367 VICMD *vp;
368 EXCMD *exp;
369 {
370 int rval;
371
372 rval = exp->cmd->fn(sp, exp);
373 return (v_ex_done(sp, vp) || rval);
374 }
375
376 /*
377 * v_ex -- :
378 * Execute a colon command line.
379 *
380 * PUBLIC: int v_ex __P((SCR *, VICMD *));
381 */
382 int
v_ex(sp,vp)383 v_ex(sp, vp)
384 SCR *sp;
385 VICMD *vp;
386 {
387 GS *gp;
388 TEXT *tp;
389 int do_cedit, do_resolution, ifcontinue;
390
391 gp = sp->gp;
392
393 /*
394 * !!!
395 * If we put out more than a single line of messages, or ex trashes
396 * the screen, the user may continue entering ex commands. We find
397 * this out when we do the screen/message resolution. We can't enter
398 * completely into ex mode however, because the user can elect to
399 * return into vi mode by entering any key, i.e. we have to be in raw
400 * mode.
401 */
402 for (do_cedit = do_resolution = 0;;) {
403 /*
404 * !!!
405 * There may already be an ex command waiting to run. If
406 * so, we continue with it.
407 */
408 if (!EXCMD_RUNNING(gp)) {
409 /* Get a command. */
410 if (v_tcmd(sp, vp, ':',
411 TXT_BS | TXT_CEDIT | TXT_FILEC | TXT_PROMPT))
412 return (1);
413 tp = sp->tiq.cqh_first;
414
415 /*
416 * If the user entered a single <esc>, they want to
417 * edit their colon command history. If they already
418 * entered some text, move it into the edit history.
419 */
420 if (tp->term == TERM_CEDIT) {
421 if (tp->len > 1 && v_ecl_log(sp, tp))
422 return (1);
423 do_cedit = 1;
424 break;
425 }
426
427 /* If the user didn't enter anything, return. */
428 if (tp->term == TERM_BS)
429 break;
430
431 /* If the user changed their mind, return. */
432 if (tp->term != TERM_OK)
433 break;
434
435 /* Log the command. */
436 if (O_STR(sp, O_CEDIT) != NULL && v_ecl_log(sp, tp))
437 return (1);
438
439 /* Push a command on the command stack. */
440 if (ex_run_str(sp, NULL, tp->lb, tp->len, 0, 1))
441 return (1);
442 }
443
444 /* Home the cursor. */
445 vs_home(sp);
446
447 /*
448 * !!!
449 * If the editor wrote the screen behind curses back, put out
450 * a <newline> so that we don't overwrite the user's command
451 * with its output or the next want-to-continue? message. This
452 * doesn't belong here, but I can't find another place to put
453 * it. See, we resolved the output from the last ex command,
454 * and the user entered another one. This is the only place
455 * where we have control before the ex command writes output.
456 * We could get control in vs_msg(), but we have no way to know
457 * if command didn't put out any output when we try and resolve
458 * this command. This fixes a bug where combinations of ex
459 * commands, e.g. ":set<CR>:!date<CR>:set" didn't look right.
460 */
461 if (F_ISSET(sp, SC_SCR_EXWROTE))
462 (void)putchar('\n');
463
464 /* Call the ex parser. */
465 (void)ex_cmd(sp);
466
467 /* Flush ex messages. */
468 (void)ex_fflush(sp);
469
470 /* Resolve any messages. */
471 if (vs_ex_resolve(sp, &ifcontinue))
472 return (1);
473
474 /*
475 * Continue or return. If continuing, make sure that we
476 * eventually do resolution.
477 */
478 if (!ifcontinue)
479 break;
480 do_resolution = 1;
481
482 /* If we're continuing, it's a new command. */
483 ++sp->ccnt;
484 }
485
486 /*
487 * If the user previously continued an ex command, we have to do
488 * resolution to clean up the screen. Don't wait, we already did
489 * that.
490 */
491 if (do_resolution) {
492 F_SET(sp, SC_EX_WAIT_NO);
493 if (vs_ex_resolve(sp, &ifcontinue))
494 return (1);
495 }
496
497 /* Cleanup from the ex command. */
498 if (v_ex_done(sp, vp))
499 return (1);
500
501 /* The user may want to edit their colon command history. */
502 if (do_cedit)
503 return (v_ecl(sp));
504
505 return (0);
506 }
507
508 /*
509 * v_ex_done --
510 * Cleanup from an ex command.
511 */
512 static int
v_ex_done(sp,vp)513 v_ex_done(sp, vp)
514 SCR *sp;
515 VICMD *vp;
516 {
517 size_t len;
518
519 /*
520 * The only cursor modifications are real, however, the underlying
521 * line may have changed; don't trust anything. This code has been
522 * a remarkably fertile place for bugs. Do a reality check on a
523 * cursor value, and make sure it's okay. If necessary, change it.
524 * Ex keeps track of the line number, but it cares less about the
525 * column and it may have disappeared.
526 *
527 * Don't trust ANYTHING.
528 *
529 * XXX
530 * Ex will soon have to start handling the column correctly; see
531 * the POSIX 1003.2 standard.
532 */
533 if (db_eget(sp, sp->lno, NULL, &len, NULL)) {
534 sp->lno = 1;
535 sp->cno = 0;
536 } else if (sp->cno >= len)
537 sp->cno = len ? len - 1 : 0;
538
539 vp->m_final.lno = sp->lno;
540 vp->m_final.cno = sp->cno;
541
542 /*
543 * Don't re-adjust the cursor after executing an ex command,
544 * and ex movements are permanent.
545 */
546 F_CLR(vp, VM_RCM_MASK);
547 F_SET(vp, VM_RCM_SET);
548
549 return (0);
550 }
551
552 /*
553 * v_ecl --
554 * Start an edit window on the colon command-line commands.
555 */
556 static int
v_ecl(sp)557 v_ecl(sp)
558 SCR *sp;
559 {
560 GS *gp;
561 SCR *new;
562
563 /* Initialize the screen, if necessary. */
564 gp = sp->gp;
565 if (gp->ccl_sp == NULL && v_ecl_init(sp))
566 return (1);
567
568 /* Get a new screen. */
569 if (screen_init(gp, sp, &new))
570 return (1);
571 if (vs_split(sp, new, 1)) {
572 (void)screen_end(new);
573 return (1);
574 }
575
576 /* Attach to the screen. */
577 new->ep = gp->ccl_sp->ep;
578 ++new->ep->refcnt;
579
580 new->frp = gp->ccl_sp->frp;
581 new->frp->flags = sp->frp->flags;
582
583 /* Move the cursor to the end. */
584 (void)db_last(new, &new->lno);
585 if (new->lno == 0)
586 new->lno = 1;
587
588 /* Remember the originating window. */
589 sp->ccl_parent = sp;
590
591 /* It's a special window. */
592 F_SET(new, SC_COMEDIT);
593
594 /* Set up the switch. */
595 sp->nextdisp = new;
596 F_SET(sp, SC_SSWITCH);
597 return (0);
598 }
599
600 /*
601 * v_ecl_exec --
602 * Execute a command from a colon command-line window.
603 *
604 * PUBLIC: int v_ecl_exec __P((SCR *));
605 */
606 int
v_ecl_exec(sp)607 v_ecl_exec(sp)
608 SCR *sp;
609 {
610 size_t len;
611 char *p;
612
613 if (db_get(sp, sp->lno, 0, &p, &len) && sp->lno == 1) {
614 v_emsg(sp, NULL, VIM_EMPTY);
615 return (1);
616 }
617 if (len == 0) {
618 msgq(sp, M_BERR, "307|No ex command to execute");
619 return (1);
620 }
621
622 /* Push the command on the command stack. */
623 if (ex_run_str(sp, NULL, p, len, 0, 0))
624 return (1);
625
626 /* Set up the switch. */
627 sp->nextdisp = sp->ccl_parent;
628 F_SET(sp, SC_EXIT);
629 return (0);
630 }
631
632 /*
633 * v_ecl_log --
634 * Log a command into the colon command-line log file.
635 */
636 static int
v_ecl_log(sp,tp)637 v_ecl_log(sp, tp)
638 SCR *sp;
639 TEXT *tp;
640 {
641 EXF *save_ep;
642 recno_t lno;
643 int rval;
644
645 /* Initialize the screen, if necessary. */
646 if (sp->gp->ccl_sp == NULL && v_ecl_init(sp))
647 return (1);
648
649 /*
650 * Don't log colon command window commands into the colon command
651 * window...
652 */
653 if (sp->ep == sp->gp->ccl_sp->ep)
654 return (0);
655
656 /*
657 * XXX
658 * Swap the current EXF with the colon command file EXF. This
659 * isn't pretty, but too many routines "know" that sp->ep points
660 * to the current EXF.
661 */
662 save_ep = sp->ep;
663 sp->ep = sp->gp->ccl_sp->ep;
664 if (db_last(sp, &lno)) {
665 sp->ep = save_ep;
666 return (1);
667 }
668 rval = db_append(sp, 0, lno, tp->lb, tp->len);
669 sp->ep = save_ep;
670 return (rval);
671 }
672
673 /*
674 * v_ecl_init --
675 * Initialize the colon command-line log file.
676 */
677 static int
v_ecl_init(sp)678 v_ecl_init(sp)
679 SCR *sp;
680 {
681 FREF *frp;
682 GS *gp;
683
684 gp = sp->gp;
685
686 /* Get a temporary file. */
687 if ((frp = file_add(sp, NULL)) == NULL)
688 return (1);
689
690 /*
691 * XXX
692 * Create a screen -- the file initialization code wants one.
693 */
694 if (screen_init(gp, sp, &gp->ccl_sp))
695 return (1);
696 if (file_init(gp->ccl_sp, frp, NULL, 0)) {
697 (void)screen_end(gp->ccl_sp);
698 return (1);
699 }
700
701 /* The underlying file isn't recoverable. */
702 F_CLR(gp->ccl_sp->ep, F_RCV_ON);
703
704 return (0);
705 }
706