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