![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to marks.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove|
Return to marks.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove |
1.1 ! root 1: /*************************************************************************** ! 2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE * ! 3: * is provided to you without charge, and with no warranty. You may give * ! 4: * away copies of JOVE, including sources, provided that this notice is * ! 5: * included in all the files. * ! 6: ***************************************************************************/ ! 7: ! 8: #include "jove.h" ! 9: ! 10: int MarksShouldFloat = 1; ! 11: ! 12: Mark * ! 13: MakeMark(line, column, type) ! 14: register Line *line; ! 15: int column, ! 16: type; ! 17: { ! 18: register Mark *newmark = (Mark *) emalloc(sizeof *newmark); ! 19: ! 20: MarkSet(newmark, line, column); ! 21: newmark->m_next = curbuf->b_marks; ! 22: newmark->m_flags = type; ! 23: curbuf->b_marks = newmark; ! 24: return newmark; ! 25: } ! 26: ! 27: void ! 28: flush_marks(b) ! 29: Buffer *b; ! 30: { ! 31: register Mark *m, ! 32: *next; ! 33: ! 34: m = b->b_marks; ! 35: while (m != 0) { ! 36: next = m->m_next; ! 37: free((char *) m); ! 38: m = next; ! 39: } ! 40: } ! 41: ! 42: void ! 43: DelMark(m) ! 44: register Mark *m; ! 45: { ! 46: register Mark *mp = curbuf->b_marks; ! 47: ! 48: if (m == mp) ! 49: curbuf->b_marks = m->m_next; ! 50: else { ! 51: while (mp != 0 && mp->m_next != m) ! 52: mp = mp->m_next; ! 53: if (mp == 0) ! 54: complain("Unknown mark!"); ! 55: mp->m_next = m->m_next; ! 56: } ! 57: free((char *) m); ! 58: } ! 59: ! 60: void ! 61: AllMarkSet(b, line, col) ! 62: Buffer *b; ! 63: register Line *line; ! 64: int col; ! 65: { ! 66: register Mark *mp; ! 67: ! 68: for (mp = b->b_marks; mp != 0; mp = mp->m_next) ! 69: MarkSet(mp, line, col); ! 70: } ! 71: ! 72: void ! 73: MarkSet(m, line, column) ! 74: Mark *m; ! 75: Line *line; ! 76: int column; ! 77: { ! 78: m->m_line = line; ! 79: m->m_char = column; ! 80: } ! 81: ! 82: void ! 83: PopMark() ! 84: { ! 85: int pmark; ! 86: ! 87: if (curmark == 0) ! 88: return; ! 89: if (curbuf->b_markring[(curbuf->b_themark + 1) % NMARKS] == 0) { ! 90: pmark = curbuf->b_themark; ! 91: do { ! 92: if (--pmark < 0) ! 93: pmark = NMARKS - 1; ! 94: } while (curbuf->b_markring[pmark] != 0); ! 95: ! 96: curbuf->b_markring[pmark] = MakeMark(curline, curchar, MarksShouldFloat ? M_FLOATER : M_FIXED); ! 97: ToMark(curmark); ! 98: DelMark(curmark); ! 99: curmark = 0; ! 100: } else ! 101: PtToMark(); ! 102: ! 103: pmark = curbuf->b_themark - 1; ! 104: if (pmark < 0) ! 105: pmark = NMARKS - 1; ! 106: curbuf->b_themark = pmark; ! 107: } ! 108: ! 109: void ! 110: SetMark() ! 111: { ! 112: if (is_an_arg()) ! 113: PopMark(); ! 114: else ! 115: set_mark(); ! 116: } ! 117: ! 118: void ! 119: set_mark() ! 120: { ! 121: do_set_mark(curline, curchar); ! 122: } ! 123: ! 124: void ! 125: do_set_mark(l, c) ! 126: Line *l; ! 127: int c; ! 128: { ! 129: curbuf->b_themark = (curbuf->b_themark + 1) % NMARKS; ! 130: if (curmark == 0) ! 131: curmark = MakeMark(l, c, MarksShouldFloat ? M_FLOATER : M_FIXED); ! 132: else ! 133: MarkSet(curmark, l, c); ! 134: s_mess("[Point pushed]"); ! 135: } ! 136: ! 137: /* Move point to Mark */ ! 138: ! 139: void ! 140: ToMark(m) ! 141: Mark *m; ! 142: { ! 143: int len; ! 144: ! 145: if (m == 0) ! 146: return; ! 147: DotTo(m->m_line, m->m_char); ! 148: if (curchar > (len = length(curline))) ! 149: curchar = len; ! 150: } ! 151: ! 152: Mark * ! 153: CurMark() ! 154: { ! 155: if (curmark == 0) ! 156: complain("No mark."); ! 157: return curmark; ! 158: } ! 159: ! 160: void ! 161: PtToMark() ! 162: { ! 163: Line *mline; ! 164: int mchar; ! 165: Mark *m = CurMark(); ! 166: ! 167: mline = curline; ! 168: mchar = curchar; ! 169: ! 170: ToMark(m); ! 171: MarkSet(m, mline, mchar); ! 172: } ! 173: ! 174: /* Fix marks for after a deletion. For now, even marks that don't ! 175: float will actually float, because we can't allow marks to point ! 176: to non-existant lines. */ ! 177: ! 178: void ! 179: DFixMarks(line1, char1, line2, char2) ! 180: register Line *line1, ! 181: *line2; ! 182: int char1, ! 183: char2; ! 184: { ! 185: register Mark *m; ! 186: Line *lp = line1; ! 187: ! 188: if (curbuf->b_marks == 0) ! 189: return; ! 190: while (lp != line2->l_next) { ! 191: for (m = curbuf->b_marks; m != 0; m = m->m_next) ! 192: if (m->m_line == lp) ! 193: m->m_char |= (1 << 15); ! 194: lp = lp->l_next; ! 195: } ! 196: for (m = curbuf->b_marks; m; m = m->m_next) { ! 197: if ((m->m_char & (1 << 15)) == 0) ! 198: continue; /* Not effected */ ! 199: m->m_char &= ~(1 << 15); ! 200: if (m->m_line == line1 && m->m_char < char1) ! 201: continue; /* This mark is not affected */ ! 202: if (line1 == line2) { ! 203: if (m->m_char >= char1 && m->m_char <= char2) ! 204: m->m_char = char1; ! 205: else if (m->m_char > char2) ! 206: m->m_char -= (char2 - char1); ! 207: /* Same line move the mark backward */ ! 208: } else if (m->m_line == line2) { ! 209: if (m->m_char > char2) ! 210: m->m_char = char1 + (m->m_char - char2); ! 211: else ! 212: m->m_char = char1; ! 213: m->m_flags |= M_BIG_DELETE; ! 214: m->m_line = line1; ! 215: } else { ! 216: m->m_char = char1; ! 217: m->m_line = line1; ! 218: m->m_flags |= M_BIG_DELETE; ! 219: } ! 220: } ! 221: } ! 222: ! 223: /* Fix marks after an insertion. Marks that don't float are ignored ! 224: on insertion, which means PtToMark has to be careful ... */ ! 225: ! 226: void ! 227: IFixMarks(line1, char1, line2, char2) ! 228: register Line *line1, ! 229: *line2; ! 230: int char1, ! 231: char2; ! 232: { ! 233: register Mark *m; ! 234: ! 235: for (m = curbuf->b_marks; m != 0; m = m->m_next) { ! 236: if ((m->m_flags & M_FLOATER) == 0) ! 237: continue; ! 238: if (m->m_line == line1) { ! 239: if (m->m_char > char1) { ! 240: m->m_line = line2; ! 241: if (line1 == line2) ! 242: m->m_char += (char2 - char1); ! 243: else ! 244: m->m_char = char2 + (m->m_char - char1); ! 245: } ! 246: } ! 247: } ! 248: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.