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