dist/nvi/common/mark.c

   1 /*      $NetBSD: mark.c,v 1.2 2008/12/05 22:51:42 christos Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1992, 1993, 1994
   5  *      The Regents of the University of California.  All rights reserved.
   6  * Copyright (c) 1992, 1993, 1994, 1995, 1996
   7  *      Keith Bostic.  All rights reserved.
   8  *
   9  * See the LICENSE file for redistribution information.
  10  */
  11
  12 #include "config.h"
  13
  14 #ifndef lint
  15 static const char sccsid[] = "Id: mark.c,v 10.15 2001/06/25 15:19:11 skimo Exp (Berkeley) Date: 2001/06/25 15:19:11";
  16 #endif /* not lint */
  17
  18 #include <sys/types.h>
  19 #include <sys/queue.h>
  20
  21 #include <bitstring.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.h"
  29
  30 static LMARK *mark_find __P((SCR *, ARG_CHAR_T));
  31
  32 /*
  33  * Marks are maintained in a key sorted doubly linked list.  We can't
  34  * use arrays because we have no idea how big an index key could be.
  35  * The underlying assumption is that users don't have more than, say,
  36  * 10 marks at any one time, so this will be is fast enough.
  37  *
  38  * Marks are fixed, and modifications to the line don't update the mark's
  39  * position in the line.  This can be hard.  If you add text to the line,
  40  * place a mark in that text, undo the addition and use ` to move to the
  41  * mark, the location will have disappeared.  It's tempting to try to adjust
  42  * the mark with the changes in the line, but this is hard to do, especially
  43  * if we've given the line to v_ntext.c:v_ntext() for editing.  Historic vi
  44  * would move to the first non-blank on the line when the mark location was
  45  * past the end of the line.  This can be complicated by deleting to a mark
  46  * that has disappeared using the ` command.  Historic vi treated this as
  47  * a line-mode motion and deleted the line.  This implementation complains to
  48  * the user.
  49  *
  50  * In historic vi, marks returned if the operation was undone, unless the
  51  * mark had been subsequently reset.  Tricky.  This is hard to start with,
  52  * but in the presence of repeated undo it gets nasty.  When a line is
  53  * deleted, we delete (and log) any marks on that line.  An undo will create
  54  * the mark.  Any mark creations are noted as to whether the user created
  55  * it or if it was created by an undo.  The former cannot be reset by another
  56  * undo, but the latter may.
  57  *
  58  * All of these routines translate ABSMARK2 to ABSMARK1.  Setting either of
  59  * the absolute mark locations sets both, so that "m'" and "m`" work like
  60  * they, ah, for lack of a better word, "should".
  61  */
  62
  63 /*
  64  * mark_init --
  65  *      Set up the marks.
  66  *
  67  * PUBLIC: int mark_init __P((SCR *, EXF *));
  68  */
  69 int
  70 mark_init(SCR *sp, EXF *ep)
  71 {
  72         /*
  73          * !!!
  74          * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
  75          *
  76          * Set up the marks.
  77          */
  78         LIST_INIT(&ep->marks);
  79         return (0);
  80 }
  81
  82 /*
  83  * mark_end --
  84  *      Free up the marks.
  85  *
  86  * PUBLIC: int mark_end __P((SCR *, EXF *));
  87  */
  88 int
  89 mark_end(SCR *sp, EXF *ep)
  90 {
  91         LMARK *lmp;
  92
  93         /*
  94          * !!!
  95          * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
  96          */
  97         while ((lmp = ep->marks.lh_first) != NULL) {
  98                 LIST_REMOVE(lmp, q);
  99                 free(lmp);
 100         }
 101         return (0);
 102 }
 103
 104 /*
 105  * mark_get --
 106  *      Get the location referenced by a mark.
 107  *
 108  * PUBLIC: int mark_get __P((SCR *, ARG_CHAR_T, MARK *, mtype_t));
 109  */
 110 int
 111 mark_get(SCR *sp, ARG_CHAR_T key, MARK *mp, mtype_t mtype)
 112 {
 113         LMARK *lmp;
 114
 115         if (key == ABSMARK2)
 116                 key = ABSMARK1;
 117
 118         lmp = mark_find(sp, key);
 119         if (lmp == NULL || (ARG_CHAR_T)lmp->name != key) {
 120                 msgq(sp, mtype, "017|Mark %s: not set", KEY_NAME(sp, key));
 121                 return (1);
 122         }
 123         if (F_ISSET(lmp, MARK_DELETED)) {
 124                 msgq(sp, mtype,
 125                     "018|Mark %s: the line was deleted", KEY_NAME(sp, key));
 126                 return (1);
 127         }
 128
 129         /*
 130          * !!!
 131          * The absolute mark is initialized to lno 1/cno 0, and historically
 132          * you could use it in an empty file.  Make such a mark always work.
 133          */
 134         if ((lmp->lno != 1 || lmp->cno != 0) && !db_exist(sp, lmp->lno)) {
 135                 msgq(sp, mtype,
 136                     "019|Mark %s: cursor position no longer exists",
 137                     KEY_NAME(sp, key));
 138                 return (1);
 139         }
 140         mp->lno = lmp->lno;
 141         mp->cno = lmp->cno;
 142         return (0);
 143 }
 144
 145 /*
 146  * mark_set --
 147  *      Set the location referenced by a mark.
 148  *
 149  * PUBLIC: int mark_set __P((SCR *, ARG_CHAR_T, MARK *, int));
 150  */
 151 int
 152 mark_set(SCR *sp, ARG_CHAR_T key, MARK *value, int userset)
 153 {
 154         LMARK *lmp, *lmt;
 155
 156         if (key == ABSMARK2)
 157                 key = ABSMARK1;
 158
 159         /*
 160          * The rules are simple.  If the user is setting a mark (if it's a
 161          * new mark this is always true), it always happens.  If not, it's
 162          * an undo, and we set it if it's not already set or if it was set
 163          * by a previous undo.
 164          */
 165         lmp = mark_find(sp, key);
 166         if (lmp == NULL || (ARG_CHAR_T)lmp->name != key) {
 167                 MALLOC_RET(sp, lmt, LMARK *, sizeof(LMARK));
 168                 if (lmp == NULL) {
 169                         LIST_INSERT_HEAD(&sp->ep->marks, lmt, q);
 170                 } else
 171                         LIST_INSERT_AFTER(lmp, lmt, q);
 172                 lmp = lmt;
 173         } else if (!userset &&
 174             !F_ISSET(lmp, MARK_DELETED) && F_ISSET(lmp, MARK_USERSET))
 175                 return (0);
 176
 177         lmp->lno = value->lno;
 178         lmp->cno = value->cno;
 179         lmp->name = key;
 180         lmp->flags = userset ? MARK_USERSET : 0;
 181         return (0);
 182 }
 183
 184 /*
 185  * mark_find --
 186  *      Find the requested mark, or, the slot immediately before
 187  *      where it would go.
 188  */
 189 static LMARK *
 190 mark_find(SCR *sp, ARG_CHAR_T key)
 191 {
 192         LMARK *lmp, *lastlmp;
 193
 194         /*
 195          * Return the requested mark or the slot immediately before
 196          * where it should go.
 197          */
 198         for (lastlmp = NULL, lmp = sp->ep->marks.lh_first;
 199             lmp != NULL; lastlmp = lmp, lmp = lmp->q.le_next)
 200                 if ((ARG_CHAR_T)lmp->name >= key)
 201                         return ((ARG_CHAR_T)lmp->name == key ? lmp : lastlmp);
 202         return (lastlmp);
 203 }
 204
 205 /*
 206  * mark_insdel --
 207  *      Update the marks based on an insertion or deletion.
 208  *
 209  * PUBLIC: int mark_insdel __P((SCR *, lnop_t, db_recno_t));
 210  */
 211 int
 212 mark_insdel(SCR *sp, lnop_t op, db_recno_t lno)
 213 {
 214         LMARK *lmp;
 215         db_recno_t lline;
 216
 217         switch (op) {
 218         case LINE_APPEND:
 219                 /* All insert/append operations are done as inserts. */
 220                 abort();
 221         case LINE_DELETE:
 222                 for (lmp = sp->ep->marks.lh_first;
 223                     lmp != NULL; lmp = lmp->q.le_next)
 224                         if (lmp->lno >= lno) {
 225                                 if (lmp->lno == lno) {
 226                                         F_SET(lmp, MARK_DELETED);
 227                                         (void)log_mark(sp, lmp);
 228                                 } else
 229                                         --lmp->lno;
 230                         }
 231                 break;
 232         case LINE_INSERT:
 233                 /*
 234                  * XXX
 235                  * Very nasty special case.  If the file was empty, then we're
 236                  * adding the first line, which is a replacement.  So, we don't
 237                  * modify the marks.  This is a hack to make:
 238                  *
 239                  *      mz:r!echo foo<carriage-return>'z
 240                  *
 241                  * work, i.e. historically you could mark the "line" in an empty
 242                  * file and replace it, and continue to use the mark.  Insane,
 243                  * well, yes, I know, but someone complained.
 244                  *
 245                  * Check for line #2 before going to the end of the file.
 246                  */
 247                 if (!db_exist(sp, 2)) {
 248                         if (db_last(sp, &lline))
 249                                 return (1);
 250                         if (lline == 1)
 251                                 return (0);
 252                 }
 253
 254                 for (lmp = sp->ep->marks.lh_first;
 255                     lmp != NULL; lmp = lmp->q.le_next)
 256                         if (lmp->lno >= lno)
 257                                 ++lmp->lno;
 258                 break;
 259         case LINE_RESET:
 260                 break;
 261         }
 262         return (0);
 263 }