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