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