vi/v_ex.c

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