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