1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/* $OpenBSD: ex_bang.c,v 1.7 2009/10/27 23:59:47 deraadt Exp $ */
/*-
* Copyright (c) 1992, 1993, 1994
* The Regents of the University of California. All rights reserved.
* Copyright (c) 1992, 1993, 1994, 1995, 1996
* Keith Bostic. All rights reserved.
*
* See the LICENSE file for redistribution information.
*/
#include "config.h"
#include <sys/types.h>
#include <sys/queue.h>
#include <sys/time.h>
#include <bitstring.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "../common/common.h"
#include "../vi/vi.h"
/*
* ex_bang -- :[line [,line]] ! command
*
* Pass the rest of the line after the ! character to the program named by
* the O_SHELL option.
*
* Historical vi did NOT do shell expansion on the arguments before passing
* them, only file name expansion. This means that the O_SHELL program got
* "$t" as an argument if that is what the user entered. Also, there's a
* special expansion done for the bang command. Any exclamation points in
* the user's argument are replaced by the last, expanded ! command.
*
* There's some fairly amazing slop in this routine to make the different
* ways of getting here display the right things. It took a long time to
* get it right (wrong?), so be careful.
*
* PUBLIC: int ex_bang(SCR *, EXCMD *);
*/
int
ex_bang(sp, cmdp)
SCR *sp;
EXCMD *cmdp;
{
enum filtertype ftype;
ARGS *ap;
EX_PRIVATE *exp;
MARK rm;
recno_t lno;
int rval;
const char *msg;
ap = cmdp->argv[0];
if (ap->len == 0) {
ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
return (1);
}
/* Set the "last bang command" remembered value. */
exp = EXP(sp);
if (exp->lastbcomm != NULL)
free(exp->lastbcomm);
if ((exp->lastbcomm = strdup(ap->bp)) == NULL) {
msgq(sp, M_SYSERR, NULL);
return (1);
}
/*
* If the command was modified by the expansion, it was historically
* redisplayed.
*/
if (F_ISSET(cmdp, E_MODIFY) && !F_ISSET(sp, SC_EX_SILENT)) {
/*
* Display the command if modified. Historic ex/vi displayed
* the command if it was modified due to file name and/or bang
* expansion. If piping lines in vi, it would be immediately
* overwritten by any error or line change reporting.
*/
if (F_ISSET(sp, SC_VI))
vs_update(sp, "!", ap->bp);
else {
(void)ex_printf(sp, "!%s\n", ap->bp);
(void)ex_fflush(sp);
}
}
/*
* If no addresses were specified, run the command. If there's an
* underlying file, it's been modified and autowrite is set, write
* the file back. If the file has been modified, autowrite is not
* set and the warn option is set, tell the user about the file.
*/
if (cmdp->addrcnt == 0) {
msg = NULL;
if (sp->ep != NULL && F_ISSET(sp->ep, F_MODIFIED)) {
if (O_ISSET(sp, O_AUTOWRITE)) {
if (file_aw(sp, FS_ALL))
return (0);
} else if (O_ISSET(sp, O_WARN) &&
!F_ISSET(sp, SC_EX_SILENT))
msg = msg_cat(sp,
"303|File modified since last write.",
NULL);
}
/* If we're still in a vi screen, move out explicitly. */
(void)ex_exec_proc(sp,
cmdp, ap->bp, msg, !F_ISSET(sp, SC_EX | SC_SCR_EXWROTE));
}
/*
* If addresses were specified, pipe lines from the file through the
* command.
*
* Historically, vi lines were replaced by both the stdout and stderr
* lines of the command, but ex lines by only the stdout lines. This
* makes no sense to me, so nvi makes it consistent for both, and
* matches vi's historic behavior.
*/
else {
NEEDFILE(sp, cmdp);
/* Autoprint is set historically, even if the command fails. */
F_SET(cmdp, E_AUTOPRINT);
/*
* !!!
* Historical vi permitted "!!" in an empty file. When this
* happens, we arrive here with two addresses of 1,1 and a
* bad attitude. The simple solution is to turn it into a
* FILTER_READ operation, with the exception that stdin isn't
* opened for the utility, and the cursor position isn't the
* same. The only historic glitch (I think) is that we don't
* put an empty line into the default cut buffer, as historic
* vi did. Imagine, if you can, my disappointment.
*/
ftype = FILTER_BANG;
if (cmdp->addr1.lno == 1 && cmdp->addr2.lno == 1) {
if (db_last(sp, &lno))
return (1);
if (lno == 0) {
cmdp->addr1.lno = cmdp->addr2.lno = 0;
ftype = FILTER_RBANG;
}
}
rval = ex_filter(sp, cmdp,
&cmdp->addr1, &cmdp->addr2, &rm, ap->bp, ftype);
/*
* If in vi mode, move to the first nonblank.
*
* !!!
* Historic vi wasn't consistent in this area -- if you used
* a forward motion it moved to the first nonblank, but if you
* did a backward motion it didn't. And, if you followed a
* backward motion with a forward motion, it wouldn't move to
* the nonblank for either. Going to the nonblank generally
* seems more useful and consistent, so we do it.
*/
sp->lno = rm.lno;
if (F_ISSET(sp, SC_VI)) {
sp->cno = 0;
(void)nonblank(sp, sp->lno, &sp->cno);
} else
sp->cno = rm.cno;
}
/* Ex terminates with a bang, even if the command fails. */
if (!F_ISSET(sp, SC_VI) && !F_ISSET(sp, SC_EX_SILENT))
(void)ex_puts(sp, "!\n");
/*
* XXX
* The ! commands never return an error, so that autoprint always
* happens in the ex parser.
*/
return (0);
}
|
