common/mark.c

   1 /*-
   2  * Copyright (c) 1992, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * %sccs.include.redist.c%
   6  */
   7
   8 #ifndef lint
   9 static char sccsid[] = "$Id: mark.c,v 8.10 1993/11/29 14:14:48 bostic Exp $ (Berkeley) $Date: 1993/11/29 14:14:48 $";
  10 #endif /* not lint */
  11
  12 #include <sys/types.h>
  13
  14 #include <errno.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17
  18 #include "vi.h"
  19
  20 static MARK *mark_find __P((SCR *, EXF *, ARG_CHAR_T));
  21
  22 /*
  23  * Marks are maintained in a key sorted doubly linked list.  We can't
  24  * use arrays because we have no idea how big an index key could be.
  25  * The underlying assumption is that users don't have more than, say,
  26  * 10 marks at any one time, so this will be is fast enough.
  27  *
  28  * Marks are fixed, and modifications to the line don't update the mark's
  29  * position in the line.  This can be hard.  If you add text to the line,
  30  * place a mark in that text, undo the addition and use ` to move to the
  31  * mark, the location will have disappeared.  It's tempting to try to adjust
  32  * the mark with the changes in the line, but this is hard to do, especially
  33  * if we've given the line to v_ntext.c:v_ntext() for editing.  Historic vi
  34  * would move to the first non-blank on the line when the mark location was
  35  * past the end of the line.  This can be complicated by deleting to a mark
  36  * that has disappeared using the ` command.  Historic vi vi treated this as
  37  * a line-mode motion and deleted the line.  This implementation complains to
  38  * the user.
  39  *
  40  * In historic vi, marks returned if the operation was undone, unless the
  41  * mark had been subsequently reset.  Tricky.  This is hard to start with,
  42  * but in the presence of repeated undo it gets nasty.  When a line is
  43  * deleted, we delete (and log) any marks on that line.  An undo will create
  44  * the mark.  Any mark creations are noted as to whether the user created
  45  * it or if it was created by an undo.  The former cannot be reset by another
  46  * undo, but the latter may.
  47  *
  48  * All of these routines translate ABSMARK2 to ABSMARK1.  Setting either of
  49  * the absolute mark locations sets both, so that "m'" and "m`" work like
  50  * they, ah, for lack of a better word, "should".
  51  */
  52
  53 /*
  54  * mark_init --
  55  *      Set up the marks.
  56  */
  57 int
  58 mark_init(sp, ep)
  59         SCR *sp;
  60         EXF *ep;
  61 {
  62         MARK *mp;
  63
  64         /*
  65          * Make sure the marks have been set up.  If they
  66          * haven't, do so, and create the absolute mark.
  67          */
  68         if ((mp = malloc(sizeof(MARK))) == NULL) {
  69                 msgq(sp, M_SYSERR, NULL);
  70                 return (1);
  71         }
  72         mp->lno = 1;
  73         mp->cno = 0;
  74         mp->name = ABSMARK1;
  75         mp->flags = 0;
  76         LIST_INSERT_HEAD(&ep->marks, mp, q);
  77         return (0);
  78 }
  79
  80 /*
  81  * mark_end --
  82  *      Free up the marks.
  83  */
  84 int
  85 mark_end(sp, ep)
  86         SCR *sp;
  87         EXF *ep;
  88 {
  89         MARK *mp;
  90
  91         while ((mp = ep->marks.lh_first) != NULL) {
  92                 LIST_REMOVE(mp, q);
  93                 FREE(mp, sizeof(MARK));
  94         }
  95         return (0);
  96 }
  97
  98 /*
  99  * mark_get --
 100  *      Get the location referenced by a mark.
 101  */
 102 MARK *
 103 mark_get(sp, ep, key)
 104         SCR *sp;
 105         EXF *ep;
 106         ARG_CHAR_T key;
 107 {
 108         MARK *mp;
 109         size_t len;
 110         char *p;
 111
 112         if (key == ABSMARK2)
 113                 key = ABSMARK1;
 114
 115         mp = mark_find(sp, ep, key);
 116         if (mp == NULL || mp->name != key) {
 117                 msgq(sp, M_BERR, "Mark %s: not set.", charname(sp, key));
 118                 return (NULL);
 119         }
 120         if (F_ISSET(mp, MARK_DELETED)) {
 121                 msgq(sp, M_BERR,
 122                     "Mark %s: the line was deleted.", charname(sp, key));
 123                 return (NULL);
 124         }
 125         if ((p = file_gline(sp, ep, mp->lno, &len)) == NULL ||
 126             mp->cno > len || mp->cno == len && len != 0) {
 127                 msgq(sp, M_BERR, "Mark %s: cursor position no longer exists.",
 128                     charname(sp, key));
 129                 return (NULL);
 130         }
 131         return (mp);
 132 }
 133
 134 /*
 135  * mark_set --
 136  *      Set the location referenced by a mark.
 137  */
 138 int
 139 mark_set(sp, ep, key, value, userset)
 140         SCR *sp;
 141         EXF *ep;
 142         ARG_CHAR_T key;
 143         MARK *value;
 144         int userset;
 145 {
 146         MARK *mp, *mt;
 147
 148         if (key == ABSMARK2)
 149                 key = ABSMARK1;
 150
 151         /*
 152          * The rules are simple.  If the user is setting a mark (if it's a
 153          * new mark this is always true), it always happens.  If not, it's
 154          * an undo, and we set it if it's not already set or if it was set
 155          * by a previous undo.
 156          */
 157         mp = mark_find(sp, ep, key);
 158         if (mp == NULL || mp->name != key) {
 159                 if ((mt = malloc(sizeof(MARK))) == NULL) {
 160                         msgq(sp, M_SYSERR, NULL);
 161                         return (1);
 162                 }
 163                 if (mp == NULL) {
 164                         LIST_INSERT_HEAD(&ep->marks, mt, q);
 165                 } else
 166                         LIST_INSERT_AFTER(mp, mt, q);
 167                 mp = mt;
 168         } else if (!userset &&
 169             !F_ISSET(mp, MARK_DELETED) && F_ISSET(mp, MARK_USERSET))
 170                 return (0);
 171
 172         mp->lno = value->lno;
 173         mp->cno = value->cno;
 174         mp->name = key;
 175         mp->flags = userset ? MARK_USERSET : 0;
 176         return (0);
 177 }
 178
 179 /*
 180  * mark_find --
 181  *      Find the requested mark, or, the slot immediately before
 182  *      where it would go.
 183  */
 184 static MARK *
 185 mark_find(sp, ep, key)
 186         SCR *sp;
 187         EXF *ep;
 188         ARG_CHAR_T key;
 189 {
 190         MARK *mp, *lastmp;
 191
 192         /*
 193          * Return the requested mark or the slot immediately before
 194          * where it should go.
 195          */
 196         for (lastmp = NULL, mp = ep->marks.lh_first;
 197             mp != NULL; lastmp = mp, mp = mp->q.le_next)
 198                 if (mp->name >= key)
 199                         return (mp->name == key ? mp : lastmp);
 200         return (lastmp);
 201 }
 202
 203 /*
 204  * mark_delete --
 205  *      Update the marks based on a deletion.
 206  */
 207 void
 208 mark_delete(sp, ep, lno)
 209         SCR *sp;
 210         EXF *ep;
 211         recno_t lno;
 212 {
 213         MARK *mp;
 214
 215         for (mp = ep->marks.lh_first; mp != NULL; mp = mp->q.le_next)
 216                 if (mp->lno >= lno)
 217                         if (mp->lno == lno) {
 218                                 F_SET(mp, MARK_DELETED);
 219                                 (void)log_mark(sp, ep, mp);
 220                         } else
 221                                 --mp->lno;
 222 }
 223
 224 /*
 225  * mark_insert --
 226  *      Update the marks based on an insertion.
 227  */
 228 void
 229 mark_insert(sp, ep, lno)
 230         SCR *sp;
 231         EXF *ep;
 232         recno_t lno;
 233 {
 234         MARK *mp;
 235
 236         for (mp = ep->marks.lh_first; mp != NULL; mp = mp->q.le_next)
 237                 if (mp->lno >= lno)
 238                         ++mp->lno;
 239 }