1 /* $NetBSD: ex_txt.c,v 1.4 2014/01/26 21:43:45 christos Exp $ */
2 /*-
3 * Copyright (c) 1992, 1993, 1994
4 * The Regents of the University of California. All rights reserved.
5 * Copyright (c) 1992, 1993, 1994, 1995, 1996
6 * Keith Bostic. All rights reserved.
7 *
8 * See the LICENSE file for redistribution information.
9 */
10
11 #include "config.h"
12
13 #include <sys/cdefs.h>
14 #if 0
15 #ifndef lint
16 static const char sccsid[] = "Id: ex_txt.c,v 10.23 2001/06/25 15:19:21 skimo Exp (Berkeley) Date: 2001/06/25 15:19:21 ";
17 #endif /* not lint */
18 #else
19 __RCSID("$NetBSD: ex_txt.c,v 1.4 2014/01/26 21:43:45 christos Exp $");
20 #endif
21
22 #include <sys/types.h>
23 #include <sys/queue.h>
24 #include <sys/time.h>
25
26 #include <bitstring.h>
27 #include <ctype.h>
28 #include <limits.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #include "../common/common.h"
34 #include "../vi/vi.h"
35
36 /*
37 * !!!
38 * The backslash characters was special when it preceded a newline as part of
39 * a substitution replacement pattern. For example, the input ":a\<cr>" would
40 * failed immediately with an error, as the <cr> wasn't part of a substitution
41 * replacement pattern. This implies a frightening integration of the editor
42 * and the parser and/or the RE engine. There's no way I'm going to reproduce
43 * those semantics.
44 *
45 * So, if backslashes are special, this code inserts the backslash and the next
46 * character into the string, without regard for the character or the command
47 * being entered. Since "\<cr>" was illegal historically (except for the one
48 * special case), and the command will fail eventually, no historical scripts
49 * should break (presuming they didn't depend on the failure mode itself or the
50 * characters remaining when failure occurred.
51 */
52
53 static int txt_dent __P((SCR *, TEXT *));
54 static void txt_prompt __P((SCR *, TEXT *, ARG_CHAR_T, u_int32_t));
55
56 /*
57 * ex_txt --
58 * Get lines from the terminal for ex.
59 *
60 * PUBLIC: int ex_txt __P((SCR *, TEXTH *, ARG_CHAR_T, u_int32_t));
61 */
62 int
ex_txt(SCR * sp,TEXTH * tiqh,ARG_CHAR_T prompt,u_int32_t flags)63 ex_txt(SCR *sp, TEXTH *tiqh, ARG_CHAR_T prompt, u_int32_t flags)
64 {
65 EVENT ev;
66 GS *gp;
67 TEXT ait, *ntp, *tp;
68 carat_t carat_st;
69 size_t cnt;
70 int rval;
71 int nochange;
72
73 rval = 0;
74
75 /*
76 * Get a TEXT structure with some initial buffer space, reusing the
77 * last one if it's big enough. (All TEXT bookkeeping fields default
78 * to 0 -- text_init() handles this.)
79 */
80 if ((tp = TAILQ_FIRST(tiqh)) != NULL) {
81 if (TAILQ_NEXT(tp, q) != NULL || tp->lb_len < 32) {
82 text_lfree(tiqh);
83 goto newtp;
84 }
85 tp->len = 0;
86 } else {
87 newtp: if ((tp = text_init(sp, NULL, 0, 32)) == NULL)
88 goto err;
89 TAILQ_INSERT_HEAD(tiqh, tp, q);
90 }
91
92 /* Set the starting line number. */
93 tp->lno = sp->lno + 1;
94
95 /*
96 * If it's a terminal, set up autoindent, put out the prompt, and
97 * set it up so we know we were suspended. Otherwise, turn off
98 * the autoindent flag, as that requires less special casing below.
99 *
100 * XXX
101 * Historic practice is that ^Z suspended command mode (but, because
102 * it ran in cooked mode, it was unaffected by the autowrite option.)
103 * On restart, any "current" input was discarded, whether in insert
104 * mode or not, and ex was in command mode. This code matches historic
105 * practice, but not 'cause it's easier.
106 */
107 gp = sp->gp;
108 if (F_ISSET(gp, G_SCRIPTED))
109 LF_CLR(TXT_AUTOINDENT);
110 else {
111 if (LF_ISSET(TXT_AUTOINDENT)) {
112 LF_SET(TXT_EOFCHAR);
113 if (v_txt_auto(sp, sp->lno, NULL, 0, tp))
114 goto err;
115 }
116 txt_prompt(sp, tp, prompt, flags);
117 }
118
119 for (carat_st = C_NOTSET, nochange = 0;;) {
120 if (v_event_get(sp, &ev, 0, 0))
121 goto err;
122
123 /* Deal with all non-character events. */
124 switch (ev.e_event) {
125 case E_CHARACTER:
126 break;
127 case E_ERR:
128 goto err;
129 case E_REPAINT:
130 case E_WRESIZE:
131 continue;
132 case E_EOF:
133 rval = 1;
134 /* FALLTHROUGH */
135 case E_INTERRUPT:
136 /*
137 * Handle EOF/SIGINT events by discarding partially
138 * entered text and returning. EOF returns failure,
139 * E_INTERRUPT returns success.
140 */
141 goto notlast;
142 default:
143 v_event_err(sp, &ev);
144 goto notlast;
145 }
146
147 /*
148 * Deal with character events.
149 *
150 * Check to see if the character fits into the input buffer.
151 * (Use tp->len, ignore overwrite and non-printable chars.)
152 */
153 BINC_GOTOW(sp, tp->lb, tp->lb_len, tp->len + 1);
154
155 switch (ev.e_value) {
156 case K_CR:
157 /*
158 * !!!
159 * Historically, <carriage-return>'s in the command
160 * weren't special, so the ex parser would return an
161 * unknown command error message. However, if they
162 * terminated the command if they were in a map. I'm
163 * pretty sure this still isn't right, but it handles
164 * what I've seen so far.
165 */
166 if (!FL_ISSET(ev.e_flags, CH_MAPPED))
167 goto ins_ch;
168 /* FALLTHROUGH */
169 case K_NL:
170 /*
171 * '\' can escape <carriage-return>/<newline>. We
172 * don't discard the backslash because we need it
173 * to get the <newline> through the ex parser.
174 */
175 if (LF_ISSET(TXT_BACKSLASH) &&
176 tp->len != 0 && tp->lb[tp->len - 1] == '\\')
177 goto ins_ch;
178
179 /*
180 * CR returns from the ex command line.
181 *
182 * XXX
183 * Terminate with a nul, needed by filter.
184 */
185 if (LF_ISSET(TXT_CR)) {
186 tp->lb[tp->len] = '\0';
187 goto done;
188 }
189
190 /*
191 * '.' may terminate text input mode; free the current
192 * TEXT.
193 */
194 if (LF_ISSET(TXT_DOTTERM) && tp->len == tp->ai + 1 &&
195 tp->lb[tp->len - 1] == '.') {
196 notlast: TAILQ_REMOVE(tiqh, tp, q);
197 text_free(tp);
198 goto done;
199 }
200
201 /* Set up bookkeeping for the new line. */
202 if ((ntp = text_init(sp, NULL, 0, 32)) == NULL)
203 goto err;
204 ntp->lno = tp->lno + 1;
205
206 /*
207 * Reset the autoindent line value. 0^D keeps the ai
208 * line from changing, ^D changes the level, even if
209 * there were no characters in the old line. Note, if
210 * using the current tp structure, use the cursor as
211 * the length, the autoindent characters may have been
212 * erased.
213 */
214 if (LF_ISSET(TXT_AUTOINDENT)) {
215 if (nochange) {
216 nochange = 0;
217 if (v_txt_auto(sp,
218 OOBLNO, &ait, ait.ai, ntp))
219 goto err;
220 free(ait.lb);
221 } else
222 if (v_txt_auto(sp,
223 OOBLNO, tp, tp->len, ntp))
224 goto err;
225 carat_st = C_NOTSET;
226 }
227 txt_prompt(sp, ntp, prompt, flags);
228
229 /*
230 * Swap old and new TEXT's, and insert the new TEXT
231 * into the queue.
232 */
233 tp = ntp;
234 TAILQ_INSERT_TAIL(tiqh, tp, q);
235 break;
236 case K_CARAT: /* Delete autoindent chars. */
237 if (tp->len <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
238 carat_st = C_CARATSET;
239 goto ins_ch;
240 case K_ZERO: /* Delete autoindent chars. */
241 if (tp->len <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
242 carat_st = C_ZEROSET;
243 goto ins_ch;
244 case K_CNTRLD: /* Delete autoindent char. */
245 /*
246 * !!!
247 * Historically, the ^D command took (but then ignored)
248 * a count. For simplicity, we don't return it unless
249 * it's the first character entered. The check for len
250 * equal to 0 is okay, TXT_AUTOINDENT won't be set.
251 */
252 if (LF_ISSET(TXT_CNTRLD)) {
253 for (cnt = 0; cnt < tp->len; ++cnt)
254 if (!ISBLANK((UCHAR_T)tp->lb[cnt]))
255 break;
256 if (cnt == tp->len) {
257 tp->len = 1;
258 tp->lb[0] = ev.e_c;
259 tp->lb[1] = '\0';
260
261 /*
262 * Put out a line separator, in case
263 * the command fails.
264 */
265 (void)putchar('\n');
266 goto done;
267 }
268 }
269
270 /*
271 * POSIX 1003.1b-1993, paragraph 7.1.1.9, states that
272 * the EOF characters are discarded if there are other
273 * characters to process in the line, i.e. if the EOF
274 * is not the first character in the line. For this
275 * reason, historic ex discarded the EOF characters,
276 * even if occurring in the middle of the input line.
277 * We match that historic practice.
278 *
279 * !!!
280 * The test for discarding in the middle of the line is
281 * done in the switch, because the CARAT forms are N+1,
282 * not N.
283 *
284 * !!!
285 * There's considerable magic to make the terminal code
286 * return the EOF character at all. See that code for
287 * details.
288 */
289 if (!LF_ISSET(TXT_AUTOINDENT) || tp->len == 0)
290 continue;
291 switch (carat_st) {
292 case C_CARATSET: /* ^^D */
293 if (tp->len > tp->ai + 1)
294 continue;
295
296 /* Save the ai string for later. */
297 ait.lb = NULL;
298 ait.lb_len = 0;
299 BINC_GOTOW(sp, ait.lb, ait.lb_len, tp->ai);
300 MEMCPYW(ait.lb, tp->lb, tp->ai);
301 ait.ai = ait.len = tp->ai;
302
303 carat_st = C_NOTSET;
304 nochange = 1;
305 goto leftmargin;
306 case C_ZEROSET: /* 0^D */
307 if (tp->len > tp->ai + 1)
308 continue;
309
310 carat_st = C_NOTSET;
311 leftmargin: (void)gp->scr_ex_adjust(sp, EX_TERM_CE);
312 tp->ai = tp->len = 0;
313 break;
314 case C_NOTSET: /* ^D */
315 if (tp->len > tp->ai)
316 continue;
317
318 if (txt_dent(sp, tp))
319 goto err;
320 break;
321 default:
322 abort();
323 }
324
325 /* Clear and redisplay the line. */
326 (void)gp->scr_ex_adjust(sp, EX_TERM_CE);
327 txt_prompt(sp, tp, prompt, flags);
328 break;
329 default:
330 /*
331 * See the TXT_BEAUTIFY comment in vi/v_txt_ev.c.
332 *
333 * Silently eliminate any iscntrl() character that was
334 * not already handled specially, except for <tab> and
335 * <ff>.
336 */
337 ins_ch: if (LF_ISSET(TXT_BEAUTIFY) && ISCNTRL(ev.e_c) &&
338 ev.e_value != K_FORMFEED && ev.e_value != K_TAB)
339 break;
340
341 tp->lb[tp->len++] = ev.e_c;
342 break;
343 }
344 }
345 /* NOTREACHED */
346
347 done: return (rval);
348
349 err:
350 alloc_err:
351 return (1);
352 }
353
354 /*
355 * txt_prompt --
356 * Display the ex prompt, line number, ai characters. Characters had
357 * better be printable by the terminal driver, but that's its problem,
358 * not ours.
359 */
360 static void
txt_prompt(SCR * sp,TEXT * tp,ARG_CHAR_T prompt,u_int32_t flags)361 txt_prompt(SCR *sp, TEXT *tp, ARG_CHAR_T prompt, u_int32_t flags)
362 {
363 /* Display the prompt. */
364 if (LF_ISSET(TXT_PROMPT))
365 (void)ex_printf(sp, "%c", prompt);
366
367 /* Display the line number. */
368 if (LF_ISSET(TXT_NUMBER) && O_ISSET(sp, O_NUMBER))
369 (void)ex_printf(sp, "%6lu ", (u_long)tp->lno);
370
371 /* Print out autoindent string. */
372 if (LF_ISSET(TXT_AUTOINDENT)) {
373 const char *nstr;
374 size_t nlen;
375 INT2CHAR(sp, tp->lb, tp->ai + 1, nstr, nlen);
376 (void)ex_printf(sp, "%.*s", (int)tp->ai, nstr);
377 }
378 (void)ex_fflush(sp);
379 }
380
381 /*
382 * txt_dent --
383 * Handle ^D outdents.
384 *
385 * Ex version of vi/v_ntext.c:txt_dent(). See that code for the (usual)
386 * ranting and raving. This is a fair bit simpler as ^T isn't special.
387 */
388 static int
txt_dent(SCR * sp,TEXT * tp)389 txt_dent(SCR *sp, TEXT *tp)
390 {
391 u_long sw, ts;
392 size_t cno, off, scno, spaces, tabs;
393
394 ts = O_VAL(sp, O_TABSTOP);
395 sw = O_VAL(sp, O_SHIFTWIDTH);
396
397 /* Get the current screen column. */
398 for (off = scno = 0; off < tp->len; ++off)
399 if (tp->lb[off] == '\t')
400 scno += COL_OFF(scno, ts);
401 else
402 ++scno;
403
404 /* Get the previous shiftwidth column. */
405 cno = scno--;
406 scno -= scno % sw;
407
408 /*
409 * Since we don't know what comes before the character(s) being
410 * deleted, we have to resolve the autoindent characters . The
411 * example is a <tab>, which doesn't take up a full shiftwidth
412 * number of columns because it's preceded by <space>s. This is
413 * easy to get if the user sets shiftwidth to a value less than
414 * tabstop, and then uses ^T to indent, and ^D to outdent.
415 *
416 * Count up spaces/tabs needed to get to the target.
417 */
418 cno = 0;
419 tabs = 0;
420 if (!O_ISSET(sp, O_EXPANDTAB)) {
421 for (; cno + COL_OFF(cno, ts) <= scno; ++tabs)
422 cno += COL_OFF(cno, ts);
423 }
424 spaces = scno - cno;
425
426 /* Make sure there's enough room. */
427 BINC_RETW(sp, tp->lb, tp->lb_len, tabs + spaces + 1);
428
429 /* Adjust the final ai character count. */
430 tp->ai = tabs + spaces;
431
432 /* Enter the replacement characters. */
433 for (tp->len = 0; tabs > 0; --tabs)
434 tp->lb[tp->len++] = '\t';
435 for (; spaces > 0; --spaces)
436 tp->lb[tp->len++] = ' ';
437 return (0);
438 }
439