contrib/nvi/vi/v_itxt.c

   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 #ifndef lint
  13 static const char sccsid[] = "@(#)v_itxt.c      10.16 (Berkeley) 10/23/96";
  14 #endif /* not lint */
  15
  16 #include <sys/types.h>
  17 #include <sys/queue.h>
  18 #include <sys/time.h>
  19
  20 #include <bitstring.h>
  21 #include <ctype.h>
  22 #include <errno.h>
  23 #include <limits.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "../common/common.h"
  29 #include "vi.h"
  30
  31 /*
  32  * !!!
  33  * Repeated input in the historic vi is mostly wrong and this isn't very
  34  * backward compatible.  For example, if the user entered "3Aab\ncd" in
  35  * the historic vi, the "ab" was repeated 3 times, and the "\ncd" was then
  36  * appended to the result.  There was also a hack which I don't remember
  37  * right now, where "3o" would open 3 lines and then let the user fill them
  38  * in, to make screen movements on 300 baud modems more tolerable.  I don't
  39  * think it's going to be missed.
  40  *
  41  * !!!
  42  * There's a problem with the way that we do logging for change commands with
  43  * implied motions (e.g. A, I, O, cc, etc.).  Since the main vi loop logs the
  44  * starting cursor position before the change command "moves" the cursor, the
  45  * cursor position to which we return on undo will be where the user entered
  46  * the change command, not the start of the change.  Several of the following
  47  * routines re-log the cursor to make this work correctly.  Historic vi tried
  48  * to do the same thing, and mostly got it right.  (The only spectacular way
  49  * it fails is if the user entered 'o' from anywhere but the last character of
  50  * the line, the undo returned the cursor to the start of the line.  If the
  51  * user was on the last character of the line, the cursor returned to that
  52  * position.)  We also check for mapped keys waiting, i.e. if we're in the
  53  * middle of a map, don't bother logging the cursor.
  54  */
  55 #define LOG_CORRECT {                                                   \
  56         if (!MAPPED_KEYS_WAITING(sp))                                   \
  57                 (void)log_cursor(sp);                                   \
  58 }
  59
  60 static u_int32_t set_txt_std __P((SCR *, VICMD *, u_int32_t));
  61
  62 /*
  63  * v_iA -- [count]A
  64  *      Append text to the end of the line.
  65  *
  66  * PUBLIC: int v_iA __P((SCR *, VICMD *));
  67  */
  68 int
  69 v_iA(sp, vp)
  70         SCR *sp;
  71         VICMD *vp;
  72 {
  73         size_t len;
  74
  75         if (!db_get(sp, vp->m_start.lno, 0, NULL, &len))
  76                 sp->cno = len == 0 ? 0 : len - 1;
  77
  78         LOG_CORRECT;
  79
  80         return (v_ia(sp, vp));
  81 }
  82
  83 /*
  84  * v_ia -- [count]a
  85  *         [count]A
  86  *      Append text to the cursor position.
  87  *
  88  * PUBLIC: int v_ia __P((SCR *, VICMD *));
  89  */
  90 int
  91 v_ia(sp, vp)
  92         SCR *sp;
  93         VICMD *vp;
  94 {
  95         size_t len;
  96         u_int32_t flags;
  97         int isempty;
  98         char *p;
  99
 100         flags = set_txt_std(sp, vp, 0);
 101         sp->showmode = SM_APPEND;
 102         sp->lno = vp->m_start.lno;
 103
 104         /* Move the cursor one column to the right and repaint the screen. */
 105         if (db_eget(sp, sp->lno, &p, &len, &isempty)) {
 106                 if (!isempty)
 107                         return (1);
 108                 len = 0;
 109                 LF_SET(TXT_APPENDEOL);
 110         } else if (len) {
 111                 if (len == sp->cno + 1) {
 112                         sp->cno = len;
 113                         LF_SET(TXT_APPENDEOL);
 114                 } else
 115                         ++sp->cno;
 116         } else
 117                 LF_SET(TXT_APPENDEOL);
 118
 119         return (v_txt(sp, vp, NULL, p, len,
 120             0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
 121 }
 122
 123 /*
 124  * v_iI -- [count]I
 125  *      Insert text at the first nonblank.
 126  *
 127  * PUBLIC: int v_iI __P((SCR *, VICMD *));
 128  */
 129 int
 130 v_iI(sp, vp)
 131         SCR *sp;
 132         VICMD *vp;
 133 {
 134         sp->cno = 0;
 135         if (nonblank(sp, vp->m_start.lno, &sp->cno))
 136                 return (1);
 137
 138         LOG_CORRECT;
 139
 140         return (v_ii(sp, vp));
 141 }
 142
 143 /*
 144  * v_ii -- [count]i
 145  *         [count]I
 146  *      Insert text at the cursor position.
 147  *
 148  * PUBLIC: int v_ii __P((SCR *, VICMD *));
 149  */
 150 int
 151 v_ii(sp, vp)
 152         SCR *sp;
 153         VICMD *vp;
 154 {
 155         size_t len;
 156         u_int32_t flags;
 157         int isempty;
 158         char *p;
 159
 160         flags = set_txt_std(sp, vp, 0);
 161         sp->showmode = SM_INSERT;
 162         sp->lno = vp->m_start.lno;
 163
 164         if (db_eget(sp, sp->lno, &p, &len, &isempty)) {
 165                 if (!isempty)
 166                         return (1);
 167                 len = 0;
 168         }
 169
 170         if (len == 0)
 171                 LF_SET(TXT_APPENDEOL);
 172         return (v_txt(sp, vp, NULL, p, len,
 173             0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
 174 }
 175
 176 enum which { o_cmd, O_cmd };
 177 static int io __P((SCR *, VICMD *, enum which));
 178
 179 /*
 180  * v_iO -- [count]O
 181  *      Insert text above this line.
 182  *
 183  * PUBLIC: int v_iO __P((SCR *, VICMD *));
 184  */
 185 int
 186 v_iO(sp, vp)
 187         SCR *sp;
 188         VICMD *vp;
 189 {
 190         return (io(sp, vp, O_cmd));
 191 }
 192
 193 /*
 194  * v_io -- [count]o
 195  *      Insert text after this line.
 196  *
 197  * PUBLIC: int v_io __P((SCR *, VICMD *));
 198  */
 199 int
 200 v_io(sp, vp)
 201         SCR *sp;
 202         VICMD *vp;
 203 {
 204         return (io(sp, vp, o_cmd));
 205 }
 206
 207 static int
 208 io(sp, vp, cmd)
 209         SCR *sp;
 210         VICMD *vp;
 211         enum which cmd;
 212 {
 213         recno_t ai_line, lno;
 214         size_t len;
 215         u_int32_t flags;
 216         char *p;
 217
 218         flags = set_txt_std(sp, vp, TXT_ADDNEWLINE | TXT_APPENDEOL);
 219         sp->showmode = SM_INSERT;
 220
 221         if (sp->lno == 1) {
 222                 if (db_last(sp, &lno))
 223                         return (1);
 224                 if (lno != 0)
 225                         goto insert;
 226                 p = NULL;
 227                 len = 0;
 228                 ai_line = OOBLNO;
 229         } else {
 230 insert:         p = "";
 231                 sp->cno = 0;
 232                 LOG_CORRECT;
 233
 234                 if (cmd == O_cmd) {
 235                         if (db_insert(sp, sp->lno, p, 0))
 236                                 return (1);
 237                         if (db_get(sp, sp->lno, DBG_FATAL, &p, &len))
 238                                 return (1);
 239                         ai_line = sp->lno + 1;
 240                 } else {
 241                         if (db_append(sp, 1, sp->lno, p, 0))
 242                                 return (1);
 243                         if (db_get(sp, ++sp->lno, DBG_FATAL, &p, &len))
 244                                 return (1);
 245                         ai_line = sp->lno - 1;
 246                 }
 247         }
 248         return (v_txt(sp, vp, NULL, p, len,
 249             0, ai_line, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
 250 }
 251
 252 /*
 253  * v_change -- [buffer][count]c[count]motion
 254  *             [buffer][count]C
 255  *             [buffer][count]S
 256  *      Change command.
 257  *
 258  * PUBLIC: int v_change __P((SCR *, VICMD *));
 259  */
 260 int
 261 v_change(sp, vp)
 262         SCR *sp;
 263         VICMD *vp;
 264 {
 265         size_t blen, len;
 266         u_int32_t flags;
 267         int isempty, lmode, rval;
 268         char *bp, *p;
 269
 270         /*
 271          * 'c' can be combined with motion commands that set the resulting
 272          * cursor position, i.e. "cG".  Clear the VM_RCM flags and make the
 273          * resulting cursor position stick, inserting text has its own rules
 274          * for cursor positioning.
 275          */
 276         F_CLR(vp, VM_RCM_MASK);
 277         F_SET(vp, VM_RCM_SET);
 278
 279         /*
 280          * Find out if the file is empty, it's easier to handle it as a
 281          * special case.
 282          */
 283         if (vp->m_start.lno == vp->m_stop.lno &&
 284             db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
 285                 if (!isempty)
 286                         return (1);
 287                 return (v_ia(sp, vp));
 288         }
 289
 290         flags = set_txt_std(sp, vp, 0);
 291         sp->showmode = SM_CHANGE;
 292
 293         /*
 294          * Move the cursor to the start of the change.  Note, if autoindent
 295          * is turned on, the cc command in line mode changes from the first
 296          * *non-blank* character of the line, not the first character.  And,
 297          * to make it just a bit more exciting, the initial space is handled
 298          * as auto-indent characters.
 299          */
 300         lmode = F_ISSET(vp, VM_LMODE) ? CUT_LINEMODE : 0;
 301         if (lmode) {
 302                 vp->m_start.cno = 0;
 303                 if (O_ISSET(sp, O_AUTOINDENT)) {
 304                         if (nonblank(sp, vp->m_start.lno, &vp->m_start.cno))
 305                                 return (1);
 306                         LF_SET(TXT_AICHARS);
 307                 }
 308         }
 309         sp->lno = vp->m_start.lno;
 310         sp->cno = vp->m_start.cno;
 311
 312         LOG_CORRECT;
 313
 314         /*
 315          * If not in line mode and changing within a single line, copy the
 316          * text and overwrite it.
 317          */
 318         if (!lmode && vp->m_start.lno == vp->m_stop.lno) {
 319                 /*
 320                  * !!!
 321                  * Historic practice, c did not cut into the numeric buffers,
 322                  * only the unnamed one.
 323                  */
 324                 if (cut(sp,
 325                     F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
 326                     &vp->m_start, &vp->m_stop, lmode))
 327                         return (1);
 328                 if (len == 0)
 329                         LF_SET(TXT_APPENDEOL);
 330                 LF_SET(TXT_EMARK | TXT_OVERWRITE);
 331                 return (v_txt(sp, vp, &vp->m_stop, p, len,
 332                     0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
 333         }
 334
 335         /*
 336          * It's trickier if in line mode or changing over multiple lines.  If
 337          * we're in line mode delete all of the lines and insert a replacement
 338          * line which the user edits.  If there was leading whitespace in the
 339          * first line being changed, we copy it and use it as the replacement.
 340          * If we're not in line mode, we delete the text and start inserting.
 341          *
 342          * !!!
 343          * Copy the text.  Historic practice, c did not cut into the numeric
 344          * buffers, only the unnamed one.
 345          */
 346         if (cut(sp,
 347             F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
 348             &vp->m_start, &vp->m_stop, lmode))
 349                 return (1);
 350
 351         /* If replacing entire lines and there's leading text. */
 352         if (lmode && vp->m_start.cno) {
 353                 /*
 354                  * Get a copy of the first line changed, and copy out the
 355                  * leading text.
 356                  */
 357                 if (db_get(sp, vp->m_start.lno, DBG_FATAL, &p, &len))
 358                         return (1);
 359                 GET_SPACE_RET(sp, bp, blen, vp->m_start.cno);
 360                 memmove(bp, p, vp->m_start.cno);
 361         } else
 362                 bp = NULL;
 363
 364         /* Delete the text. */
 365         if (del(sp, &vp->m_start, &vp->m_stop, lmode))
 366                 return (1);
 367
 368         /* If replacing entire lines, insert a replacement line. */
 369         if (lmode) {
 370                 if (db_insert(sp, vp->m_start.lno, bp, vp->m_start.cno))
 371                         return (1);
 372                 sp->lno = vp->m_start.lno;
 373                 len = sp->cno = vp->m_start.cno;
 374         }
 375
 376         /* Get the line we're editing. */
 377         if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
 378                 if (!isempty)
 379                         return (1);
 380                 len = 0;
 381         }
 382
 383         /* Check to see if we're appending to the line. */
 384         if (vp->m_start.cno >= len)
 385                 LF_SET(TXT_APPENDEOL);
 386
 387         rval = v_txt(sp, vp, NULL, p, len,
 388             0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags);
 389
 390         if (bp != NULL)
 391                 FREE_SPACE(sp, bp, blen);
 392         return (rval);
 393 }
 394
 395 /*
 396  * v_Replace -- [count]R
 397  *      Overwrite multiple characters.
 398  *
 399  * PUBLIC: int v_Replace __P((SCR *, VICMD *));
 400  */
 401 int
 402 v_Replace(sp, vp)
 403         SCR *sp;
 404         VICMD *vp;
 405 {
 406         size_t len;
 407         u_int32_t flags;
 408         int isempty;
 409         char *p;
 410
 411         flags = set_txt_std(sp, vp, 0);
 412         sp->showmode = SM_REPLACE;
 413
 414         if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
 415                 if (!isempty)
 416                         return (1);
 417                 len = 0;
 418                 LF_SET(TXT_APPENDEOL);
 419         } else {
 420                 if (len == 0)
 421                         LF_SET(TXT_APPENDEOL);
 422                 LF_SET(TXT_OVERWRITE | TXT_REPLACE);
 423         }
 424         vp->m_stop.lno = vp->m_start.lno;
 425         vp->m_stop.cno = len ? len - 1 : 0;
 426
 427         return (v_txt(sp, vp, &vp->m_stop, p, len,
 428             0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
 429 }
 430
 431 /*
 432  * v_subst -- [buffer][count]s
 433  *      Substitute characters.
 434  *
 435  * PUBLIC: int v_subst __P((SCR *, VICMD *));
 436  */
 437 int
 438 v_subst(sp, vp)
 439         SCR *sp;
 440         VICMD *vp;
 441 {
 442         size_t len;
 443         u_int32_t flags;
 444         int isempty;
 445         char *p;
 446
 447         flags = set_txt_std(sp, vp, 0);
 448         sp->showmode = SM_CHANGE;
 449
 450         if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
 451                 if (!isempty)
 452                         return (1);
 453                 len = 0;
 454                 LF_SET(TXT_APPENDEOL);
 455         } else {
 456                 if (len == 0)
 457                         LF_SET(TXT_APPENDEOL);
 458                 LF_SET(TXT_EMARK | TXT_OVERWRITE);
 459         }
 460
 461         vp->m_stop.lno = vp->m_start.lno;
 462         vp->m_stop.cno =
 463             vp->m_start.cno + (F_ISSET(vp, VC_C1SET) ? vp->count - 1 : 0);
 464         if (vp->m_stop.cno > len - 1)
 465                 vp->m_stop.cno = len - 1;
 466
 467         if (p != NULL && cut(sp,
 468             F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
 469             &vp->m_start, &vp->m_stop, 0))
 470                 return (1);
 471
 472         return (v_txt(sp, vp, &vp->m_stop, p, len, 0, OOBLNO, 1, flags));
 473 }
 474
 475 /*
 476  * set_txt_std --
 477  *      Initialize text processing flags.
 478  */
 479 static u_int32_t
 480 set_txt_std(sp, vp, flags)
 481         SCR *sp;
 482         VICMD *vp;
 483         u_int32_t flags;
 484 {
 485         LF_SET(TXT_CNTRLT |
 486             TXT_ESCAPE | TXT_MAPINPUT | TXT_RECORD | TXT_RESOLVE);
 487
 488         if (F_ISSET(vp, VC_ISDOT))
 489                 LF_SET(TXT_REPLAY);
 490
 491         if (O_ISSET(sp, O_ALTWERASE))
 492                 LF_SET(TXT_ALTWERASE);
 493         if (O_ISSET(sp, O_AUTOINDENT))
 494                 LF_SET(TXT_AUTOINDENT);
 495         if (O_ISSET(sp, O_BEAUTIFY))
 496                 LF_SET(TXT_BEAUTIFY);
 497         if (O_ISSET(sp, O_SHOWMATCH))
 498                 LF_SET(TXT_SHOWMATCH);
 499         if (F_ISSET(sp, SC_SCRIPT))
 500                 LF_SET(TXT_CR);
 501         if (O_ISSET(sp, O_TTYWERASE))
 502                 LF_SET(TXT_TTYWERASE);
 503
 504         /*
 505          * !!!
 506          * Mapped keys were sometimes unaffected by the wrapmargin option
 507          * in the historic 4BSD vi.  Consider the following commands, where
 508          * each is executed on an empty line, in an 80 column screen, with
 509          * the wrapmargin value set to 60.
 510          *
 511          *      aABC DEF <ESC>....
 512          *      :map K aABC DEF ^V<ESC><CR>KKKKK
 513          *      :map K 5aABC DEF ^V<ESC><CR>K
 514          *
 515          * The first and second commands are affected by wrapmargin.  The
 516          * third is not.  (If the inserted text is itself longer than the
 517          * wrapmargin value, i.e. if the "ABC DEF " string is replaced by
 518          * something that's longer than 60 columns from the beginning of
 519          * the line, the first two commands behave as before, but the third
 520          * command gets fairly strange.)  The problem is that people wrote
 521          * macros that depended on the third command NOT being affected by
 522          * wrapmargin, as in this gem which centers lines:
 523          *
 524          *      map #c $mq81a ^V^[81^V^V|D`qld0:s/  / /g^V^M$p
 525          *
 526          * For compatibility reasons, we try and make it all work here.  I
 527          * offer no hope that this is right, but it's probably pretty close.
 528          *
 529          * XXX
 530          * Once I work my courage up, this is all gonna go away.  It's too
 531          * evil to survive.
 532          */
 533         if ((O_ISSET(sp, O_WRAPLEN) || O_ISSET(sp, O_WRAPMARGIN)) &&
 534             (!MAPPED_KEYS_WAITING(sp) || !F_ISSET(vp, VC_C1SET)))
 535                 LF_SET(TXT_WRAPMARGIN);
 536         return (flags);
 537 }