ex.c revision 19304
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 13static const char sccsid[] = "@(#)ex.c 10.57 (Berkeley) 10/10/96"; 14#endif /* not lint */ 15 16#include <sys/types.h> 17#include <sys/queue.h> 18#include <sys/stat.h> 19#include <sys/time.h> 20 21#include <bitstring.h> 22#include <ctype.h> 23#include <errno.h> 24#include <fcntl.h> 25#include <limits.h> 26#include <stdio.h> 27#include <stdlib.h> 28#include <string.h> 29#include <unistd.h> 30 31#include "../common/common.h" 32#include "../vi/vi.h" 33 34#if defined(DEBUG) && defined(COMLOG) 35static void ex_comlog __P((SCR *, EXCMD *)); 36#endif 37static EXCMDLIST const * 38 ex_comm_search __P((char *, size_t)); 39static int ex_discard __P((SCR *)); 40static int ex_line __P((SCR *, EXCMD *, MARK *, int *, int *)); 41static int ex_load __P((SCR *)); 42static void ex_unknown __P((SCR *, char *, size_t)); 43 44/* 45 * ex -- 46 * Main ex loop. 47 * 48 * PUBLIC: int ex __P((SCR **)); 49 */ 50int 51ex(spp) 52 SCR **spp; 53{ 54 EX_PRIVATE *exp; 55 GS *gp; 56 MSGS *mp; 57 SCR *sp; 58 TEXT *tp; 59 u_int32_t flags; 60 61 sp = *spp; 62 gp = sp->gp; 63 exp = EXP(sp); 64 65 /* Start the ex screen. */ 66 if (ex_init(sp)) 67 return (1); 68 69 /* Flush any saved messages. */ 70 while ((mp = gp->msgq.lh_first) != NULL) { 71 gp->scr_msg(sp, mp->mtype, mp->buf, mp->len); 72 LIST_REMOVE(mp, q); 73 free(mp->buf); 74 free(mp); 75 } 76 77 /* If reading from a file, errors should have name and line info. */ 78 if (F_ISSET(gp, G_SCRIPTED)) { 79 gp->excmd.if_lno = 1; 80 gp->excmd.if_name = "script"; 81 } 82 83 /* 84 * !!! 85 * Initialize the text flags. The beautify edit option historically 86 * applied to ex command input read from a file. In addition, the 87 * first time a ^H was discarded from the input, there was a message, 88 * "^H discarded", that was displayed. We don't bother. 89 */ 90 LF_INIT(TXT_BACKSLASH | TXT_CNTRLD | TXT_CR); 91 for (;; ++gp->excmd.if_lno) { 92 /* Display status line and flush. */ 93 if (F_ISSET(sp, SC_STATUS)) { 94 if (!F_ISSET(sp, SC_EX_SILENT)) 95 msgq_status(sp, sp->lno, 0); 96 F_CLR(sp, SC_STATUS); 97 } 98 (void)ex_fflush(sp); 99 100 /* Set the flags the user can reset. */ 101 if (O_ISSET(sp, O_BEAUTIFY)) 102 LF_SET(TXT_BEAUTIFY); 103 if (O_ISSET(sp, O_PROMPT)) 104 LF_SET(TXT_PROMPT); 105 106 /* Clear any current interrupts, and get a command. */ 107 CLR_INTERRUPT(sp); 108 if (ex_txt(sp, &sp->tiq, ':', flags)) 109 return (1); 110 if (INTERRUPTED(sp)) { 111 (void)ex_puts(sp, "\n"); 112 (void)ex_fflush(sp); 113 continue; 114 } 115 116 /* Initialize the command structure. */ 117 CLEAR_EX_PARSER(&gp->excmd); 118 119 /* 120 * If the user entered a single carriage return, send 121 * ex_cmd() a separator -- it discards single newlines. 122 */ 123 tp = sp->tiq.cqh_first; 124 if (tp->len == 0) { 125 gp->excmd.cp = " "; /* __TK__ why not |? */ 126 gp->excmd.clen = 1; 127 } else { 128 gp->excmd.cp = tp->lb; 129 gp->excmd.clen = tp->len; 130 } 131 F_INIT(&gp->excmd, E_NRSEP); 132 133 if (ex_cmd(sp) && F_ISSET(gp, G_SCRIPTED)) 134 return (1); 135 136 if (INTERRUPTED(sp)) { 137 CLR_INTERRUPT(sp); 138 msgq(sp, M_ERR, "170|Interrupted"); 139 } 140 141 /* 142 * If the last command caused a restart, or switched screens 143 * or into vi, return. 144 */ 145 if (F_ISSET(gp, G_SRESTART) || F_ISSET(sp, SC_SSWITCH | SC_VI)) { 146 *spp = sp; 147 break; 148 } 149 150 /* If the last command switched files, we don't care. */ 151 F_CLR(sp, SC_FSWITCH); 152 153 /* 154 * If we're exiting this screen, move to the next one. By 155 * definition, this means returning into vi, so return to the 156 * main editor loop. The ordering is careful, don't discard 157 * the contents of sp until the end. 158 */ 159 if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE)) { 160 if (file_end(sp, NULL, F_ISSET(sp, SC_EXIT_FORCE))) 161 return (1); 162 *spp = screen_next(sp); 163 return (screen_end(sp)); 164 } 165 } 166 return (0); 167} 168 169/* 170 * ex_cmd -- 171 * The guts of the ex parser: parse and execute a string containing 172 * ex commands. 173 * 174 * !!! 175 * This code MODIFIES the string that gets passed in, to delete quoting 176 * characters, etc. The string cannot be readonly/text space, nor should 177 * you expect to use it again after ex_cmd() returns. 178 * 179 * !!! 180 * For the fun of it, if you want to see if a vi clone got the ex argument 181 * parsing right, try: 182 * 183 * echo 'foo|bar' > file1; echo 'foo/bar' > file2; 184 * vi 185 * :edit +1|s/|/PIPE/|w file1| e file2|1 | s/\//SLASH/|wq 186 * 187 * or: vi 188 * :set|file|append|set|file 189 * 190 * For extra credit, try them in a startup .exrc file. 191 * 192 * PUBLIC: int ex_cmd __P((SCR *)); 193 */ 194int 195ex_cmd(sp) 196 SCR *sp; 197{ 198 enum nresult nret; 199 EX_PRIVATE *exp; 200 EXCMD *ecp; 201 GS *gp; 202 MARK cur; 203 recno_t lno; 204 size_t arg1_len, discard, len; 205 u_int32_t flags; 206 long ltmp; 207 int at_found, gv_found; 208 int ch, cnt, delim, isaddr, namelen; 209 int newscreen, notempty, tmp, vi_address; 210 char *arg1, *p, *s, *t; 211 212 gp = sp->gp; 213 exp = EXP(sp); 214 215 /* 216 * We always start running the command on the top of the stack. 217 * This means that *everything* must be resolved when we leave 218 * this function for any reason. 219 */ 220loop: ecp = gp->ecq.lh_first; 221 222 /* If we're reading a command from a file, set up error information. */ 223 if (ecp->if_name != NULL) { 224 gp->if_lno = ecp->if_lno; 225 gp->if_name = ecp->if_name; 226 } 227 228 /* 229 * If a move to the end of the file is scheduled for this command, 230 * do it now. 231 */ 232 if (F_ISSET(ecp, E_MOVETOEND)) { 233 if (db_last(sp, &sp->lno)) 234 goto rfail; 235 sp->cno = 0; 236 F_CLR(ecp, E_MOVETOEND); 237 } 238 239 /* If we found a newline, increment the count now. */ 240 if (F_ISSET(ecp, E_NEWLINE)) { 241 ++gp->if_lno; 242 ++ecp->if_lno; 243 F_CLR(ecp, E_NEWLINE); 244 } 245 246 /* (Re)initialize the EXCMD structure, preserving some flags. */ 247 CLEAR_EX_CMD(ecp); 248 249 /* Initialize the argument structures. */ 250 if (argv_init(sp, ecp)) 251 goto err; 252 253 /* Initialize +cmd, saved command information. */ 254 arg1 = NULL; 255 ecp->save_cmdlen = 0; 256 257 /* Skip <blank>s, empty lines. */ 258 for (notempty = 0; ecp->clen > 0; ++ecp->cp, --ecp->clen) 259 if ((ch = *ecp->cp) == '\n') { 260 ++gp->if_lno; 261 ++ecp->if_lno; 262 } else if (isblank(ch)) 263 notempty = 1; 264 else 265 break; 266 267 /* 268 * !!! 269 * Permit extra colons at the start of the line. Historically, 270 * ex/vi allowed a single extra one. It's simpler not to count. 271 * The stripping is done here because, historically, any command 272 * could have preceding colons, e.g. ":g/pattern/:p" worked. 273 */ 274 if (ecp->clen != 0 && ch == ':') { 275 notempty = 1; 276 while (--ecp->clen > 0 && (ch = *++ecp->cp) == ':'); 277 } 278 279 /* 280 * Command lines that start with a double-quote are comments. 281 * 282 * !!! 283 * Historically, there was no escape or delimiter for a comment, e.g. 284 * :"foo|set was a single comment and nothing was output. Since nvi 285 * permits users to escape <newline> characters into command lines, we 286 * have to check for that case. 287 */ 288 if (ecp->clen != 0 && ch == '"') { 289 while (--ecp->clen > 0 && *++ecp->cp != '\n'); 290 if (*ecp->cp == '\n') { 291 F_SET(ecp, E_NEWLINE); 292 ++ecp->cp; 293 --ecp->clen; 294 } 295 goto loop; 296 } 297 298 /* Skip whitespace. */ 299 for (; ecp->clen > 0; ++ecp->cp, --ecp->clen) { 300 ch = *ecp->cp; 301 if (!isblank(ch)) 302 break; 303 } 304 305 /* 306 * The last point at which an empty line can mean do nothing. 307 * 308 * !!! 309 * Historically, in ex mode, lines containing only <blank> characters 310 * were the same as a single <carriage-return>, i.e. a default command. 311 * In vi mode, they were ignored. In .exrc files this was a serious 312 * annoyance, as vi kept trying to treat them as print commands. We 313 * ignore backward compatibility in this case, discarding lines that 314 * contain only <blank> characters from .exrc files. 315 * 316 * !!! 317 * This is where you end up when you're done a command, i.e. clen has 318 * gone to zero. Continue if there are more commands to run. 319 */ 320 if (ecp->clen == 0 && 321 (!notempty || F_ISSET(sp, SC_VI) || F_ISSET(ecp, E_BLIGNORE))) { 322 if (ex_load(sp)) 323 goto rfail; 324 ecp = gp->ecq.lh_first; 325 if (ecp->clen == 0) 326 goto rsuccess; 327 goto loop; 328 } 329 330 /* 331 * Check to see if this is a command for which we may want to move 332 * the cursor back up to the previous line. (The command :1<CR> 333 * wants a <newline> separator, but the command :<CR> wants to erase 334 * the command line.) If the line is empty except for <blank>s, 335 * <carriage-return> or <eof>, we'll probably want to move up. I 336 * don't think there's any way to get <blank> characters *after* the 337 * command character, but this is the ex parser, and I've been wrong 338 * before. 339 */ 340 if (F_ISSET(ecp, E_NRSEP) && 341 ecp->clen != 0 && (ecp->clen != 1 || ecp->cp[0] != '\004')) 342 F_CLR(ecp, E_NRSEP); 343 344 /* Parse command addresses. */ 345 if (ex_range(sp, ecp, &tmp)) 346 goto rfail; 347 if (tmp) 348 goto err; 349 350 /* 351 * Skip <blank>s and any more colons (the command :3,5:print 352 * worked, historically). 353 */ 354 for (; ecp->clen > 0; ++ecp->cp, --ecp->clen) { 355 ch = *ecp->cp; 356 if (!isblank(ch) && ch != ':') 357 break; 358 } 359 360 /* 361 * If no command, ex does the last specified of p, l, or #, and vi 362 * moves to the line. Otherwise, determine the length of the command 363 * name by looking for the first non-alphabetic character. (There 364 * are a few non-alphabetic characters in command names, but they're 365 * all single character commands.) This isn't a great test, because 366 * it means that, for the command ":e +cut.c file", we'll report that 367 * the command "cut" wasn't known. However, it makes ":e+35 file" work 368 * correctly. 369 * 370 * !!! 371 * Historically, lines with multiple adjacent (or <blank> separated) 372 * command separators were very strange. For example, the command 373 * |||<carriage-return>, when the cursor was on line 1, displayed 374 * lines 2, 3 and 5 of the file. In addition, the command " | " 375 * would only display the line after the next line, instead of the 376 * next two lines. No ideas why. It worked reasonably when executed 377 * from vi mode, and displayed lines 2, 3, and 4, so we do a default 378 * command for each separator. 379 */ 380#define SINGLE_CHAR_COMMANDS "\004!#&*<=>@~" 381 newscreen = 0; 382 if (ecp->clen != 0 && ecp->cp[0] != '|' && ecp->cp[0] != '\n') { 383 if (strchr(SINGLE_CHAR_COMMANDS, *ecp->cp)) { 384 p = ecp->cp; 385 ++ecp->cp; 386 --ecp->clen; 387 namelen = 1; 388 } else { 389 for (p = ecp->cp; 390 ecp->clen > 0; --ecp->clen, ++ecp->cp) 391 if (!isalpha(*ecp->cp)) 392 break; 393 if ((namelen = ecp->cp - p) == 0) { 394 msgq(sp, M_ERR, "080|Unknown command name"); 395 goto err; 396 } 397 } 398 399 /* 400 * !!! 401 * Historic vi permitted flags to immediately follow any 402 * subset of the 'delete' command, but then did not permit 403 * further arguments (flag, buffer, count). Make it work. 404 * Permit further arguments for the few shreds of dignity 405 * it offers. 406 * 407 * Adding commands that start with 'd', and match "delete" 408 * up to a l, p, +, - or # character can break this code. 409 * 410 * !!! 411 * Capital letters beginning the command names ex, edit, 412 * next, previous, tag and visual (in vi mode) indicate the 413 * command should happen in a new screen. 414 */ 415 switch (p[0]) { 416 case 'd': 417 for (s = p, 418 t = cmds[C_DELETE].name; *s == *t; ++s, ++t); 419 if (s[0] == 'l' || s[0] == 'p' || s[0] == '+' || 420 s[0] == '-' || s[0] == '^' || s[0] == '#') { 421 len = (ecp->cp - p) - (s - p); 422 ecp->cp -= len; 423 ecp->clen += len; 424 ecp->rcmd = cmds[C_DELETE]; 425 ecp->rcmd.syntax = "1bca1"; 426 ecp->cmd = &ecp->rcmd; 427 goto skip_srch; 428 } 429 break; 430 case 'E': case 'F': case 'N': case 'P': case 'T': case 'V': 431 newscreen = 1; 432 p[0] = tolower(p[0]); 433 break; 434 } 435 436 /* 437 * Search the table for the command. 438 * 439 * !!! 440 * Historic vi permitted the mark to immediately follow the 441 * 'k' in the 'k' command. Make it work. 442 * 443 * !!! 444 * Historic vi permitted any flag to follow the s command, e.g. 445 * "s/e/E/|s|sgc3p" was legal. Make the command "sgc" work. 446 * Since the following characters all have to be flags, i.e. 447 * alphabetics, we can let the s command routine return errors 448 * if it was some illegal command string. This code will break 449 * if an "sg" or similar command is ever added. The substitute 450 * code doesn't care if it's a "cgr" flag or a "#lp" flag that 451 * follows the 's', but we limit the choices here to "cgr" so 452 * that we get unknown command messages for wrong combinations. 453 */ 454 if ((ecp->cmd = ex_comm_search(p, namelen)) == NULL) 455 switch (p[0]) { 456 case 'k': 457 if (namelen == 2) { 458 ecp->cp -= namelen - 1; 459 ecp->clen += namelen - 1; 460 ecp->cmd = &cmds[C_K]; 461 break; 462 } 463 goto unknown; 464 case 's': 465 for (s = p + 1, cnt = namelen; --cnt; ++s) 466 if (s[0] != 'c' && 467 s[0] != 'g' && s[0] != 'r') 468 break; 469 if (cnt == 0) { 470 ecp->cp -= namelen - 1; 471 ecp->clen += namelen - 1; 472 ecp->rcmd = cmds[C_SUBSTITUTE]; 473 ecp->rcmd.fn = ex_subagain; 474 ecp->cmd = &ecp->rcmd; 475 break; 476 } 477 /* FALLTHROUGH */ 478 default: 479unknown: if (newscreen) 480 p[0] = toupper(p[0]); 481 ex_unknown(sp, p, namelen); 482 goto err; 483 } 484 485 /* 486 * The visual command has a different syntax when called 487 * from ex than when called from a vi colon command. FMH. 488 * Make the change now, before we test for the newscreen 489 * semantic, so that we're testing the right one. 490 */ 491skip_srch: if (ecp->cmd == &cmds[C_VISUAL_EX] && F_ISSET(sp, SC_VI)) 492 ecp->cmd = &cmds[C_VISUAL_VI]; 493 494 /* 495 * !!! 496 * Historic vi permitted a capital 'P' at the beginning of 497 * any command that started with 'p'. Probably wanted the 498 * P[rint] command for backward compatibility, and the code 499 * just made Preserve and Put work by accident. Nvi uses 500 * Previous to mean previous-in-a-new-screen, so be careful. 501 */ 502 if (newscreen && !F_ISSET(ecp->cmd, E_NEWSCREEN) && 503 (ecp->cmd == &cmds[C_PRINT] || 504 ecp->cmd == &cmds[C_PRESERVE])) 505 newscreen = 0; 506 507 /* Test for a newscreen associated with this command. */ 508 if (newscreen && !F_ISSET(ecp->cmd, E_NEWSCREEN)) 509 goto unknown; 510 511 /* Secure means no shell access. */ 512 if (F_ISSET(ecp->cmd, E_SECURE) && O_ISSET(sp, O_SECURE)) { 513 ex_emsg(sp, ecp->cmd->name, EXM_SECURE); 514 goto err; 515 } 516 517 /* 518 * Multiple < and > characters; another "feature". Note, 519 * The string passed to the underlying function may not be 520 * nul terminated in this case. 521 */ 522 if ((ecp->cmd == &cmds[C_SHIFTL] && *p == '<') || 523 (ecp->cmd == &cmds[C_SHIFTR] && *p == '>')) { 524 for (ch = *p; 525 ecp->clen > 0; --ecp->clen, ++ecp->cp) 526 if (*ecp->cp != ch) 527 break; 528 if (argv_exp0(sp, ecp, p, ecp->cp - p)) 529 goto err; 530 } 531 532 /* Set the format style flags for the next command. */ 533 if (ecp->cmd == &cmds[C_HASH]) 534 exp->fdef = E_C_HASH; 535 else if (ecp->cmd == &cmds[C_LIST]) 536 exp->fdef = E_C_LIST; 537 else if (ecp->cmd == &cmds[C_PRINT]) 538 exp->fdef = E_C_PRINT; 539 F_CLR(ecp, E_USELASTCMD); 540 } else { 541 /* Print is the default command. */ 542 ecp->cmd = &cmds[C_PRINT]; 543 544 /* Set the saved format flags. */ 545 F_SET(ecp, exp->fdef); 546 547 /* 548 * !!! 549 * If no address was specified, and it's not a global command, 550 * we up the address by one. (I have no idea why globals are 551 * exempted, but it's (ahem) historic practice.) 552 */ 553 if (ecp->addrcnt == 0 && !F_ISSET(sp, SC_EX_GLOBAL)) { 554 ecp->addrcnt = 1; 555 ecp->addr1.lno = sp->lno + 1; 556 ecp->addr1.cno = sp->cno; 557 } 558 559 F_SET(ecp, E_USELASTCMD); 560 } 561 562 /* 563 * !!! 564 * Historically, the number option applied to both ex and vi. One 565 * strangeness was that ex didn't switch display formats until a 566 * command was entered, e.g. <CR>'s after the set didn't change to 567 * the new format, but :1p would. 568 */ 569 if (O_ISSET(sp, O_NUMBER)) { 570 F_SET(ecp, E_OPTNUM); 571 FL_SET(ecp->iflags, E_C_HASH); 572 } else 573 F_CLR(ecp, E_OPTNUM); 574 575 /* Check for ex mode legality. */ 576 if (F_ISSET(sp, SC_EX) && (F_ISSET(ecp->cmd, E_VIONLY) || newscreen)) { 577 msgq(sp, M_ERR, 578 "082|%s: command not available in ex mode", ecp->cmd->name); 579 goto err; 580 } 581 582 /* Add standard command flags. */ 583 F_SET(ecp, ecp->cmd->flags); 584 if (!newscreen) 585 F_CLR(ecp, E_NEWSCREEN); 586 587 /* 588 * There are three normal termination cases for an ex command. They 589 * are the end of the string (ecp->clen), or unescaped (by <literal 590 * next> characters) <newline> or '|' characters. As we're now past 591 * possible addresses, we can determine how long the command is, so we 592 * don't have to look for all the possible terminations. Naturally, 593 * there are some exciting special cases: 594 * 595 * 1: The bang, global, v and the filter versions of the read and 596 * write commands are delimited by <newline>s (they can contain 597 * shell pipes). 598 * 2: The ex, edit, next and visual in vi mode commands all take ex 599 * commands as their first arguments. 600 * 3: The s command takes an RE as its first argument, and wants it 601 * to be specially delimited. 602 * 603 * Historically, '|' characters in the first argument of the ex, edit, 604 * next, vi visual, and s commands didn't delimit the command. And, 605 * in the filter cases for read and write, and the bang, global and v 606 * commands, they did not delimit the command at all. 607 * 608 * For example, the following commands were legal: 609 * 610 * :edit +25|s/abc/ABC/ file.c 611 * :s/|/PIPE/ 612 * :read !spell % | columnate 613 * :global/pattern/p|l 614 * 615 * It's not quite as simple as it sounds, however. The command: 616 * 617 * :s/a/b/|s/c/d|set 618 * 619 * was also legal, i.e. the historic ex parser (using the word loosely, 620 * since "parser" implies some regularity of syntax) delimited the RE's 621 * based on its delimiter and not anything so irretrievably vulgar as a 622 * command syntax. 623 * 624 * Anyhow, the following code makes this all work. First, for the 625 * special cases we move past their special argument(s). Then, we 626 * do normal command processing on whatever is left. Barf-O-Rama. 627 */ 628 discard = 0; /* Characters discarded from the command. */ 629 arg1_len = 0; 630 ecp->save_cmd = ecp->cp; 631 if (ecp->cmd == &cmds[C_EDIT] || ecp->cmd == &cmds[C_EX] || 632 ecp->cmd == &cmds[C_NEXT] || ecp->cmd == &cmds[C_VISUAL_VI]) { 633 /* 634 * Move to the next non-whitespace character. A '!' 635 * immediately following the command is eaten as a 636 * force flag. 637 */ 638 if (ecp->clen > 0 && *ecp->cp == '!') { 639 ++ecp->cp; 640 --ecp->clen; 641 FL_SET(ecp->iflags, E_C_FORCE); 642 643 /* Reset, don't reparse. */ 644 ecp->save_cmd = ecp->cp; 645 } 646 for (; ecp->clen > 0; --ecp->clen, ++ecp->cp) 647 if (!isblank(*ecp->cp)) 648 break; 649 /* 650 * QUOTING NOTE: 651 * 652 * The historic implementation ignored all escape characters 653 * so there was no way to put a space or newline into the +cmd 654 * field. We do a simplistic job of fixing it by moving to the 655 * first whitespace character that isn't escaped. The escaping 656 * characters are stripped as no longer useful. 657 */ 658 if (ecp->clen > 0 && *ecp->cp == '+') { 659 ++ecp->cp; 660 --ecp->clen; 661 for (arg1 = p = ecp->cp; 662 ecp->clen > 0; --ecp->clen, ++ecp->cp) { 663 ch = *ecp->cp; 664 if (IS_ESCAPE(sp, ecp, ch) && 665 ecp->clen > 1) { 666 ++discard; 667 --ecp->clen; 668 ch = *++ecp->cp; 669 } else if (isblank(ch)) 670 break; 671 *p++ = ch; 672 } 673 arg1_len = ecp->cp - arg1; 674 675 /* Reset, so the first argument isn't reparsed. */ 676 ecp->save_cmd = ecp->cp; 677 } 678 } else if (ecp->cmd == &cmds[C_BANG] || 679 ecp->cmd == &cmds[C_GLOBAL] || ecp->cmd == &cmds[C_V]) { 680 /* 681 * QUOTING NOTE: 682 * 683 * We use backslashes to escape <newline> characters, although 684 * this wasn't historic practice for the bang command. It was 685 * for the global and v commands, and it's common usage when 686 * doing text insert during the command. Escaping characters 687 * are stripped as no longer useful. 688 */ 689 for (p = ecp->cp; ecp->clen > 0; --ecp->clen, ++ecp->cp) { 690 ch = *ecp->cp; 691 if (ch == '\\' && ecp->clen > 1 && ecp->cp[1] == '\n') { 692 ++discard; 693 --ecp->clen; 694 ch = *++ecp->cp; 695 696 ++gp->if_lno; 697 ++ecp->if_lno; 698 } else if (ch == '\n') 699 break; 700 *p++ = ch; 701 } 702 } else if (ecp->cmd == &cmds[C_READ] || ecp->cmd == &cmds[C_WRITE]) { 703 /* 704 * For write commands, if the next character is a <blank>, and 705 * the next non-blank character is a '!', it's a filter command 706 * and we want to eat everything up to the <newline>. For read 707 * commands, if the next non-blank character is a '!', it's a 708 * filter command and we want to eat everything up to the next 709 * <newline>. Otherwise, we're done. 710 */ 711 for (tmp = 0; ecp->clen > 0; --ecp->clen, ++ecp->cp) { 712 ch = *ecp->cp; 713 if (isblank(ch)) 714 tmp = 1; 715 else 716 break; 717 } 718 if (ecp->clen > 0 && ch == '!' && 719 (ecp->cmd == &cmds[C_READ] || tmp)) 720 for (; ecp->clen > 0; --ecp->clen, ++ecp->cp) 721 if (ecp->cp[0] == '\n') 722 break; 723 } else if (ecp->cmd == &cmds[C_SUBSTITUTE]) { 724 /* 725 * Move to the next non-whitespace character, we'll use it as 726 * the delimiter. If the character isn't an alphanumeric or 727 * a '|', it's the delimiter, so parse it. Otherwise, we're 728 * into something like ":s g", so use the special s command. 729 */ 730 for (; ecp->clen > 0; --ecp->clen, ++ecp->cp) 731 if (!isblank(ecp->cp[0])) 732 break; 733 734 if (isalnum(ecp->cp[0]) || ecp->cp[0] == '|') { 735 ecp->rcmd = cmds[C_SUBSTITUTE]; 736 ecp->rcmd.fn = ex_subagain; 737 ecp->cmd = &ecp->rcmd; 738 } else if (ecp->clen > 0) { 739 /* 740 * QUOTING NOTE: 741 * 742 * Backslashes quote delimiter characters for RE's. 743 * The backslashes are NOT removed since they'll be 744 * used by the RE code. Move to the third delimiter 745 * that's not escaped (or the end of the command). 746 */ 747 delim = *ecp->cp; 748 ++ecp->cp; 749 --ecp->clen; 750 for (cnt = 2; ecp->clen > 0 && 751 cnt != 0; --ecp->clen, ++ecp->cp) 752 if (ecp->cp[0] == '\\' && 753 ecp->clen > 1) { 754 ++ecp->cp; 755 --ecp->clen; 756 } else if (ecp->cp[0] == delim) 757 --cnt; 758 } 759 } 760 761 /* 762 * Use normal quoting and termination rules to find the end of this 763 * command. 764 * 765 * QUOTING NOTE: 766 * 767 * Historically, vi permitted ^V's to escape <newline>'s in the .exrc 768 * file. It was almost certainly a bug, but that's what bug-for-bug 769 * compatibility means, Grasshopper. Also, ^V's escape the command 770 * delimiters. Literal next quote characters in front of the newlines, 771 * '|' characters or literal next characters are stripped as they're 772 * no longer useful. 773 */ 774 vi_address = ecp->clen != 0 && ecp->cp[0] != '\n'; 775 for (p = ecp->cp; ecp->clen > 0; --ecp->clen, ++ecp->cp) { 776 ch = ecp->cp[0]; 777 if (IS_ESCAPE(sp, ecp, ch) && ecp->clen > 1) { 778 tmp = ecp->cp[1]; 779 if (tmp == '\n' || tmp == '|') { 780 if (tmp == '\n') { 781 ++gp->if_lno; 782 ++ecp->if_lno; 783 } 784 ++discard; 785 --ecp->clen; 786 ++ecp->cp; 787 ch = tmp; 788 } 789 } else if (ch == '\n' || ch == '|') { 790 if (ch == '\n') 791 F_SET(ecp, E_NEWLINE); 792 --ecp->clen; 793 break; 794 } 795 *p++ = ch; 796 } 797 798 /* 799 * Save off the next command information, go back to the 800 * original start of the command. 801 */ 802 p = ecp->cp + 1; 803 ecp->cp = ecp->save_cmd; 804 ecp->save_cmd = p; 805 ecp->save_cmdlen = ecp->clen; 806 ecp->clen = ((ecp->save_cmd - ecp->cp) - 1) - discard; 807 808 /* 809 * QUOTING NOTE: 810 * 811 * The "set tags" command historically used a backslash, not the 812 * user's literal next character, to escape whitespace. Handle 813 * it here instead of complicating the argv_exp3() code. Note, 814 * this isn't a particularly complex trap, and if backslashes were 815 * legal in set commands, this would have to be much more complicated. 816 */ 817 if (ecp->cmd == &cmds[C_SET]) 818 for (p = ecp->cp, len = ecp->clen; len > 0; --len, ++p) 819 if (*p == '\\') 820 *p = CH_LITERAL; 821 822 /* 823 * Set the default addresses. It's an error to specify an address for 824 * a command that doesn't take them. If two addresses are specified 825 * for a command that only takes one, lose the first one. Two special 826 * cases here, some commands take 0 or 2 addresses. For most of them 827 * (the E_ADDR2_ALL flag), 0 defaults to the entire file. For one 828 * (the `!' command, the E_ADDR2_NONE flag), 0 defaults to no lines. 829 * 830 * Also, if the file is empty, some commands want to use an address of 831 * 0, i.e. the entire file is 0 to 0, and the default first address is 832 * 0. Otherwise, an entire file is 1 to N and the default line is 1. 833 * Note, we also add the E_ADDR_ZERO flag to the command flags, for the 834 * case where the 0 address is only valid if it's a default address. 835 * 836 * Also, set a flag if we set the default addresses. Some commands 837 * (ex: z) care if the user specified an address or if we just used 838 * the current cursor. 839 */ 840 switch (F_ISSET(ecp, E_ADDR1 | E_ADDR2 | E_ADDR2_ALL | E_ADDR2_NONE)) { 841 case E_ADDR1: /* One address: */ 842 switch (ecp->addrcnt) { 843 case 0: /* Default cursor/empty file. */ 844 ecp->addrcnt = 1; 845 F_SET(ecp, E_ADDR_DEF); 846 if (F_ISSET(ecp, E_ADDR_ZERODEF)) { 847 if (db_last(sp, &lno)) 848 goto err; 849 if (lno == 0) { 850 ecp->addr1.lno = 0; 851 F_SET(ecp, E_ADDR_ZERO); 852 } else 853 ecp->addr1.lno = sp->lno; 854 } else 855 ecp->addr1.lno = sp->lno; 856 ecp->addr1.cno = sp->cno; 857 break; 858 case 1: 859 break; 860 case 2: /* Lose the first address. */ 861 ecp->addrcnt = 1; 862 ecp->addr1 = ecp->addr2; 863 } 864 break; 865 case E_ADDR2_NONE: /* Zero/two addresses: */ 866 if (ecp->addrcnt == 0) /* Default to nothing. */ 867 break; 868 goto two_addr; 869 case E_ADDR2_ALL: /* Zero/two addresses: */ 870 if (ecp->addrcnt == 0) { /* Default entire/empty file. */ 871 F_SET(ecp, E_ADDR_DEF); 872 ecp->addrcnt = 2; 873 if (sp->ep == NULL) 874 ecp->addr2.lno = 0; 875 else if (db_last(sp, &ecp->addr2.lno)) 876 goto err; 877 if (F_ISSET(ecp, E_ADDR_ZERODEF) && 878 ecp->addr2.lno == 0) { 879 ecp->addr1.lno = 0; 880 F_SET(ecp, E_ADDR_ZERO); 881 } else 882 ecp->addr1.lno = 1; 883 ecp->addr1.cno = ecp->addr2.cno = 0; 884 F_SET(ecp, E_ADDR2_ALL); 885 break; 886 } 887 /* FALLTHROUGH */ 888 case E_ADDR2: /* Two addresses: */ 889two_addr: switch (ecp->addrcnt) { 890 case 0: /* Default cursor/empty file. */ 891 ecp->addrcnt = 2; 892 F_SET(ecp, E_ADDR_DEF); 893 if (sp->lno == 1 && 894 F_ISSET(ecp, E_ADDR_ZERODEF)) { 895 if (db_last(sp, &lno)) 896 goto err; 897 if (lno == 0) { 898 ecp->addr1.lno = ecp->addr2.lno = 0; 899 F_SET(ecp, E_ADDR_ZERO); 900 } else 901 ecp->addr1.lno = 902 ecp->addr2.lno = sp->lno; 903 } else 904 ecp->addr1.lno = ecp->addr2.lno = sp->lno; 905 ecp->addr1.cno = ecp->addr2.cno = sp->cno; 906 break; 907 case 1: /* Default to first address. */ 908 ecp->addrcnt = 2; 909 ecp->addr2 = ecp->addr1; 910 break; 911 case 2: 912 break; 913 } 914 break; 915 default: 916 if (ecp->addrcnt) /* Error. */ 917 goto usage; 918 } 919 920 /* 921 * !!! 922 * The ^D scroll command historically scrolled the value of the scroll 923 * option or to EOF. It was an error if the cursor was already at EOF. 924 * (Leading addresses were permitted, but were then ignored.) 925 */ 926 if (ecp->cmd == &cmds[C_SCROLL]) { 927 ecp->addrcnt = 2; 928 ecp->addr1.lno = sp->lno + 1; 929 ecp->addr2.lno = sp->lno + O_VAL(sp, O_SCROLL); 930 ecp->addr1.cno = ecp->addr2.cno = sp->cno; 931 if (db_last(sp, &lno)) 932 goto err; 933 if (lno != 0 && lno > sp->lno && ecp->addr2.lno > lno) 934 ecp->addr2.lno = lno; 935 } 936 937 ecp->flagoff = 0; 938 for (p = ecp->cmd->syntax; *p != '\0'; ++p) { 939 /* 940 * The force flag is sensitive to leading whitespace, i.e. 941 * "next !" is different from "next!". Handle it before 942 * skipping leading <blank>s. 943 */ 944 if (*p == '!') { 945 if (ecp->clen > 0 && *ecp->cp == '!') { 946 ++ecp->cp; 947 --ecp->clen; 948 FL_SET(ecp->iflags, E_C_FORCE); 949 } 950 continue; 951 } 952 953 /* Skip leading <blank>s. */ 954 for (; ecp->clen > 0; --ecp->clen, ++ecp->cp) 955 if (!isblank(*ecp->cp)) 956 break; 957 if (ecp->clen == 0) 958 break; 959 960 switch (*p) { 961 case '1': /* +, -, #, l, p */ 962 /* 963 * !!! 964 * Historically, some flags were ignored depending 965 * on where they occurred in the command line. For 966 * example, in the command, ":3+++p--#", historic vi 967 * acted on the '#' flag, but ignored the '-' flags. 968 * It's unambiguous what the flags mean, so we just 969 * handle them regardless of the stupidity of their 970 * location. 971 */ 972 for (; ecp->clen; --ecp->clen, ++ecp->cp) 973 switch (*ecp->cp) { 974 case '+': 975 ++ecp->flagoff; 976 break; 977 case '-': 978 case '^': 979 --ecp->flagoff; 980 break; 981 case '#': 982 F_CLR(ecp, E_OPTNUM); 983 FL_SET(ecp->iflags, E_C_HASH); 984 exp->fdef |= E_C_HASH; 985 break; 986 case 'l': 987 FL_SET(ecp->iflags, E_C_LIST); 988 exp->fdef |= E_C_LIST; 989 break; 990 case 'p': 991 FL_SET(ecp->iflags, E_C_PRINT); 992 exp->fdef |= E_C_PRINT; 993 break; 994 default: 995 goto end_case1; 996 } 997end_case1: break; 998 case '2': /* -, ., +, ^ */ 999 case '3': /* -, ., +, ^, = */ 1000 for (; ecp->clen; --ecp->clen, ++ecp->cp) 1001 switch (*ecp->cp) { 1002 case '-': 1003 FL_SET(ecp->iflags, E_C_DASH); 1004 break; 1005 case '.': 1006 FL_SET(ecp->iflags, E_C_DOT); 1007 break; 1008 case '+': 1009 FL_SET(ecp->iflags, E_C_PLUS); 1010 break; 1011 case '^': 1012 FL_SET(ecp->iflags, E_C_CARAT); 1013 break; 1014 case '=': 1015 if (*p == '3') { 1016 FL_SET(ecp->iflags, E_C_EQUAL); 1017 break; 1018 } 1019 /* FALLTHROUGH */ 1020 default: 1021 goto end_case23; 1022 } 1023end_case23: break; 1024 case 'b': /* buffer */ 1025 /* 1026 * !!! 1027 * Historically, "d #" was a delete with a flag, not a 1028 * delete into the '#' buffer. If the current command 1029 * permits a flag, don't use one as a buffer. However, 1030 * the 'l' and 'p' flags were legal buffer names in the 1031 * historic ex, and were used as buffers, not flags. 1032 */ 1033 if ((ecp->cp[0] == '+' || ecp->cp[0] == '-' || 1034 ecp->cp[0] == '^' || ecp->cp[0] == '#') && 1035 strchr(p, '1') != NULL) 1036 break; 1037 /* 1038 * !!! 1039 * Digits can't be buffer names in ex commands, or the 1040 * command "d2" would be a delete into buffer '2', and 1041 * not a two-line deletion. 1042 */ 1043 if (!isdigit(ecp->cp[0])) { 1044 ecp->buffer = *ecp->cp; 1045 ++ecp->cp; 1046 --ecp->clen; 1047 FL_SET(ecp->iflags, E_C_BUFFER); 1048 } 1049 break; 1050 case 'c': /* count [01+a] */ 1051 ++p; 1052 /* Validate any signed value. */ 1053 if (!isdigit(*ecp->cp) && (*p != '+' || 1054 (*ecp->cp != '+' && *ecp->cp != '-'))) 1055 break; 1056 /* If a signed value, set appropriate flags. */ 1057 if (*ecp->cp == '-') 1058 FL_SET(ecp->iflags, E_C_COUNT_NEG); 1059 else if (*ecp->cp == '+') 1060 FL_SET(ecp->iflags, E_C_COUNT_POS); 1061 if ((nret = 1062 nget_slong(<mp, ecp->cp, &t, 10)) != NUM_OK) { 1063 ex_badaddr(sp, NULL, A_NOTSET, nret); 1064 goto err; 1065 } 1066 if (ltmp == 0 && *p != '0') { 1067 msgq(sp, M_ERR, "083|Count may not be zero"); 1068 goto err; 1069 } 1070 ecp->clen -= (t - ecp->cp); 1071 ecp->cp = t; 1072 1073 /* 1074 * Counts as address offsets occur in commands taking 1075 * two addresses. Historic vi practice was to use 1076 * the count as an offset from the *second* address. 1077 * 1078 * Set a count flag; some underlying commands (see 1079 * join) do different things with counts than with 1080 * line addresses. 1081 */ 1082 if (*p == 'a') { 1083 ecp->addr1 = ecp->addr2; 1084 ecp->addr2.lno = ecp->addr1.lno + ltmp - 1; 1085 } else 1086 ecp->count = ltmp; 1087 FL_SET(ecp->iflags, E_C_COUNT); 1088 break; 1089 case 'f': /* file */ 1090 if (argv_exp2(sp, ecp, ecp->cp, ecp->clen)) 1091 goto err; 1092 goto arg_cnt_chk; 1093 case 'l': /* line */ 1094 /* 1095 * Get a line specification. 1096 * 1097 * If the line was a search expression, we may have 1098 * changed state during the call, and we're now 1099 * searching the file. Push ourselves onto the state 1100 * stack. 1101 */ 1102 if (ex_line(sp, ecp, &cur, &isaddr, &tmp)) 1103 goto rfail; 1104 if (tmp) 1105 goto err; 1106 1107 /* Line specifications are always required. */ 1108 if (!isaddr) { 1109 msgq_str(sp, M_ERR, ecp->cp, 1110 "084|%s: bad line specification"); 1111 goto err; 1112 } 1113 /* 1114 * The target line should exist for these commands, 1115 * but 0 is legal for them as well. 1116 */ 1117 if (cur.lno != 0 && !db_exist(sp, cur.lno)) { 1118 ex_badaddr(sp, NULL, A_EOF, NUM_OK); 1119 goto err; 1120 } 1121 ecp->lineno = cur.lno; 1122 break; 1123 case 'S': /* string, file exp. */ 1124 if (ecp->clen != 0) { 1125 if (argv_exp1(sp, ecp, ecp->cp, 1126 ecp->clen, ecp->cmd == &cmds[C_BANG])) 1127 goto err; 1128 goto addr_verify; 1129 } 1130 /* FALLTHROUGH */ 1131 case 's': /* string */ 1132 if (argv_exp0(sp, ecp, ecp->cp, ecp->clen)) 1133 goto err; 1134 goto addr_verify; 1135 case 'W': /* word string */ 1136 /* 1137 * QUOTING NOTE: 1138 * 1139 * Literal next characters escape the following 1140 * character. Quoting characters are stripped here 1141 * since they are no longer useful. 1142 * 1143 * First there was the word. 1144 */ 1145 for (p = t = ecp->cp; 1146 ecp->clen > 0; --ecp->clen, ++ecp->cp) { 1147 ch = *ecp->cp; 1148 if (IS_ESCAPE(sp, 1149 ecp, ch) && ecp->clen > 1) { 1150 --ecp->clen; 1151 *p++ = *++ecp->cp; 1152 } else if (isblank(ch)) { 1153 ++ecp->cp; 1154 --ecp->clen; 1155 break; 1156 } else 1157 *p++ = ch; 1158 } 1159 if (argv_exp0(sp, ecp, t, p - t)) 1160 goto err; 1161 1162 /* Delete intervening whitespace. */ 1163 for (; ecp->clen > 0; 1164 --ecp->clen, ++ecp->cp) { 1165 ch = *ecp->cp; 1166 if (!isblank(ch)) 1167 break; 1168 } 1169 if (ecp->clen == 0) 1170 goto usage; 1171 1172 /* Followed by the string. */ 1173 for (p = t = ecp->cp; ecp->clen > 0; 1174 --ecp->clen, ++ecp->cp, ++p) { 1175 ch = *ecp->cp; 1176 if (IS_ESCAPE(sp, 1177 ecp, ch) && ecp->clen > 1) { 1178 --ecp->clen; 1179 *p = *++ecp->cp; 1180 } else 1181 *p = ch; 1182 } 1183 if (argv_exp0(sp, ecp, t, p - t)) 1184 goto err; 1185 goto addr_verify; 1186 case 'w': /* word */ 1187 if (argv_exp3(sp, ecp, ecp->cp, ecp->clen)) 1188 goto err; 1189arg_cnt_chk: if (*++p != 'N') { /* N */ 1190 /* 1191 * If a number is specified, must either be 1192 * 0 or that number, if optional, and that 1193 * number, if required. 1194 */ 1195 tmp = *p - '0'; 1196 if ((*++p != 'o' || exp->argsoff != 0) && 1197 exp->argsoff != tmp) 1198 goto usage; 1199 } 1200 goto addr_verify; 1201 default: 1202 msgq(sp, M_ERR, 1203 "085|Internal syntax table error (%s: %s)", 1204 ecp->cmd->name, KEY_NAME(sp, *p)); 1205 } 1206 } 1207 1208 /* Skip trailing whitespace. */ 1209 for (; ecp->clen > 0; --ecp->clen) { 1210 ch = *ecp->cp++; 1211 if (!isblank(ch)) 1212 break; 1213 } 1214 1215 /* 1216 * There shouldn't be anything left, and no more required fields, 1217 * i.e neither 'l' or 'r' in the syntax string. 1218 */ 1219 if (ecp->clen != 0 || strpbrk(p, "lr")) { 1220usage: msgq(sp, M_ERR, "086|Usage: %s", ecp->cmd->usage); 1221 goto err; 1222 } 1223 1224 /* 1225 * Verify that the addresses are legal. Check the addresses here, 1226 * because this is a place where all ex addresses pass through. 1227 * (They don't all pass through ex_line(), for instance.) We're 1228 * assuming that any non-existent line doesn't exist because it's 1229 * past the end-of-file. That's a pretty good guess. 1230 * 1231 * If it's a "default vi command", an address of zero is okay. 1232 */ 1233addr_verify: 1234 switch (ecp->addrcnt) { 1235 case 2: 1236 /* 1237 * Historic ex/vi permitted commands with counts to go past 1238 * EOF. So, for example, if the file only had 5 lines, the 1239 * ex command "1,6>" would fail, but the command ">300" 1240 * would succeed. Since we don't want to have to make all 1241 * of the underlying commands handle random line numbers, 1242 * fix it here. 1243 */ 1244 if (ecp->addr2.lno == 0) { 1245 if (!F_ISSET(ecp, E_ADDR_ZERO) && 1246 (F_ISSET(sp, SC_EX) || 1247 !F_ISSET(ecp, E_USELASTCMD))) { 1248 ex_badaddr(sp, ecp->cmd, A_ZERO, NUM_OK); 1249 goto err; 1250 } 1251 } else if (!db_exist(sp, ecp->addr2.lno)) 1252 if (FL_ISSET(ecp->iflags, E_C_COUNT)) { 1253 if (db_last(sp, &lno)) 1254 goto err; 1255 ecp->addr2.lno = lno; 1256 } else { 1257 ex_badaddr(sp, NULL, A_EOF, NUM_OK); 1258 goto err; 1259 } 1260 /* FALLTHROUGH */ 1261 case 1: 1262 if (ecp->addr1.lno == 0) { 1263 if (!F_ISSET(ecp, E_ADDR_ZERO) && 1264 (F_ISSET(sp, SC_EX) || 1265 !F_ISSET(ecp, E_USELASTCMD))) { 1266 ex_badaddr(sp, ecp->cmd, A_ZERO, NUM_OK); 1267 goto err; 1268 } 1269 } else if (!db_exist(sp, ecp->addr1.lno)) { 1270 ex_badaddr(sp, NULL, A_EOF, NUM_OK); 1271 goto err; 1272 } 1273 break; 1274 } 1275 1276 /* 1277 * If doing a default command and there's nothing left on the line, 1278 * vi just moves to the line. For example, ":3" and ":'a,'b" just 1279 * move to line 3 and line 'b, respectively, but ":3|" prints line 3. 1280 * 1281 * !!! 1282 * In addition, IF THE LINE CHANGES, move to the first nonblank of 1283 * the line. 1284 * 1285 * !!! 1286 * This is done before the absolute mark gets set; historically, 1287 * "/a/,/b/" did NOT set vi's absolute mark, but "/a/,/b/d" did. 1288 */ 1289 if ((F_ISSET(sp, SC_VI) || F_ISSET(ecp, E_NOPRDEF)) && 1290 F_ISSET(ecp, E_USELASTCMD) && vi_address == 0) { 1291 switch (ecp->addrcnt) { 1292 case 2: 1293 if (sp->lno != 1294 (ecp->addr2.lno ? ecp->addr2.lno : 1)) { 1295 sp->lno = 1296 ecp->addr2.lno ? ecp->addr2.lno : 1; 1297 sp->cno = 0; 1298 (void)nonblank(sp, sp->lno, &sp->cno); 1299 } 1300 break; 1301 case 1: 1302 if (sp->lno != 1303 (ecp->addr1.lno ? ecp->addr1.lno : 1)) { 1304 sp->lno = 1305 ecp->addr1.lno ? ecp->addr1.lno : 1; 1306 sp->cno = 0; 1307 (void)nonblank(sp, sp->lno, &sp->cno); 1308 } 1309 break; 1310 } 1311 ecp->cp = ecp->save_cmd; 1312 ecp->clen = ecp->save_cmdlen; 1313 goto loop; 1314 } 1315 1316 /* 1317 * Set the absolute mark -- we have to set it for vi here, in case 1318 * it's a compound command, e.g. ":5p|6" should set the absolute 1319 * mark for vi. 1320 */ 1321 if (F_ISSET(ecp, E_ABSMARK)) { 1322 cur.lno = sp->lno; 1323 cur.cno = sp->cno; 1324 F_CLR(ecp, E_ABSMARK); 1325 if (mark_set(sp, ABSMARK1, &cur, 1)) 1326 goto err; 1327 } 1328 1329#if defined(DEBUG) && defined(COMLOG) 1330 ex_comlog(sp, ecp); 1331#endif 1332 /* Increment the command count if not called from vi. */ 1333 if (F_ISSET(sp, SC_EX)) 1334 ++sp->ccnt; 1335 1336 /* 1337 * If file state available, and not doing a global command, 1338 * log the start of an action. 1339 */ 1340 if (sp->ep != NULL && !F_ISSET(sp, SC_EX_GLOBAL)) 1341 (void)log_cursor(sp); 1342 1343 /* 1344 * !!! 1345 * There are two special commands for the purposes of this code: the 1346 * default command (<carriage-return>) or the scrolling commands (^D 1347 * and <EOF>) as the first non-<blank> characters in the line. 1348 * 1349 * If this is the first command in the command line, we received the 1350 * command from the ex command loop and we're talking to a tty, and 1351 * and there's nothing else on the command line, and it's one of the 1352 * special commands, we move back up to the previous line, and erase 1353 * the prompt character with the output. Since ex runs in canonical 1354 * mode, we don't have to do anything else, a <newline> has already 1355 * been echoed by the tty driver. It's OK if vi calls us -- we won't 1356 * be in ex mode so we'll do nothing. 1357 */ 1358 if (F_ISSET(ecp, E_NRSEP)) { 1359 if (sp->ep != NULL && 1360 F_ISSET(sp, SC_EX) && !F_ISSET(gp, G_SCRIPTED) && 1361 (F_ISSET(ecp, E_USELASTCMD) || ecp->cmd == &cmds[C_SCROLL])) 1362 gp->scr_ex_adjust(sp, EX_TERM_SCROLL); 1363 F_CLR(ecp, E_NRSEP); 1364 } 1365 1366 /* 1367 * Call the underlying function for the ex command. 1368 * 1369 * XXX 1370 * Interrupts behave like errors, for now. 1371 */ 1372 if (ecp->cmd->fn(sp, ecp) || INTERRUPTED(sp)) { 1373 if (F_ISSET(gp, G_SCRIPTED)) 1374 F_SET(sp, SC_EXIT_FORCE); 1375 goto err; 1376 } 1377 1378#ifdef DEBUG 1379 /* Make sure no function left global temporary space locked. */ 1380 if (F_ISSET(gp, G_TMP_INUSE)) { 1381 F_CLR(gp, G_TMP_INUSE); 1382 msgq(sp, M_ERR, "087|%s: temporary buffer not released", 1383 ecp->cmd->name); 1384 } 1385#endif 1386 /* 1387 * Ex displayed the number of lines modified immediately after each 1388 * command, so the command "1,10d|1,10d" would display: 1389 * 1390 * 10 lines deleted 1391 * 10 lines deleted 1392 * <autoprint line> 1393 * 1394 * Executing ex commands from vi only reported the final modified 1395 * lines message -- that's wrong enough that we don't match it. 1396 */ 1397 if (F_ISSET(sp, SC_EX)) 1398 mod_rpt(sp); 1399 1400 /* 1401 * Integrate any offset parsed by the underlying command, and make 1402 * sure the referenced line exists. 1403 * 1404 * XXX 1405 * May not match historic practice (which I've never been able to 1406 * completely figure out.) For example, the '=' command from vi 1407 * mode often got the offset wrong, and complained it was too large, 1408 * but didn't seem to have a problem with the cursor. If anyone 1409 * complains, ask them how it's supposed to work, they might know. 1410 */ 1411 if (sp->ep != NULL && ecp->flagoff) { 1412 if (ecp->flagoff < 0) { 1413 if (sp->lno <= -ecp->flagoff) { 1414 msgq(sp, M_ERR, 1415 "088|Flag offset to before line 1"); 1416 goto err; 1417 } 1418 } else { 1419 if (!NPFITS(MAX_REC_NUMBER, sp->lno, ecp->flagoff)) { 1420 ex_badaddr(sp, NULL, A_NOTSET, NUM_OVER); 1421 goto err; 1422 } 1423 if (!db_exist(sp, sp->lno + ecp->flagoff)) { 1424 msgq(sp, M_ERR, 1425 "089|Flag offset past end-of-file"); 1426 goto err; 1427 } 1428 } 1429 sp->lno += ecp->flagoff; 1430 } 1431 1432 /* 1433 * If the command executed successfully, we may want to display a line 1434 * based on the autoprint option or an explicit print flag. (Make sure 1435 * that there's a line to display.) Also, the autoprint edit option is 1436 * turned off for the duration of global commands. 1437 */ 1438 if (F_ISSET(sp, SC_EX) && sp->ep != NULL && sp->lno != 0) { 1439 /* 1440 * The print commands have already handled the `print' flags. 1441 * If so, clear them. 1442 */ 1443 if (FL_ISSET(ecp->iflags, E_CLRFLAG)) 1444 FL_CLR(ecp->iflags, E_C_HASH | E_C_LIST | E_C_PRINT); 1445 1446 /* If hash set only because of the number option, discard it. */ 1447 if (F_ISSET(ecp, E_OPTNUM)) 1448 FL_CLR(ecp->iflags, E_C_HASH); 1449 1450 /* 1451 * If there was an explicit flag to display the new cursor line, 1452 * or autoprint is set and a change was made, display the line. 1453 * If any print flags were set use them, else default to print. 1454 */ 1455 LF_INIT(FL_ISSET(ecp->iflags, E_C_HASH | E_C_LIST | E_C_PRINT)); 1456 if (!LF_ISSET(E_C_HASH | E_C_LIST | E_C_PRINT | E_NOAUTO) && 1457 !F_ISSET(sp, SC_EX_GLOBAL) && 1458 O_ISSET(sp, O_AUTOPRINT) && F_ISSET(ecp, E_AUTOPRINT)) 1459 LF_INIT(E_C_PRINT); 1460 1461 if (LF_ISSET(E_C_HASH | E_C_LIST | E_C_PRINT)) { 1462 cur.lno = sp->lno; 1463 cur.cno = 0; 1464 (void)ex_print(sp, ecp, &cur, &cur, flags); 1465 } 1466 } 1467 1468 /* 1469 * If the command had an associated "+cmd", it has to be executed 1470 * before we finish executing any more of this ex command. For 1471 * example, consider a .exrc file that contains the following lines: 1472 * 1473 * :set all 1474 * :edit +25 file.c|s/abc/ABC/|1 1475 * :3,5 print 1476 * 1477 * This can happen more than once -- the historic vi simply hung or 1478 * dropped core, of course. Prepend the + command back into the 1479 * current command and continue. We may have to add an additional 1480 * <literal next> character. We know that it will fit because we 1481 * discarded at least one space and the + character. 1482 */ 1483 if (arg1_len != 0) { 1484 /* 1485 * If the last character of the + command was a <literal next> 1486 * character, it would be treated differently because of the 1487 * append. Quote it, if necessary. 1488 */ 1489 if (IS_ESCAPE(sp, ecp, arg1[arg1_len - 1])) { 1490 *--ecp->save_cmd = CH_LITERAL; 1491 ++ecp->save_cmdlen; 1492 } 1493 1494 ecp->save_cmd -= arg1_len; 1495 ecp->save_cmdlen += arg1_len; 1496 memcpy(ecp->save_cmd, arg1, arg1_len); 1497 1498 /* 1499 * Any commands executed from a +cmd are executed starting at 1500 * the first column of the last line of the file -- NOT the 1501 * first nonblank.) The main file startup code doesn't know 1502 * that a +cmd was set, however, so it may have put us at the 1503 * top of the file. (Note, this is safe because we must have 1504 * switched files to get here.) 1505 */ 1506 F_SET(ecp, E_MOVETOEND); 1507 } 1508 1509 /* Update the current command. */ 1510 ecp->cp = ecp->save_cmd; 1511 ecp->clen = ecp->save_cmdlen; 1512 1513 /* 1514 * !!! 1515 * If we've changed screens or underlying files, any pending global or 1516 * v command, or @ buffer that has associated addresses, has to be 1517 * discarded. This is historic practice for globals, and necessary for 1518 * @ buffers that had associated addresses. 1519 * 1520 * Otherwise, if we've changed underlying files, it's not a problem, 1521 * we continue with the rest of the ex command(s), operating on the 1522 * new file. However, if we switch screens (either by exiting or by 1523 * an explicit command), we have no way of knowing where to put output 1524 * messages, and, since we don't control screens here, we could screw 1525 * up the upper layers, (e.g. we could exit/reenter a screen multiple 1526 * times). So, return and continue after we've got a new screen. 1527 */ 1528 if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE | SC_FSWITCH | SC_SSWITCH)) { 1529 at_found = gv_found = 0; 1530 for (ecp = sp->gp->ecq.lh_first; 1531 ecp != NULL; ecp = ecp->q.le_next) 1532 switch (ecp->agv_flags) { 1533 case 0: 1534 case AGV_AT_NORANGE: 1535 break; 1536 case AGV_AT: 1537 if (!at_found) { 1538 at_found = 1; 1539 msgq(sp, M_ERR, 1540 "090|@ with range running when the file/screen changed"); 1541 } 1542 break; 1543 case AGV_GLOBAL: 1544 case AGV_V: 1545 if (!gv_found) { 1546 gv_found = 1; 1547 msgq(sp, M_ERR, 1548 "091|Global/v command running when the file/screen changed"); 1549 } 1550 break; 1551 default: 1552 abort(); 1553 } 1554 if (at_found || gv_found) 1555 goto discard; 1556 if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE | SC_SSWITCH)) 1557 goto rsuccess; 1558 } 1559 1560 goto loop; 1561 /* NOTREACHED */ 1562 1563err: /* 1564 * On command failure, we discard keys and pending commands remaining, 1565 * as well as any keys that were mapped and waiting. The save_cmdlen 1566 * test is not necessarily correct. If we fail early enough we don't 1567 * know if the entire string was a single command or not. Guess, as 1568 * it's useful to know if commands other than the current one are being 1569 * discarded. 1570 */ 1571 if (ecp->save_cmdlen == 0) 1572 for (; ecp->clen; --ecp->clen) { 1573 ch = *ecp->cp++; 1574 if (IS_ESCAPE(sp, ecp, ch) && ecp->clen > 1) { 1575 --ecp->clen; 1576 ++ecp->cp; 1577 } else if (ch == '\n' || ch == '|') { 1578 if (ecp->clen > 1) 1579 ecp->save_cmdlen = 1; 1580 break; 1581 } 1582 } 1583 if (ecp->save_cmdlen != 0 || gp->ecq.lh_first != &gp->excmd) { 1584discard: msgq(sp, M_BERR, 1585 "092|Ex command failed: pending commands discarded"); 1586 ex_discard(sp); 1587 } 1588 if (v_event_flush(sp, CH_MAPPED)) 1589 msgq(sp, M_BERR, 1590 "093|Ex command failed: mapped keys discarded"); 1591 1592rfail: tmp = 1; 1593 if (0) 1594rsuccess: tmp = 0; 1595 1596 /* Turn off any file name error information. */ 1597 gp->if_name = NULL; 1598 1599 /* Turn off the global bit. */ 1600 F_CLR(sp, SC_EX_GLOBAL); 1601 1602 return (tmp); 1603} 1604 1605/* 1606 * ex_range -- 1607 * Get a line range for ex commands, or perform a vi ex address search. 1608 * 1609 * PUBLIC: int ex_range __P((SCR *, EXCMD *, int *)); 1610 */ 1611int 1612ex_range(sp, ecp, errp) 1613 SCR *sp; 1614 EXCMD *ecp; 1615 int *errp; 1616{ 1617 enum { ADDR_FOUND, ADDR_NEED, ADDR_NONE } addr; 1618 GS *gp; 1619 EX_PRIVATE *exp; 1620 MARK m; 1621 int isaddr; 1622 1623 *errp = 0; 1624 1625 /* 1626 * Parse comma or semi-colon delimited line specs. 1627 * 1628 * Semi-colon delimiters update the current address to be the last 1629 * address. For example, the command 1630 * 1631 * :3;/pattern/ecp->cp 1632 * 1633 * will search for pattern from line 3. In addition, if ecp->cp 1634 * is not a valid command, the current line will be left at 3, not 1635 * at the original address. 1636 * 1637 * Extra addresses are discarded, starting with the first. 1638 * 1639 * !!! 1640 * If any addresses are missing, they default to the current line. 1641 * This was historically true for both leading and trailing comma 1642 * delimited addresses as well as for trailing semicolon delimited 1643 * addresses. For consistency, we make it true for leading semicolon 1644 * addresses as well. 1645 */ 1646 gp = sp->gp; 1647 exp = EXP(sp); 1648 for (addr = ADDR_NONE, ecp->addrcnt = 0; ecp->clen > 0;) 1649 switch (*ecp->cp) { 1650 case '%': /* Entire file. */ 1651 /* Vi ex address searches didn't permit % signs. */ 1652 if (F_ISSET(ecp, E_VISEARCH)) 1653 goto ret; 1654 1655 /* It's an error if the file is empty. */ 1656 if (sp->ep == NULL) { 1657 ex_badaddr(sp, NULL, A_EMPTY, NUM_OK); 1658 *errp = 1; 1659 return (0); 1660 } 1661 /* 1662 * !!! 1663 * A percent character addresses all of the lines in 1664 * the file. Historically, it couldn't be followed by 1665 * any other address. We do it as a text substitution 1666 * for simplicity. POSIX 1003.2 is expected to follow 1667 * this practice. 1668 * 1669 * If it's an empty file, the first line is 0, not 1. 1670 */ 1671 if (addr == ADDR_FOUND) { 1672 ex_badaddr(sp, NULL, A_COMBO, NUM_OK); 1673 *errp = 1; 1674 return (0); 1675 } 1676 if (db_last(sp, &ecp->addr2.lno)) 1677 return (1); 1678 ecp->addr1.lno = ecp->addr2.lno == 0 ? 0 : 1; 1679 ecp->addr1.cno = ecp->addr2.cno = 0; 1680 ecp->addrcnt = 2; 1681 addr = ADDR_FOUND; 1682 ++ecp->cp; 1683 --ecp->clen; 1684 break; 1685 case ',': /* Comma delimiter. */ 1686 /* Vi ex address searches didn't permit commas. */ 1687 if (F_ISSET(ecp, E_VISEARCH)) 1688 goto ret; 1689 /* FALLTHROUGH */ 1690 case ';': /* Semi-colon delimiter. */ 1691 if (sp->ep == NULL) { 1692 ex_badaddr(sp, NULL, A_EMPTY, NUM_OK); 1693 *errp = 1; 1694 return (0); 1695 } 1696 if (addr != ADDR_FOUND) 1697 switch (ecp->addrcnt) { 1698 case 0: 1699 ecp->addr1.lno = sp->lno; 1700 ecp->addr1.cno = sp->cno; 1701 ecp->addrcnt = 1; 1702 break; 1703 case 2: 1704 ecp->addr1 = ecp->addr2; 1705 /* FALLTHROUGH */ 1706 case 1: 1707 ecp->addr2.lno = sp->lno; 1708 ecp->addr2.cno = sp->cno; 1709 ecp->addrcnt = 2; 1710 break; 1711 } 1712 if (*ecp->cp == ';') 1713 switch (ecp->addrcnt) { 1714 case 0: 1715 abort(); 1716 /* NOTREACHED */ 1717 case 1: 1718 sp->lno = ecp->addr1.lno; 1719 sp->cno = ecp->addr1.cno; 1720 break; 1721 case 2: 1722 sp->lno = ecp->addr2.lno; 1723 sp->cno = ecp->addr2.cno; 1724 break; 1725 } 1726 addr = ADDR_NEED; 1727 /* FALLTHROUGH */ 1728 case ' ': /* Whitespace. */ 1729 case '\t': /* Whitespace. */ 1730 ++ecp->cp; 1731 --ecp->clen; 1732 break; 1733 default: 1734 /* Get a line specification. */ 1735 if (ex_line(sp, ecp, &m, &isaddr, errp)) 1736 return (1); 1737 if (*errp) 1738 return (0); 1739 if (!isaddr) 1740 goto ret; 1741 if (addr == ADDR_FOUND) { 1742 ex_badaddr(sp, NULL, A_COMBO, NUM_OK); 1743 *errp = 1; 1744 return (0); 1745 } 1746 switch (ecp->addrcnt) { 1747 case 0: 1748 ecp->addr1 = m; 1749 ecp->addrcnt = 1; 1750 break; 1751 case 1: 1752 ecp->addr2 = m; 1753 ecp->addrcnt = 2; 1754 break; 1755 case 2: 1756 ecp->addr1 = ecp->addr2; 1757 ecp->addr2 = m; 1758 break; 1759 } 1760 addr = ADDR_FOUND; 1761 break; 1762 } 1763 1764 /* 1765 * !!! 1766 * Vi ex address searches are indifferent to order or trailing 1767 * semi-colons. 1768 */ 1769ret: if (F_ISSET(ecp, E_VISEARCH)) 1770 return (0); 1771 1772 if (addr == ADDR_NEED) 1773 switch (ecp->addrcnt) { 1774 case 0: 1775 ecp->addr1.lno = sp->lno; 1776 ecp->addr1.cno = sp->cno; 1777 ecp->addrcnt = 1; 1778 break; 1779 case 2: 1780 ecp->addr1 = ecp->addr2; 1781 /* FALLTHROUGH */ 1782 case 1: 1783 ecp->addr2.lno = sp->lno; 1784 ecp->addr2.cno = sp->cno; 1785 ecp->addrcnt = 2; 1786 break; 1787 } 1788 1789 if (ecp->addrcnt == 2 && ecp->addr2.lno < ecp->addr1.lno) { 1790 msgq(sp, M_ERR, 1791 "094|The second address is smaller than the first"); 1792 *errp = 1; 1793 } 1794 return (0); 1795} 1796 1797/* 1798 * ex_line -- 1799 * Get a single line address specifier. 1800 * 1801 * The way the "previous context" mark worked was that any "non-relative" 1802 * motion set it. While ex/vi wasn't totally consistent about this, ANY 1803 * numeric address, search pattern, '$', or mark reference in an address 1804 * was considered non-relative, and set the value. Which should explain 1805 * why we're hacking marks down here. The problem was that the mark was 1806 * only set if the command was called, i.e. we have to set a flag and test 1807 * it later. 1808 * 1809 * XXX 1810 * This is probably still not exactly historic practice, although I think 1811 * it's fairly close. 1812 */ 1813static int 1814ex_line(sp, ecp, mp, isaddrp, errp) 1815 SCR *sp; 1816 EXCMD *ecp; 1817 MARK *mp; 1818 int *isaddrp, *errp; 1819{ 1820 enum nresult nret; 1821 EX_PRIVATE *exp; 1822 GS *gp; 1823 long total, val; 1824 int isneg; 1825 int (*sf) __P((SCR *, MARK *, MARK *, char *, size_t, char **, u_int)); 1826 char *endp; 1827 1828 gp = sp->gp; 1829 exp = EXP(sp); 1830 1831 *isaddrp = *errp = 0; 1832 F_CLR(ecp, E_DELTA); 1833 1834 /* No addresses permitted until a file has been read in. */ 1835 if (sp->ep == NULL && strchr("$0123456789'\\/?.+-^", *ecp->cp)) { 1836 ex_badaddr(sp, NULL, A_EMPTY, NUM_OK); 1837 *errp = 1; 1838 return (0); 1839 } 1840 1841 switch (*ecp->cp) { 1842 case '$': /* Last line in the file. */ 1843 *isaddrp = 1; 1844 F_SET(ecp, E_ABSMARK); 1845 1846 mp->cno = 0; 1847 if (db_last(sp, &mp->lno)) 1848 return (1); 1849 ++ecp->cp; 1850 --ecp->clen; 1851 break; /* Absolute line number. */ 1852 case '0': case '1': case '2': case '3': case '4': 1853 case '5': case '6': case '7': case '8': case '9': 1854 *isaddrp = 1; 1855 F_SET(ecp, E_ABSMARK); 1856 1857 if ((nret = nget_slong(&val, ecp->cp, &endp, 10)) != NUM_OK) { 1858 ex_badaddr(sp, NULL, A_NOTSET, nret); 1859 *errp = 1; 1860 return (0); 1861 } 1862 if (!NPFITS(MAX_REC_NUMBER, 0, val)) { 1863 ex_badaddr(sp, NULL, A_NOTSET, NUM_OVER); 1864 *errp = 1; 1865 return (0); 1866 } 1867 mp->lno = val; 1868 mp->cno = 0; 1869 ecp->clen -= (endp - ecp->cp); 1870 ecp->cp = endp; 1871 break; 1872 case '\'': /* Use a mark. */ 1873 *isaddrp = 1; 1874 F_SET(ecp, E_ABSMARK); 1875 1876 if (ecp->clen == 1) { 1877 msgq(sp, M_ERR, "095|No mark name supplied"); 1878 *errp = 1; 1879 return (0); 1880 } 1881 if (mark_get(sp, ecp->cp[1], mp, M_ERR)) { 1882 *errp = 1; 1883 return (0); 1884 } 1885 ecp->cp += 2; 1886 ecp->clen -= 2; 1887 break; 1888 case '\\': /* Search: forward/backward. */ 1889 /* 1890 * !!! 1891 * I can't find any difference between // and \/ or between 1892 * ?? and \?. Mark Horton doesn't remember there being any 1893 * difference. C'est la vie. 1894 */ 1895 if (ecp->clen < 2 || 1896 ecp->cp[1] != '/' && ecp->cp[1] != '?') { 1897 msgq(sp, M_ERR, "096|\\ not followed by / or ?"); 1898 *errp = 1; 1899 return (0); 1900 } 1901 ++ecp->cp; 1902 --ecp->clen; 1903 sf = ecp->cp[0] == '/' ? f_search : b_search; 1904 goto search; 1905 case '/': /* Search forward. */ 1906 sf = f_search; 1907 goto search; 1908 case '?': /* Search backward. */ 1909 sf = b_search; 1910 1911search: mp->lno = sp->lno; 1912 mp->cno = sp->cno; 1913 if (sf(sp, mp, mp, ecp->cp, ecp->clen, &endp, 1914 SEARCH_MSG | SEARCH_PARSE | SEARCH_SET | 1915 (F_ISSET(ecp, E_SEARCH_WMSG) ? SEARCH_WMSG : 0))) { 1916 *errp = 1; 1917 return (0); 1918 } 1919 1920 /* Fix up the command pointers. */ 1921 ecp->clen -= (endp - ecp->cp); 1922 ecp->cp = endp; 1923 1924 *isaddrp = 1; 1925 F_SET(ecp, E_ABSMARK); 1926 break; 1927 case '.': /* Current position. */ 1928 *isaddrp = 1; 1929 mp->cno = sp->cno; 1930 1931 /* If an empty file, then '.' is 0, not 1. */ 1932 if (sp->lno == 1) { 1933 if (db_last(sp, &mp->lno)) 1934 return (1); 1935 if (mp->lno != 0) 1936 mp->lno = 1; 1937 } else 1938 mp->lno = sp->lno; 1939 1940 /* 1941 * !!! 1942 * Historically, .<number> was the same as .+<number>, i.e. 1943 * the '+' could be omitted. (This feature is found in ed 1944 * as well.) 1945 */ 1946 if (ecp->clen > 1 && isdigit(ecp->cp[1])) 1947 *ecp->cp = '+'; 1948 else { 1949 ++ecp->cp; 1950 --ecp->clen; 1951 } 1952 break; 1953 } 1954 1955 /* Skip trailing <blank>s. */ 1956 for (; ecp->clen > 0 && 1957 isblank(ecp->cp[0]); ++ecp->cp, --ecp->clen); 1958 1959 /* 1960 * Evaluate any offset. If no address yet found, the offset 1961 * is relative to ".". 1962 */ 1963 total = 0; 1964 if (ecp->clen != 0 && (isdigit(ecp->cp[0]) || 1965 ecp->cp[0] == '+' || ecp->cp[0] == '-' || 1966 ecp->cp[0] == '^')) { 1967 if (!*isaddrp) { 1968 *isaddrp = 1; 1969 mp->lno = sp->lno; 1970 mp->cno = sp->cno; 1971 } 1972 /* 1973 * Evaluate an offset, defined as: 1974 * 1975 * [+-^<blank>]*[<blank>]*[0-9]* 1976 * 1977 * The rough translation is any number of signs, optionally 1978 * followed by numbers, or a number by itself, all <blank> 1979 * separated. 1980 * 1981 * !!! 1982 * All address offsets were additive, e.g. "2 2 3p" was the 1983 * same as "7p", or, "/ZZZ/ 2" was the same as "/ZZZ/+2". 1984 * Note, however, "2 /ZZZ/" was an error. It was also legal 1985 * to insert signs without numbers, so "3 - 2" was legal, and 1986 * equal to 4. 1987 * 1988 * !!! 1989 * Offsets were historically permitted for any line address, 1990 * e.g. the command "1,2 copy 2 2 2 2" copied lines 1,2 after 1991 * line 8. 1992 * 1993 * !!! 1994 * Offsets were historically permitted for search commands, 1995 * and handled as addresses: "/pattern/2 2 2" was legal, and 1996 * referenced the 6th line after pattern. 1997 */ 1998 F_SET(ecp, E_DELTA); 1999 for (;;) { 2000 for (; ecp->clen > 0 && isblank(ecp->cp[0]); 2001 ++ecp->cp, --ecp->clen); 2002 if (ecp->clen == 0 || !isdigit(ecp->cp[0]) && 2003 ecp->cp[0] != '+' && ecp->cp[0] != '-' && 2004 ecp->cp[0] != '^') 2005 break; 2006 if (!isdigit(ecp->cp[0]) && 2007 !isdigit(ecp->cp[1])) { 2008 total += ecp->cp[0] == '+' ? 1 : -1; 2009 --ecp->clen; 2010 ++ecp->cp; 2011 } else { 2012 if (ecp->cp[0] == '-' || 2013 ecp->cp[0] == '^') { 2014 ++ecp->cp; 2015 --ecp->clen; 2016 isneg = 1; 2017 } else 2018 isneg = 0; 2019 2020 /* Get a signed long, add it to the total. */ 2021 if ((nret = nget_slong(&val, 2022 ecp->cp, &endp, 10)) != NUM_OK || 2023 (nret = NADD_SLONG(sp, 2024 total, val)) != NUM_OK) { 2025 ex_badaddr(sp, NULL, A_NOTSET, nret); 2026 *errp = 1; 2027 return (0); 2028 } 2029 total += isneg ? -val : val; 2030 ecp->clen -= (endp - ecp->cp); 2031 ecp->cp = endp; 2032 } 2033 } 2034 } 2035 2036 /* 2037 * Any value less than 0 is an error. Make sure that the new value 2038 * will fit into a recno_t. 2039 */ 2040 if (*isaddrp && total != 0) { 2041 if (total < 0) { 2042 if (-total > mp->lno) { 2043 msgq(sp, M_ERR, 2044 "097|Reference to a line number less than 0"); 2045 *errp = 1; 2046 return (0); 2047 } 2048 } else 2049 if (!NPFITS(MAX_REC_NUMBER, mp->lno, total)) { 2050 ex_badaddr(sp, NULL, A_NOTSET, NUM_OVER); 2051 *errp = 1; 2052 return (0); 2053 } 2054 mp->lno += total; 2055 } 2056 return (0); 2057} 2058 2059 2060/* 2061 * ex_load -- 2062 * Load up the next command, which may be an @ buffer or global command. 2063 */ 2064static int 2065ex_load(sp) 2066 SCR *sp; 2067{ 2068 GS *gp; 2069 EXCMD *ecp; 2070 RANGE *rp; 2071 2072 F_CLR(sp, SC_EX_GLOBAL); 2073 2074 /* 2075 * Lose any exhausted commands. We know that the first command 2076 * can't be an AGV command, which makes things a bit easier. 2077 */ 2078 for (gp = sp->gp;;) { 2079 /* 2080 * If we're back to the original structure, leave it around, 2081 * but discard any allocated source name, we've returned to 2082 * the beginning of the command stack. 2083 */ 2084 if ((ecp = gp->ecq.lh_first) == &gp->excmd) { 2085 if (F_ISSET(ecp, E_NAMEDISCARD)) { 2086 free(ecp->if_name); 2087 ecp->if_name = NULL; 2088 } 2089 return (0); 2090 } 2091 2092 /* 2093 * ecp->clen will be 0 for the first discarded command, but 2094 * may not be 0 for subsequent ones, e.g. if the original 2095 * command was ":g/xx/@a|s/b/c/", then when we discard the 2096 * command pushed on the stack by the @a, we have to resume 2097 * the global command which included the substitute command. 2098 */ 2099 if (ecp->clen != 0) 2100 return (0); 2101 2102 /* 2103 * If it's an @, global or v command, we may need to continue 2104 * the command on a different line. 2105 */ 2106 if (FL_ISSET(ecp->agv_flags, AGV_ALL)) { 2107 /* Discard any exhausted ranges. */ 2108 while ((rp = ecp->rq.cqh_first) != (void *)&ecp->rq) 2109 if (rp->start > rp->stop) { 2110 CIRCLEQ_REMOVE(&ecp->rq, rp, q); 2111 free(rp); 2112 } else 2113 break; 2114 2115 /* If there's another range, continue with it. */ 2116 if (rp != (void *)&ecp->rq) 2117 break; 2118 2119 /* If it's a global/v command, fix up the last line. */ 2120 if (FL_ISSET(ecp->agv_flags, 2121 AGV_GLOBAL | AGV_V) && ecp->range_lno != OOBLNO) 2122 if (db_exist(sp, ecp->range_lno)) 2123 sp->lno = ecp->range_lno; 2124 else { 2125 if (db_last(sp, &sp->lno)) 2126 return (1); 2127 if (sp->lno == 0) 2128 sp->lno = 1; 2129 } 2130 free(ecp->o_cp); 2131 } 2132 2133 /* Discard the EXCMD. */ 2134 LIST_REMOVE(ecp, q); 2135 free(ecp); 2136 } 2137 2138 /* 2139 * We only get here if it's an active @, global or v command. Set 2140 * the current line number, and get a new copy of the command for 2141 * the parser. Note, the original pointer almost certainly moved, 2142 * so we have play games. 2143 */ 2144 ecp->cp = ecp->o_cp; 2145 memcpy(ecp->cp, ecp->cp + ecp->o_clen, ecp->o_clen); 2146 ecp->clen = ecp->o_clen; 2147 ecp->range_lno = sp->lno = rp->start++; 2148 2149 if (FL_ISSET(ecp->agv_flags, AGV_GLOBAL | AGV_V)) 2150 F_SET(sp, SC_EX_GLOBAL); 2151 return (0); 2152} 2153 2154/* 2155 * ex_discard -- 2156 * Discard any pending ex commands. 2157 */ 2158static int 2159ex_discard(sp) 2160 SCR *sp; 2161{ 2162 GS *gp; 2163 EXCMD *ecp; 2164 RANGE *rp; 2165 2166 /* 2167 * We know the first command can't be an AGV command, so we don't 2168 * process it specially. We do, however, nail the command itself. 2169 */ 2170 for (gp = sp->gp; (ecp = gp->ecq.lh_first) != &gp->excmd;) { 2171 if (FL_ISSET(ecp->agv_flags, AGV_ALL)) { 2172 while ((rp = ecp->rq.cqh_first) != (void *)&ecp->rq) { 2173 CIRCLEQ_REMOVE(&ecp->rq, rp, q); 2174 free(rp); 2175 } 2176 free(ecp->o_cp); 2177 } 2178 LIST_REMOVE(ecp, q); 2179 free(ecp); 2180 } 2181 gp->ecq.lh_first->clen = 0; 2182 return (0); 2183} 2184 2185/* 2186 * ex_unknown -- 2187 * Display an unknown command name. 2188 */ 2189static void 2190ex_unknown(sp, cmd, len) 2191 SCR *sp; 2192 char *cmd; 2193 size_t len; 2194{ 2195 size_t blen; 2196 char *bp; 2197 2198 GET_SPACE_GOTO(sp, bp, blen, len + 1); 2199 bp[len] = '\0'; 2200 memcpy(bp, cmd, len); 2201 msgq_str(sp, M_ERR, bp, "098|The %s command is unknown"); 2202 FREE_SPACE(sp, bp, blen); 2203 2204alloc_err: 2205 return; 2206} 2207 2208/* 2209 * ex_is_abbrev - 2210 * The vi text input routine needs to know if ex thinks this is an 2211 * [un]abbreviate command, so it can turn off abbreviations. See 2212 * the usual ranting in the vi/v_txt_ev.c:txt_abbrev() routine. 2213 * 2214 * PUBLIC: int ex_is_abbrev __P((char *, size_t)); 2215 */ 2216int 2217ex_is_abbrev(name, len) 2218 char *name; 2219 size_t len; 2220{ 2221 EXCMDLIST const *cp; 2222 2223 return ((cp = ex_comm_search(name, len)) != NULL && 2224 (cp == &cmds[C_ABBR] || cp == &cmds[C_UNABBREVIATE])); 2225} 2226 2227/* 2228 * ex_is_unmap - 2229 * The vi text input routine needs to know if ex thinks this is an 2230 * unmap command, so it can turn off input mapping. See the usual 2231 * ranting in the vi/v_txt_ev.c:txt_unmap() routine. 2232 * 2233 * PUBLIC: int ex_is_unmap __P((char *, size_t)); 2234 */ 2235int 2236ex_is_unmap(name, len) 2237 char *name; 2238 size_t len; 2239{ 2240 EXCMDLIST const *cp; 2241 2242 /* 2243 * The command the vi input routines are really interested in 2244 * is "unmap!", not just unmap. 2245 */ 2246 if (name[len - 1] != '!') 2247 return (0); 2248 --len; 2249 return ((cp = ex_comm_search(name, len)) != NULL && 2250 cp == &cmds[C_UNMAP]); 2251} 2252 2253/* 2254 * ex_comm_search -- 2255 * Search for a command name. 2256 */ 2257static EXCMDLIST const * 2258ex_comm_search(name, len) 2259 char *name; 2260 size_t len; 2261{ 2262 EXCMDLIST const *cp; 2263 2264 for (cp = cmds; cp->name != NULL; ++cp) { 2265 if (cp->name[0] > name[0]) 2266 return (NULL); 2267 if (cp->name[0] != name[0]) 2268 continue; 2269 if (!memcmp(name, cp->name, len)) 2270 return (cp); 2271 } 2272 return (NULL); 2273} 2274 2275/* 2276 * ex_badaddr -- 2277 * Display a bad address message. 2278 * 2279 * PUBLIC: void ex_badaddr 2280 * PUBLIC: __P((SCR *, EXCMDLIST const *, enum badaddr, enum nresult)); 2281 */ 2282void 2283ex_badaddr(sp, cp, ba, nret) 2284 SCR *sp; 2285 EXCMDLIST const *cp; 2286 enum badaddr ba; 2287 enum nresult nret; 2288{ 2289 recno_t lno; 2290 2291 switch (nret) { 2292 case NUM_OK: 2293 break; 2294 case NUM_ERR: 2295 msgq(sp, M_SYSERR, NULL); 2296 return; 2297 case NUM_OVER: 2298 msgq(sp, M_ERR, "099|Address value overflow"); 2299 return; 2300 case NUM_UNDER: 2301 msgq(sp, M_ERR, "100|Address value underflow"); 2302 return; 2303 } 2304 2305 /* 2306 * When encountering an address error, tell the user if there's no 2307 * underlying file, that's the real problem. 2308 */ 2309 if (sp->ep == NULL) { 2310 ex_emsg(sp, cp->name, EXM_NOFILEYET); 2311 return; 2312 } 2313 2314 switch (ba) { 2315 case A_COMBO: 2316 msgq(sp, M_ERR, "101|Illegal address combination"); 2317 break; 2318 case A_EOF: 2319 if (db_last(sp, &lno)) 2320 return; 2321 if (lno != 0) { 2322 msgq(sp, M_ERR, 2323 "102|Illegal address: only %lu lines in the file", 2324 lno); 2325 break; 2326 } 2327 /* FALLTHROUGH */ 2328 case A_EMPTY: 2329 msgq(sp, M_ERR, "103|Illegal address: the file is empty"); 2330 break; 2331 case A_NOTSET: 2332 abort(); 2333 /* NOTREACHED */ 2334 case A_ZERO: 2335 msgq(sp, M_ERR, 2336 "104|The %s command doesn't permit an address of 0", 2337 cp->name); 2338 break; 2339 } 2340 return; 2341} 2342 2343#if defined(DEBUG) && defined(COMLOG) 2344/* 2345 * ex_comlog -- 2346 * Log ex commands. 2347 */ 2348static void 2349ex_comlog(sp, ecp) 2350 SCR *sp; 2351 EXCMD *ecp; 2352{ 2353 TRACE(sp, "ecmd: %s", ecp->cmd->name); 2354 if (ecp->addrcnt > 0) { 2355 TRACE(sp, " a1 %d", ecp->addr1.lno); 2356 if (ecp->addrcnt > 1) 2357 TRACE(sp, " a2: %d", ecp->addr2.lno); 2358 } 2359 if (ecp->lineno) 2360 TRACE(sp, " line %d", ecp->lineno); 2361 if (ecp->flags) 2362 TRACE(sp, " flags 0x%x", ecp->flags); 2363 if (F_ISSET(&exc, E_BUFFER)) 2364 TRACE(sp, " buffer %c", ecp->buffer); 2365 if (ecp->argc) 2366 for (cnt = 0; cnt < ecp->argc; ++cnt) 2367 TRACE(sp, " arg %d: {%s}", cnt, ecp->argv[cnt]->bp); 2368 TRACE(sp, "\n"); 2369} 2370#endif 2371