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 <limits.h> 18#include <stdio.h> 19#include <string.h> 20#include <unistd.h> 21 22#include "../common/common.h" 23 24enum which {APPEND, CHANGE, INSERT}; 25 26static int ex_aci(SCR *, EXCMD *, enum which); 27 28/* 29 * ex_append -- :[line] a[ppend][!] 30 * Append one or more lines of new text after the specified line, 31 * or the current line if no address is specified. 32 * 33 * PUBLIC: int ex_append(SCR *, EXCMD *); 34 */ 35int 36ex_append(SCR *sp, EXCMD *cmdp) 37{ 38 return (ex_aci(sp, cmdp, APPEND)); 39} 40 41/* 42 * ex_change -- :[line[,line]] c[hange][!] [count] 43 * Change one or more lines to the input text. 44 * 45 * PUBLIC: int ex_change(SCR *, EXCMD *); 46 */ 47int 48ex_change(SCR *sp, EXCMD *cmdp) 49{ 50 return (ex_aci(sp, cmdp, CHANGE)); 51} 52 53/* 54 * ex_insert -- :[line] i[nsert][!] 55 * Insert one or more lines of new text before the specified line, 56 * or the current line if no address is specified. 57 * 58 * PUBLIC: int ex_insert(SCR *, EXCMD *); 59 */ 60int 61ex_insert(SCR *sp, EXCMD *cmdp) 62{ 63 return (ex_aci(sp, cmdp, INSERT)); 64} 65 66/* 67 * ex_aci -- 68 * Append, change, insert in ex. 69 */ 70static int 71ex_aci(SCR *sp, EXCMD *cmdp, enum which cmd) 72{ 73 CHAR_T *p, *t; 74 GS *gp; 75 TEXT *tp; 76 TEXTH tiq[] = {{ 0 }}; 77 recno_t cnt = 0, lno; 78 size_t len; 79 u_int32_t flags; 80 int need_newline; 81 82 gp = sp->gp; 83 NEEDFILE(sp, cmdp); 84 85 /* 86 * If doing a change, replace lines for as long as possible. Then, 87 * append more lines or delete remaining lines. Changes to an empty 88 * file are appends, inserts are the same as appends to the previous 89 * line. 90 * 91 * !!! 92 * Set the address to which we'll append. We set sp->lno to this 93 * address as well so that autoindent works correctly when get text 94 * from the user. 95 */ 96 lno = cmdp->addr1.lno; 97 sp->lno = lno; 98 if ((cmd == CHANGE || cmd == INSERT) && lno != 0) 99 --lno; 100 101 /* 102 * !!! 103 * If the file isn't empty, cut changes into the unnamed buffer. 104 */ 105 if (cmd == CHANGE && cmdp->addr1.lno != 0 && 106 (cut(sp, NULL, &cmdp->addr1, &cmdp->addr2, CUT_LINEMODE) || 107 del(sp, &cmdp->addr1, &cmdp->addr2, 1))) 108 return (1); 109 110 /* 111 * !!! 112 * Anything that was left after the command separator becomes part 113 * of the inserted text. Apparently, it was common usage to enter: 114 * 115 * :g/pattern/append|stuff1 116 * 117 * and append the line of text "stuff1" to the lines containing the 118 * pattern. It was also historically legal to enter: 119 * 120 * :append|stuff1 121 * stuff2 122 * . 123 * 124 * and the text on the ex command line would be appended as well as 125 * the text inserted after it. There was an historic bug however, 126 * that the user had to enter *two* terminating lines (the '.' lines) 127 * to terminate text input mode, in this case. This whole thing 128 * could be taken too far, however. Entering: 129 * 130 * :append|stuff1\ 131 * stuff2 132 * stuff3 133 * . 134 * 135 * i.e. mixing and matching the forms confused the historic vi, and, 136 * not only did it take two terminating lines to terminate text input 137 * mode, but the trailing backslashes were retained on the input. We 138 * match historic practice except that we discard the backslashes. 139 * 140 * Input lines specified on the ex command line lines are separated by 141 * <newline>s. If there is a trailing delimiter an empty line was 142 * inserted. There may also be a leading delimiter, which is ignored 143 * unless it's also a trailing delimiter. It is possible to encounter 144 * a termination line, i.e. a single '.', in a global command, but not 145 * necessary if the text insert command was the last of the global 146 * commands. 147 */ 148 if (cmdp->save_cmdlen != 0) { 149 for (p = cmdp->save_cmd, 150 len = cmdp->save_cmdlen; len > 0; p = t) { 151 for (t = p; len > 0 && t[0] != '\n'; ++t, --len); 152 if (t != p || len == 0) { 153 if (F_ISSET(sp, SC_EX_GLOBAL) && 154 t - p == 1 && p[0] == '.') { 155 ++t; 156 if (len > 0) 157 --len; 158 break; 159 } 160 if (db_append(sp, 1, lno++, p, t - p)) 161 return (1); 162 } 163 if (len != 0) { 164 ++t; 165 if (--len == 0 && 166 db_append(sp, 1, lno++, NULL, 0)) 167 return (1); 168 } 169 } 170 /* 171 * If there's any remaining text, we're in a global, and 172 * there's more command to parse. 173 * 174 * !!! 175 * We depend on the fact that non-global commands will eat the 176 * rest of the command line as text input, and before getting 177 * any text input from the user. Otherwise, we'd have to save 178 * off the command text before or during the call to the text 179 * input function below. 180 */ 181 if (len != 0) 182 cmdp->save_cmd = t; 183 cmdp->save_cmdlen = len; 184 } 185 186 if (F_ISSET(sp, SC_EX_GLOBAL)) { 187 if ((sp->lno = lno) == 0 && db_exist(sp, 1)) 188 sp->lno = 1; 189 return (0); 190 } 191 192 /* 193 * If not in a global command, read from the terminal. 194 * 195 * If this code is called by vi, we want to reset the terminal and use 196 * ex's line get routine. It actually works fine if we use vi's get 197 * routine, but it doesn't look as nice. Maybe if we had a separate 198 * window or something, but getting a line at a time looks awkward. 199 * However, depending on the screen that we're using, that may not 200 * be possible. 201 */ 202 if (F_ISSET(sp, SC_VI)) { 203 if (gp->scr_screen(sp, SC_EX)) { 204 ex_wemsg(sp, cmdp->cmd->name, EXM_NOCANON); 205 return (1); 206 } 207 208 /* If we're still in the vi screen, move out explicitly. */ 209 need_newline = !F_ISSET(sp, SC_SCR_EXWROTE); 210 F_SET(sp, SC_SCR_EX | SC_SCR_EXWROTE); 211 if (need_newline) 212 (void)ex_puts(sp, "\n"); 213 214 /* 215 * !!! 216 * Users of historical versions of vi sometimes get confused 217 * when they enter append mode, and can't seem to get out of 218 * it. Give them an informational message. 219 */ 220 (void)ex_puts(sp, 221 msg_cat(sp, "273|Entering ex input mode.", NULL)); 222 (void)ex_puts(sp, "\n"); 223 (void)ex_fflush(sp); 224 } 225 226 /* 227 * Set input flags; the ! flag turns off autoindent for append, 228 * change and insert. 229 */ 230 LF_INIT(TXT_DOTTERM | TXT_NUMBER); 231 if (!FL_ISSET(cmdp->iflags, E_C_FORCE) && O_ISSET(sp, O_AUTOINDENT)) 232 LF_SET(TXT_AUTOINDENT); 233 if (O_ISSET(sp, O_BEAUTIFY)) 234 LF_SET(TXT_BEAUTIFY); 235 236 /* 237 * This code can't use the common screen TEXTH structure (sp->tiq), 238 * as it may already be in use, e.g. ":append|s/abc/ABC/" would fail 239 * as we are only halfway through the text when the append code fires. 240 * Use a local structure instead. (The ex code would have to use a 241 * local structure except that we're guaranteed to finish remaining 242 * characters in the common TEXTH structure when they were inserted 243 * into the file, above.) 244 */ 245 TAILQ_INIT(tiq); 246 247 if (ex_txt(sp, tiq, 0, flags)) 248 return (1); 249 250 TAILQ_FOREACH(tp, tiq, q) { 251 if (db_append(sp, 1, lno++, tp->lb, tp->len)) 252 return (1); 253 ++cnt; 254 } 255 256 /* 257 * Set sp->lno to the final line number value (correcting for a 258 * possible 0 value) as that's historically correct for the final 259 * line value, whether or not the user entered any text. 260 */ 261 if ((sp->lno = lno) == 0 && db_exist(sp, 1)) 262 sp->lno = 1; 263 264 return (0); 265} 266