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