1 /* $NetBSD: v_ex.c,v 1.7 2014/01/26 21:43:45 christos Exp $ */ 2 /*- 3 * Copyright (c) 1992, 1993, 1994 4 * The Regents of the University of California. All rights reserved. 5 * Copyright (c) 1992, 1993, 1994, 1995, 1996 6 * Keith Bostic. All rights reserved. 7 * 8 * See the LICENSE file for redistribution information. 9 */ 10 11 #include "config.h" 12 13 #include <sys/cdefs.h> 14 #if 0 15 #ifndef lint 16 static const char sccsid[] = "Id: v_ex.c,v 10.60 2003/07/19 21:04:00 skimo Exp (Berkeley) Date: 2003/07/19 21:04:00 "; 17 #endif /* not lint */ 18 #else 19 __RCSID("$NetBSD: v_ex.c,v 1.7 2014/01/26 21:43:45 christos Exp $"); 20 #endif 21 22 #include <sys/types.h> 23 #include <sys/queue.h> 24 #include <sys/time.h> 25 26 #include <bitstring.h> 27 #include <limits.h> 28 #include <stdio.h> 29 #include <stdlib.h> 30 #include <string.h> 31 #include <unistd.h> 32 33 #include "../common/common.h" 34 #include "vi.h" 35 36 static int v_ecl __P((SCR *)); 37 static int v_ecl_init __P((SCR *)); 38 static int v_ecl_log __P((SCR *, TEXT *)); 39 static int v_ex_done __P((SCR *, VICMD *)); 40 41 /* 42 * v_again -- & 43 * Repeat the previous substitution. 44 * 45 * PUBLIC: int v_again __P((SCR *, VICMD *)); 46 */ 47 int 48 v_again(SCR *sp, VICMD *vp) 49 { 50 EXCMD cmd; 51 static CHAR_T nul[] = { 0 }; 52 53 ex_cinit(sp, &cmd, C_SUBAGAIN, 2, vp->m_start.lno, vp->m_start.lno, 1); 54 argv_exp0(sp, &cmd, nul, 1); 55 return (v_exec_ex(sp, vp, &cmd)); 56 } 57 58 /* 59 * v_exmode -- Q 60 * Switch the editor into EX mode. 61 * 62 * PUBLIC: int v_exmode __P((SCR *, VICMD *)); 63 */ 64 int 65 v_exmode(SCR *sp, 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 101 v_join(SCR *sp, 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(SCR *sp, VICMD *vp) 131 { 132 EXCMD cmd; 133 static CHAR_T lt[] = {'<', 0}; 134 135 ex_cinit(sp, &cmd, C_SHIFTL, 2, vp->m_start.lno, vp->m_stop.lno, 0); 136 argv_exp0(sp, &cmd, lt, 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(SCR *sp, VICMD *vp) 148 { 149 EXCMD cmd; 150 static CHAR_T gt[] = {'>', 0}; 151 152 ex_cinit(sp, &cmd, C_SHIFTR, 2, vp->m_start.lno, vp->m_stop.lno, 0); 153 argv_exp0(sp, &cmd, gt, 2); 154 return (v_exec_ex(sp, vp, &cmd)); 155 } 156 157 /* 158 * v_suspend -- ^Z 159 * Suspend vi. 160 * 161 * PUBLIC: int v_suspend __P((SCR *, VICMD *)); 162 */ 163 int 164 v_suspend(SCR *sp, VICMD *vp) 165 { 166 EXCMD cmd; 167 static CHAR_T suspend[] = {'s', 'u', 's', 'p', 'e', 'n', 'd', 0}; 168 169 ex_cinit(sp, &cmd, C_STOP, 0, OOBLNO, OOBLNO, 0); 170 argv_exp0(sp, &cmd, suspend, sizeof(suspend)/sizeof(CHAR_T)); 171 return (v_exec_ex(sp, vp, &cmd)); 172 } 173 174 /* 175 * v_switch -- ^^ 176 * Switch to the previous file. 177 * 178 * PUBLIC: int v_switch __P((SCR *, VICMD *)); 179 */ 180 int 181 v_switch(SCR *sp, VICMD *vp) 182 { 183 EXCMD cmd; 184 char *name; 185 const CHAR_T *wp; 186 size_t wlen; 187 188 /* 189 * Try the alternate file name, then the previous file 190 * name. Use the real name, not the user's current name. 191 */ 192 if ((name = sp->alt_name) == NULL) { 193 msgq(sp, M_ERR, "180|No previous file to edit"); 194 return (1); 195 } 196 197 /* If autowrite is set, write out the file. */ 198 if (file_m1(sp, 0, FS_ALL)) 199 return (1); 200 201 ex_cinit(sp, &cmd, C_EDIT, 0, OOBLNO, OOBLNO, 0); 202 CHAR2INT(sp, name, strlen(name) + 1, wp, wlen); 203 argv_exp0(sp, &cmd, wp, wlen); 204 return (v_exec_ex(sp, vp, &cmd)); 205 } 206 207 /* 208 * v_tagpush -- ^[ 209 * Do a tag search on the cursor keyword. 210 * 211 * PUBLIC: int v_tagpush __P((SCR *, VICMD *)); 212 */ 213 int 214 v_tagpush(SCR *sp, VICMD *vp) 215 { 216 EXCMD cmd; 217 218 #ifdef GTAGS 219 if (O_ISSET(sp, O_GTAGSMODE) && vp->m_start.cno == 0) 220 ex_cinit(sp, &cmd, C_RTAG, 0, OOBLNO, 0, 0); 221 else 222 #endif 223 ex_cinit(sp, &cmd, C_TAG, 0, OOBLNO, 0, 0); 224 argv_exp0(sp, &cmd, VIP(sp)->keyw, STRLEN(VIP(sp)->keyw) + 1); 225 return (v_exec_ex(sp, vp, &cmd)); 226 } 227 228 /* 229 * v_tagpop -- ^T 230 * Pop the tags stack. 231 * 232 * PUBLIC: int v_tagpop __P((SCR *, VICMD *)); 233 */ 234 int 235 v_tagpop(SCR *sp, 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(SCR *sp, VICMD *vp) 251 { 252 EXCMD cmd; 253 TEXT *tp; 254 255 /* 256 * !!! 257 * Historical vi permitted "!!" in an empty file, and it's handled 258 * as a special case in the ex_bang routine. Don't modify this setup 259 * without understanding that one. In particular, note that we're 260 * manipulating the ex argument structures behind ex's back. 261 * 262 * !!! 263 * Historical vi did not permit the '!' command to be associated with 264 * a non-line oriented motion command, in general, although it did 265 * with search commands. So, !f; and !w would fail, but !/;<CR> 266 * would succeed, even if they all moved to the same location in the 267 * current line. I don't see any reason to disallow '!' using any of 268 * the possible motion commands. 269 * 270 * !!! 271 * Historical vi ran the last bang command if N or n was used as the 272 * search motion. 273 */ 274 if (F_ISSET(vp, VC_ISDOT) || 275 ISCMD(vp->rkp, 'N') || ISCMD(vp->rkp, 'n')) { 276 static CHAR_T bang[] = {'!', 0}; 277 ex_cinit(sp, 278 &cmd, C_BANG, 2, vp->m_start.lno, vp->m_stop.lno, 0); 279 EXP(sp)->argsoff = 0; /* XXX */ 280 281 if (argv_exp1(sp, &cmd, bang, 1, 1)) 282 return (1); 283 cmd.argc = EXP(sp)->argsoff; /* XXX */ 284 cmd.argv = EXP(sp)->args; /* XXX */ 285 return (v_exec_ex(sp, vp, &cmd)); 286 } 287 288 /* Get the command from the user. */ 289 if (v_tcmd(sp, vp, 290 '!', TXT_BS | TXT_CR | TXT_ESCAPE | TXT_FILEC | TXT_PROMPT)) 291 return (1); 292 293 /* 294 * Check to see if the user changed their mind. 295 * 296 * !!! 297 * Entering <escape> on an empty line was historically an error, 298 * this implementation doesn't bother. 299 */ 300 tp = TAILQ_FIRST(&sp->tiq); 301 if (tp->term != TERM_OK) { 302 vp->m_final.lno = sp->lno; 303 vp->m_final.cno = sp->cno; 304 return (0); 305 } 306 307 /* Home the cursor. */ 308 vs_home(sp); 309 310 ex_cinit(sp, &cmd, C_BANG, 2, vp->m_start.lno, vp->m_stop.lno, 0); 311 EXP(sp)->argsoff = 0; /* XXX */ 312 313 if (argv_exp1(sp, &cmd, tp->lb + 1, tp->len - 1, 1)) 314 return (1); 315 cmd.argc = EXP(sp)->argsoff; /* XXX */ 316 cmd.argv = EXP(sp)->args; /* XXX */ 317 return (v_exec_ex(sp, vp, &cmd)); 318 } 319 320 /* 321 * v_exec_ex -- 322 * Execute an ex command. 323 * 324 * PUBLIC: int v_exec_ex __P((SCR *, VICMD *, EXCMD *)); 325 */ 326 int 327 v_exec_ex(SCR *sp, VICMD *vp, EXCMD *exp) 328 { 329 int rval; 330 331 rval = exp->cmd->fn(sp, exp); 332 return (v_ex_done(sp, vp) || rval); 333 } 334 335 /* 336 * v_ex -- : 337 * Execute a colon command line. 338 * 339 * PUBLIC: int v_ex __P((SCR *, VICMD *)); 340 */ 341 int 342 v_ex(SCR *sp, VICMD *vp) 343 { 344 WIN *wp; 345 TEXT *tp; 346 int do_cedit, do_resolution, ifcontinue; 347 348 wp = sp->wp; 349 350 /* 351 * !!! 352 * If we put out more than a single line of messages, or ex trashes 353 * the screen, the user may continue entering ex commands. We find 354 * this out when we do the screen/message resolution. We can't enter 355 * completely into ex mode however, because the user can elect to 356 * return into vi mode by entering any key, i.e. we have to be in raw 357 * mode. 358 */ 359 for (do_cedit = do_resolution = 0;;) { 360 /* 361 * !!! 362 * There may already be an ex command waiting to run. If 363 * so, we continue with it. 364 */ 365 if (!EXCMD_RUNNING(wp)) { 366 /* Get a command. */ 367 if (v_tcmd(sp, vp, ':', 368 TXT_BS | TXT_CEDIT | TXT_FILEC | TXT_PROMPT)) 369 return (1); 370 tp = TAILQ_FIRST(&sp->tiq); 371 372 /* 373 * If the user entered a single <esc>, they want to 374 * edit their colon command history. If they already 375 * entered some text, move it into the edit history. 376 */ 377 if (tp->term == TERM_CEDIT) { 378 if (tp->len > 1 && v_ecl_log(sp, tp)) 379 return (1); 380 do_cedit = 1; 381 break; 382 } 383 384 /* If the user didn't enter anything, return. */ 385 if (tp->term == TERM_BS) 386 break; 387 388 /* Log the command. */ 389 if (O_STR(sp, O_CEDIT) != NULL) 390 (void)v_ecl_log(sp, tp); 391 392 /* Push a command on the command stack. */ 393 if (ex_run_str(sp, NULL, tp->lb, tp->len, 0, 1)) 394 return (1); 395 } 396 397 /* Home the cursor. */ 398 vs_home(sp); 399 400 /* 401 * !!! 402 * If the editor wrote the screen behind curses back, put out 403 * a <newline> so that we don't overwrite the user's command 404 * with its output or the next want-to-continue? message. This 405 * doesn't belong here, but I can't find another place to put 406 * it. See, we resolved the output from the last ex command, 407 * and the user entered another one. This is the only place 408 * where we have control before the ex command writes output. 409 * We could get control in vs_msg(), but we have no way to know 410 * if command didn't put out any output when we try and resolve 411 * this command. This fixes a bug where combinations of ex 412 * commands, e.g. ":set<CR>:!date<CR>:set" didn't look right. 413 */ 414 if (F_ISSET(sp, SC_SCR_EXWROTE)) 415 (void)putchar('\n'); 416 417 /* Call the ex parser. */ 418 (void)ex_cmd(sp); 419 420 /* Flush ex messages. */ 421 (void)ex_fflush(sp); 422 423 /* Resolve any messages. */ 424 if (vs_ex_resolve(sp, &ifcontinue)) 425 return (1); 426 427 /* 428 * Continue or return. If continuing, make sure that we 429 * eventually do resolution. 430 */ 431 if (!ifcontinue) 432 break; 433 do_resolution = 1; 434 435 /* If we're continuing, it's a new command. */ 436 ++sp->ccnt; 437 } 438 439 /* 440 * If the user previously continued an ex command, we have to do 441 * resolution to clean up the screen. Don't wait, we already did 442 * that. 443 */ 444 if (do_resolution) { 445 F_SET(sp, SC_EX_WAIT_NO); 446 if (vs_ex_resolve(sp, &ifcontinue)) 447 return (1); 448 } 449 450 /* Cleanup from the ex command. */ 451 if (v_ex_done(sp, vp)) 452 return (1); 453 454 /* The user may want to edit their colon command history. */ 455 if (do_cedit) 456 return (v_ecl(sp)); 457 458 return (0); 459 } 460 461 /* 462 * v_ex_done -- 463 * Cleanup from an ex command. 464 */ 465 static int 466 v_ex_done(SCR *sp, VICMD *vp) 467 { 468 size_t len; 469 470 /* 471 * The only cursor modifications are real, however, the underlying 472 * line may have changed; don't trust anything. This code has been 473 * a remarkably fertile place for bugs. Do a reality check on a 474 * cursor value, and make sure it's okay. If necessary, change it. 475 * Ex keeps track of the line number, but it cares less about the 476 * column and it may have disappeared. 477 * 478 * Don't trust ANYTHING. 479 * 480 * XXX 481 * Ex will soon have to start handling the column correctly; see 482 * the POSIX 1003.2 standard. 483 */ 484 if (db_eget(sp, sp->lno, NULL, &len, NULL)) { 485 sp->lno = 1; 486 sp->cno = 0; 487 } else if (sp->cno >= len) 488 sp->cno = len ? len - 1 : 0; 489 490 vp->m_final.lno = sp->lno; 491 vp->m_final.cno = sp->cno; 492 493 /* 494 * Don't re-adjust the cursor after executing an ex command, 495 * and ex movements are permanent. 496 */ 497 F_CLR(vp, VM_RCM_MASK); 498 F_SET(vp, VM_RCM_SET); 499 500 return (0); 501 } 502 503 /* 504 * v_ecl -- 505 * Start an edit window on the colon command-line commands. 506 */ 507 static int 508 v_ecl(SCR *sp) 509 { 510 GS *gp; 511 WIN *wp; 512 SCR *new; 513 514 /* Initialize the screen, if necessary. */ 515 gp = sp->gp; 516 wp = sp->wp; 517 if (wp->ccl_sp == NULL && v_ecl_init(sp)) 518 return (1); 519 520 /* Get a new screen. */ 521 if (screen_init(gp, sp, &new)) 522 return (1); 523 if (vs_split(sp, new, 1)) { 524 (void)screen_fini(new); 525 return (1); 526 } 527 528 /* Attach to the screen. */ 529 new->ep = wp->ccl_sp->ep; 530 ++new->ep->refcnt; 531 TAILQ_INSERT_HEAD(&new->ep->scrq, new, eq); 532 533 new->frp = wp->ccl_sp->frp; 534 new->frp->flags = sp->frp->flags; 535 new->conv = wp->ccl_sp->conv; 536 537 /* Move the cursor to the end. */ 538 (void)db_last(new, &new->lno); 539 if (new->lno == 0) 540 new->lno = 1; 541 542 /* Remember the originating window. */ 543 sp->ccl_parent = sp; 544 545 /* It's a special window. */ 546 F_SET(new, SC_COMEDIT); 547 548 /* Don't encode on writing to DB. */ 549 o_set(new, O_FILEENCODING, OS_STRDUP, "WCHAR_T", 0); 550 551 /* Set up the switch. */ 552 sp->nextdisp = new; 553 F_SET(sp, SC_SSWITCH); 554 return (0); 555 } 556 557 /* 558 * v_ecl_exec -- 559 * Execute a command from a colon command-line window. 560 * 561 * PUBLIC: int v_ecl_exec __P((SCR *)); 562 */ 563 int 564 v_ecl_exec(SCR *sp) 565 { 566 size_t len; 567 CHAR_T *p; 568 569 if (db_get(sp, sp->lno, 0, &p, &len) && sp->lno == 1) { 570 v_emsg(sp, NULL, VIM_EMPTY); 571 return (1); 572 } 573 if (len == 0) { 574 msgq(sp, M_BERR, "307|No ex command to execute"); 575 return (1); 576 } 577 578 /* Push the command on the command stack. */ 579 if (ex_run_str(sp, NULL, p, len, 0, 0)) 580 return (1); 581 582 /* Set up the switch. */ 583 sp->nextdisp = sp->ccl_parent; 584 F_SET(sp, SC_EXIT); 585 return (0); 586 } 587 588 /* 589 * v_ecl_log -- 590 * Log a command into the colon command-line log file. 591 */ 592 static int 593 v_ecl_log(SCR *sp, TEXT *tp) 594 { 595 db_recno_t lno; 596 int rval; 597 CHAR_T *p; 598 size_t len; 599 SCR *ccl_sp; 600 601 /* Initialize the screen, if necessary. */ 602 if (sp->wp->ccl_sp == NULL && v_ecl_init(sp)) 603 return (1); 604 605 ccl_sp = sp->wp->ccl_sp; 606 607 /* 608 * Don't log colon command window commands into the colon command 609 * window... 610 */ 611 if (sp->ep == ccl_sp->ep) 612 return (0); 613 614 if (db_last(ccl_sp, &lno)) { 615 return (1); 616 } 617 /* Don't log line that is identical to previous one */ 618 if (lno > 0 && 619 !db_get(ccl_sp, lno, 0, &p, &len) && 620 len == tp->len && 621 !MEMCMP(tp->lb, p, len)) 622 rval = 0; 623 else { 624 rval = db_append(ccl_sp, 0, lno, tp->lb, tp->len); 625 /* XXXX end "transaction" on ccl */ 626 /* Is this still necessary now that we no longer hijack sp ? */ 627 log_cursor(ccl_sp); 628 } 629 630 return (rval); 631 } 632 633 /* 634 * v_ecl_init -- 635 * Initialize the colon command-line log file. 636 */ 637 static int 638 v_ecl_init(SCR *sp) 639 { 640 FREF *frp; 641 GS *gp; 642 WIN *wp; 643 644 gp = sp->gp; 645 wp = sp->wp; 646 647 /* Get a temporary file. */ 648 if ((frp = file_add(sp, NULL)) == NULL) 649 return (1); 650 651 /* 652 * XXX 653 * Create a screen -- the file initialization code wants one. 654 */ 655 if (screen_init(gp, sp, &wp->ccl_sp)) 656 return (1); 657 conv_enc(wp->ccl_sp, O_FILEENCODING, "WCHAR_T"); 658 if (file_init(wp->ccl_sp, frp, NULL, 0)) { 659 (void)screen_fini(wp->ccl_sp); 660 wp->ccl_sp = 0; 661 return (1); 662 } 663 664 /* The underlying file isn't recoverable. */ 665 F_CLR(wp->ccl_sp->ep, F_RCV_ON); 666 667 return (0); 668 } 669
Indexes created Mon May 25 00:24:39 UTC 2026