![[BACK]](/icons/back.gif){kind=icon}
Return to mark.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim|
Return to mark.c CVS log | Up to [local] / src / usr.bin / vim |
1.1 downsj 1: /* $OpenBSD$ */
2: /* vi:set ts=4 sw=4:
3: *
4: * VIM - Vi IMproved by Bram Moolenaar
5: *
6: * Do ":help uganda" in Vim to read copying and usage conditions.
7: * Do ":help credits" in Vim to see a list of people who contributed.
8: */
9:
10: /*
11: * mark.c: functions for setting marks and jumping to them
12: */
13:
14: #include "vim.h"
15: #include "globals.h"
16: #include "proto.h"
17: #include "option.h"
18:
19: /*
20: * This file contains routines to maintain and manipulate marks.
21: */
22:
23: /*
24: * If a named file mark's lnum is non-zero, it is valid.
25: * If a named file mark's fnum is non-zero, it is for an existing buffer,
26: * otherwise it is from .viminfo and namedfm_names[n] is the file name.
27: * There are marks 'A - 'Z (set by user) and '0 to '9 (set when writing
28: * viminfo).
29: */
30: #define EXTRA_MARKS 10 /* marks 0-9 */
31: static struct filemark namedfm[NMARKS + EXTRA_MARKS]; /* marks with file nr */
32: static char_u *namedfm_names[NMARKS + EXTRA_MARKS]; /* name for namedfm[] */
33:
34: static void show_one_mark __ARGS((int, char_u *, FPOS *, char_u *));
35: static void cleanup_jumplist __ARGS((void));
36: #ifdef VIMINFO
37: static int removable __ARGS((char_u *name));
38: #endif
39:
40: /*
41: * setmark(c) - set named mark 'c' at current cursor position
42: *
43: * Returns OK on success, FAIL if no room for mark or bad name given.
44: */
45: int
46: setmark(c)
47: int c;
48: {
49: int i;
50:
51: if (c > 'z') /* some islower() and isupper() cannot handle
52: characters above 127 */
53: return FAIL;
54: if (islower(c))
55: {
56: i = c - 'a';
57: curbuf->b_namedm[i] = curwin->w_cursor;
58: return OK;
59: }
60: if (isupper(c))
61: {
62: i = c - 'A';
63: namedfm[i].mark = curwin->w_cursor;
64: namedfm[i].fnum = curbuf->b_fnum;
65: return OK;
66: }
67: return FAIL;
68: }
69:
70: /*
71: * setpcmark() - set the previous context mark to the current position
72: * and add it to the jump list
73: */
74: void
75: setpcmark()
76: {
77: int i;
78: #ifdef ROTATE
79: struct filemark tempmark;
80: #endif
81:
82: /* for :global the mark is set only once */
83: if (global_busy)
84: return;
85:
86: curwin->w_prev_pcmark = curwin->w_pcmark;
87: curwin->w_pcmark = curwin->w_cursor;
88:
89: #ifdef ROTATE
90: /*
91: * If last used entry is not at the top, put it at the top by rotating
92: * the stack until it is (the newer entries will be at the bottom).
93: * Keep one entry (the last used one) at the top.
94: */
95: if (curwin->w_jumplistidx < curwin->w_jumplistlen)
96: ++curwin->w_jumplistidx;
97: while (curwin->w_jumplistidx < curwin->w_jumplistlen)
98: {
99: tempmark = curwin->w_jumplist[curwin->w_jumplistlen - 1];
100: for (i = curwin->w_jumplistlen - 1; i > 0; --i)
101: curwin->w_jumplist[i] = curwin->w_jumplist[i - 1];
102: curwin->w_jumplist[0] = tempmark;
103: ++curwin->w_jumplistidx;
104: }
105: #endif
106:
107: /* If jumplist is full: remove oldest entry */
108: if (++curwin->w_jumplistlen > JUMPLISTSIZE)
109: {
110: curwin->w_jumplistlen = JUMPLISTSIZE;
111: for (i = 1; i < JUMPLISTSIZE; ++i)
112: curwin->w_jumplist[i - 1] = curwin->w_jumplist[i];
113: }
114: curwin->w_jumplistidx = curwin->w_jumplistlen - 1;
115:
116: #ifdef ARCHIE
117: /* Workaround for a bug in gcc 2.4.5 R2 on the Archimedes
118: * Should be fixed in 2.5.x.
119: */
120: curwin->w_jumplist[curwin->w_jumplistidx].mark.ptr = curwin->w_pcmark.ptr;
121: curwin->w_jumplist[curwin->w_jumplistidx].mark.col = curwin->w_pcmark.col;
122: #else
123: curwin->w_jumplist[curwin->w_jumplistidx].mark = curwin->w_pcmark;
124: #endif
125: curwin->w_jumplist[curwin->w_jumplistidx].fnum = curbuf->b_fnum;
126: ++curwin->w_jumplistidx;
127:
128: /* remove any duplicates, from the new entry or from previous deletes */
129: cleanup_jumplist();
130: }
131:
132: /*
133: * checkpcmark() - To change context, call setpcmark(), then move the current
134: * position to where ever, then call checkpcmark(). This
135: * ensures that the previous context will only be changed if
136: * the cursor moved to a different line. -- webb.
137: * If pcmark was deleted (with "dG") the previous mark is
138: * restored.
139: */
140: void
141: checkpcmark()
142: {
143: if (curwin->w_prev_pcmark.lnum != 0 &&
144: (equal(curwin->w_pcmark, curwin->w_cursor) ||
145: curwin->w_pcmark.lnum == 0))
146: {
147: curwin->w_pcmark = curwin->w_prev_pcmark;
148: curwin->w_prev_pcmark.lnum = 0; /* Show it has been checked */
149: }
150: }
151:
152: /*
153: * move "count" positions in the jump list (count may be negative)
154: */
155: FPOS *
156: movemark(count)
157: int count;
158: {
159: FPOS *pos;
160:
161: cleanup_jumplist();
162:
163: if (curwin->w_jumplistlen == 0) /* nothing to jump to */
164: return (FPOS *)NULL;
165:
166: if (curwin->w_jumplistidx + count < 0 ||
167: curwin->w_jumplistidx + count >= curwin->w_jumplistlen)
168: return (FPOS *)NULL;
169:
170: /*
171: * if first CTRL-O or CTRL-I command after a jump, add cursor position to
172: * list. Careful: If there are duplicates (CTRL-O immidiately after
173: * starting Vim on a file), another entry may have been removed.
174: */
175: if (curwin->w_jumplistidx == curwin->w_jumplistlen)
176: {
177: setpcmark();
178: --curwin->w_jumplistidx; /* skip the new entry */
179: if (curwin->w_jumplistidx + count < 0)
180: return (FPOS *)NULL;
181: }
182:
183: curwin->w_jumplistidx += count;
184: /* jump to other file */
185: if (curwin->w_jumplist[curwin->w_jumplistidx].fnum != curbuf->b_fnum)
186: {
187: if (buflist_getfile(curwin->w_jumplist[curwin->w_jumplistidx].fnum,
188: curwin->w_jumplist[curwin->w_jumplistidx].mark.lnum,
189: 0) == FAIL)
190: return (FPOS *)NULL;
191: curwin->w_cursor.col =
192: curwin->w_jumplist[curwin->w_jumplistidx].mark.col;
193: pos = (FPOS *)-1;
194: }
195: else
196: pos = &(curwin->w_jumplist[curwin->w_jumplistidx].mark);
197: return pos;
198: }
199:
200: /*
201: * getmark(c) - find mark for char 'c'
202: *
203: * Return pointer to FPOS if found (caller needs to check lnum!)
204: * NULL if there is no mark called 'c'.
205: * -1 if mark is in other file (only if changefile is TRUE)
206: */
207: FPOS *
208: getmark(c, changefile)
209: int c;
210: int changefile;
211: {
212: FPOS *posp;
213: FPOS *startp, *endp;
214: static FPOS pos_copy;
215: int len;
216: char_u *p;
217:
218: posp = NULL;
219: if (c > '~') /* check for islower()/isupper() */
220: ;
221: else if (c == '\'' || c == '`') /* previous context mark */
222: {
223: pos_copy = curwin->w_pcmark; /* need to make a copy because */
224: posp = &pos_copy; /* w_pcmark may be changed soon */
225: }
226: else if (c == '"') /* to pos when leaving buffer */
227: posp = &(curbuf->b_last_cursor);
228: else if (c == '[') /* to start of previous operator */
229: posp = &(curbuf->b_op_start);
230: else if (c == ']') /* to end of previous operator */
231: posp = &(curbuf->b_op_end);
232: else if (c == '<' || c == '>') /* start/end of visual area */
233: {
234: if (VIsual_active)
235: startp = &VIsual_save;
236: else
237: startp = &VIsual;
238: endp = &VIsual_end;
239: if ((c == '<') == lt(*startp, *endp))
240: posp = startp;
241: else
242: posp = endp;
243: }
244: else if (islower(c)) /* normal named mark */
245: posp = &(curbuf->b_namedm[c - 'a']);
246: else if (isupper(c) || isdigit(c)) /* named file mark */
247: {
248: if (isdigit(c))
249: c = c - '0' + NMARKS;
250: else
251: c -= 'A';
252: posp = &(namedfm[c].mark);
253:
254: if (namedfm[c].fnum == 0 && namedfm_names[c] != NULL)
255: {
256: /*
257: * First expand "~/" in the file name to the home directory.
258: * Try to find the shortname by comparing the fullname with the
259: * current directory.
260: */
261: expand_env(namedfm_names[c], NameBuff, MAXPATHL);
262: mch_dirname(IObuff, IOSIZE);
263: len = STRLEN(IObuff);
264: if (fnamencmp(IObuff, NameBuff, len) == 0)
265: {
266: p = NameBuff + len;
267: if (ispathsep(*p))
268: ++p;
269: }
270: else
271: p = NULL;
272: /* buflist_new will call fmarks_check_names() */
273: (void)buflist_new(NameBuff, p, (linenr_t)1, FALSE);
274: }
275:
276: if (namedfm[c].fnum != curbuf->b_fnum) /* mark is in other file */
277: {
278: if (namedfm[c].mark.lnum != 0 && changefile && namedfm[c].fnum)
279: {
280: if (buflist_getfile(namedfm[c].fnum,
281: namedfm[c].mark.lnum, GETF_SETMARK) == OK)
282: {
283: curwin->w_cursor.col = namedfm[c].mark.col;
284: return (FPOS *)-1;
285: }
286: }
287: posp = &pos_copy; /* mark exists, but is not valid in
288: current buffer */
289: pos_copy.lnum = 0;
290: }
291: }
292: return posp;
293: }
294:
295: /*
296: * Check all file marks for a name that matches the file name in buf.
297: * May replace the name with an fnum.
298: */
299: void
300: fmarks_check_names(buf)
301: BUF *buf;
302: {
303: char_u *name;
304: int i;
305:
306: if (buf->b_filename == NULL)
307: return;
308:
309: name = home_replace_save(buf, buf->b_filename);
310: if (name == NULL)
311: return;
312:
313: for (i = 0; i < NMARKS + EXTRA_MARKS; ++i)
314: {
315: if (namedfm[i].fnum == 0 && namedfm_names[i] != NULL &&
316: fnamecmp(name, namedfm_names[i]) == 0)
317: {
318: namedfm[i].fnum = buf->b_fnum;
319: vim_free(namedfm_names[i]);
320: namedfm_names[i] = NULL;
321: }
322: }
323: vim_free(name);
324: }
325:
326: /*
327: * Check a if a position from a mark is valid.
328: * Give and error message and return FAIL if not.
329: */
330: int
331: check_mark(pos)
332: FPOS *pos;
333: {
334: if (pos == NULL)
335: {
336: emsg(e_umark);
337: return FAIL;
338: }
339: if (pos->lnum == 0)
340: {
341: emsg(e_marknotset);
342: return FAIL;
343: }
344: if (pos->lnum > curbuf->b_ml.ml_line_count)
345: {
346: emsg(e_markinval);
347: return FAIL;
348: }
349: return OK;
350: }
351:
352: /*
353: * clrallmarks() - clear all marks in the buffer 'buf'
354: *
355: * Used mainly when trashing the entire buffer during ":e" type commands
356: */
357: void
358: clrallmarks(buf)
359: BUF *buf;
360: {
361: static int i = -1;
362:
363: if (i == -1) /* first call ever: initialize */
364: for (i = 0; i < NMARKS + 1; i++)
365: {
366: namedfm[i].mark.lnum = 0;
367: namedfm_names[i] = NULL;
368: }
369:
370: for (i = 0; i < NMARKS; i++)
371: buf->b_namedm[i].lnum = 0;
372: buf->b_op_start.lnum = 0; /* start/end op mark cleared */
373: buf->b_op_end.lnum = 0;
374: }
375:
376: /*
377: * get name of file from a filemark
378: * Careful: buflist_nr2name returns NameBuff.
379: */
380: char_u *
381: fm_getname(fmark)
382: struct filemark *fmark;
383: {
384: if (fmark->fnum != curbuf->b_fnum) /* not current file */
385: return buflist_nr2name(fmark->fnum, FALSE, TRUE);
386: return (char_u *)"-current-";
387: }
388:
389: /*
390: * print the marks
391: */
392: void
393: do_marks(arg)
394: char_u *arg;
395: {
396: int i;
397: char_u *name;
398:
399: if (arg != NULL && *arg == NUL)
400: arg = NULL;
401:
402: show_one_mark('\'', arg, &curwin->w_pcmark, NULL);
403: for (i = 0; i < NMARKS; ++i)
404: show_one_mark(i + 'a', arg, &curbuf->b_namedm[i], NULL);
405: for (i = 0; i < NMARKS + EXTRA_MARKS; ++i)
406: {
407: name = namedfm[i].fnum == 0 ? namedfm_names[i] :
408: fm_getname(&namedfm[i]);
409: if (name != NULL)
410: show_one_mark(i >= NMARKS ? i - NMARKS + '0' : i + 'A',
411: arg, &namedfm[i].mark, name);
412: }
413: show_one_mark('"', arg, &curbuf->b_last_cursor, NULL);
414: show_one_mark('[', arg, &curbuf->b_op_start, NULL);
415: show_one_mark(']', arg, &curbuf->b_op_end, NULL);
416: show_one_mark('<', arg, &VIsual, NULL);
417: show_one_mark('>', arg, &VIsual_end, NULL);
418: show_one_mark(-1, arg, NULL, NULL);
419: }
420:
421: static void
422: show_one_mark(c, arg, p, name)
423: int c;
424: char_u *arg;
425: FPOS *p;
426: char_u *name;
427: {
428: static int did_title = FALSE;
429:
430: if (c == -1) /* finish up */
431: {
432: if (did_title)
433: did_title = FALSE;
434: else
435: {
436: if (arg == NULL)
437: MSG("No marks set");
438: else
439: EMSG2("No marks matching \"%s\"", arg);
440: }
441: }
442: /* don't output anything if 'q' typed at --more-- prompt */
443: else if (!got_int && (arg == NULL || vim_strchr(arg, c) != NULL) &&
444: p->lnum != 0)
445: {
446: if (!did_title)
447: {
448: set_highlight('t'); /* Highlight title */
449: start_highlight();
450: MSG_OUTSTR("\nmark line col file");
451: stop_highlight();
452: did_title = TRUE;
453: }
454: msg_outchar('\n');
455: if (!got_int)
456: {
457: sprintf((char *)IObuff, " %c %5ld %3d ", c, p->lnum, p->col);
458: if (name != NULL)
459: STRCAT(IObuff, name);
460: msg_outtrans(IObuff);
461: }
462: flushbuf(); /* show one line at a time */
463: }
464: }
465:
466: /*
467: * print the jumplist
468: */
469: void
470: do_jumps()
471: {
472: int i;
473: char_u *name;
474:
475: cleanup_jumplist();
476: set_highlight('t'); /* Highlight title */
477: start_highlight();
478: MSG_OUTSTR("\n jump line file");
479: stop_highlight();
480: for (i = 0; i < curwin->w_jumplistlen; ++i)
481: {
482: if (curwin->w_jumplist[i].mark.lnum != 0)
483: {
484: name = fm_getname(&curwin->w_jumplist[i]);
485: if (name == NULL) /* file name not available */
486: continue;
487:
488: msg_outchar('\n');
489: sprintf((char *)IObuff, "%c %2d %5ld %s",
490: i == curwin->w_jumplistidx ? '>' : ' ',
491: i + 1,
492: curwin->w_jumplist[i].mark.lnum,
493: name);
494: msg_outtrans(IObuff);
495: }
496: flushbuf();
497: }
498: if (curwin->w_jumplistidx == curwin->w_jumplistlen)
499: MSG_OUTSTR("\n>");
500: }
501:
502: /*
503: * adjust marks between line1 and line2 (inclusive) to move 'amount' lines
504: * If 'amount' is MAXLNUM the mark is made invalid.
505: * If 'amount_after' is non-zero adjust marks after line 2.
506: */
507:
508: #define one_adjust(add) \
509: { \
510: lp = add; \
511: if (*lp >= line1 && *lp <= line2) \
512: { \
513: if (amount == MAXLNUM) \
514: *lp = 0; \
515: else \
516: *lp += amount; \
517: } \
518: else if (amount_after && *lp > line2) \
519: *lp += amount_after; \
520: }
521:
522: /* don't delete the line, just put at first deleted line */
523: #define one_adjust_nodel(add) \
524: { \
525: lp = add; \
526: if (*lp >= line1 && *lp <= line2) \
527: { \
528: if (amount == MAXLNUM) \
529: *lp = line1; \
530: else \
531: *lp += amount; \
532: } \
533: else if (amount_after && *lp > line2) \
534: *lp += amount_after; \
535: }
536:
537: void
538: mark_adjust(line1, line2, amount, amount_after)
539: linenr_t line1;
540: linenr_t line2;
541: long amount;
542: long amount_after;
543: {
544: int i;
545: int fnum = curbuf->b_fnum;
546: linenr_t *lp;
547: WIN *win;
548:
549: if (line2 < line1 && amount_after == 0L) /* nothing to do */
550: return;
551:
552: /* named marks, lower case and upper case */
553: for (i = 0; i < NMARKS; i++)
554: {
555: one_adjust(&(curbuf->b_namedm[i].lnum));
556: if (namedfm[i].fnum == fnum)
557: one_adjust(&(namedfm[i].mark.lnum));
558: }
559: for (i = NMARKS; i < NMARKS + EXTRA_MARKS; i++)
560: {
561: if (namedfm[i].fnum == fnum)
562: one_adjust(&(namedfm[i].mark.lnum));
563: }
564:
565: /* previous context mark */
566: one_adjust(&(curwin->w_pcmark.lnum));
567:
568: /* previous pcmark */
569: one_adjust(&(curwin->w_prev_pcmark.lnum));
570:
571: /* Visual area */
572: one_adjust_nodel(&(VIsual.lnum));
573: one_adjust_nodel(&(VIsual_end.lnum));
574:
575: /* marks in the tag stack */
576: for (i = 0; i < curwin->w_tagstacklen; i++)
577: if (curwin->w_tagstack[i].fmark.fnum == fnum)
578: one_adjust_nodel(&(curwin->w_tagstack[i].fmark.mark.lnum));
579:
580: /* quickfix marks */
581: qf_mark_adjust(line1, line2, amount, amount_after);
582:
583: /* jumplist marks */
584: for (win = firstwin; win != NULL; win = win->w_next)
585: {
586: /*
587: * When deleting lines, this may create duplicate marks in the
588: * jumplist. They will be removed later.
589: */
590: for (i = 0; i < win->w_jumplistlen; ++i)
591: if (win->w_jumplist[i].fnum == fnum)
592: one_adjust_nodel(&(win->w_jumplist[i].mark.lnum));
593: /*
594: * also adjust the line at the top of the window and the cursor
595: * position for windows with the same buffer.
596: */
597: if (win != curwin && win->w_buffer == curbuf)
598: {
599: if (win->w_topline >= line1 && win->w_topline <= line2)
600: {
601: if (amount == MAXLNUM) /* topline is deleted */
602: {
603: if (line1 <= 1)
604: win->w_topline = 1;
605: else
606: win->w_topline = line1 - 1;
607: }
608: else /* keep topline on the same line */
609: win->w_topline += amount;
610: }
611: else if (amount_after && win->w_topline > line2)
612: win->w_topline += amount_after;
613: if (win->w_cursor.lnum >= line1 && win->w_cursor.lnum <= line2)
614: {
615: if (amount == MAXLNUM) /* line with cursor is deleted */
616: {
617: if (line1 <= 1)
618: win->w_cursor.lnum = 1;
619: else
620: win->w_cursor.lnum = line1 - 1;
621: win->w_cursor.col = 0;
622: }
623: else /* keep cursor on the same line */
624: win->w_cursor.lnum += amount;
625: }
626: else if (amount_after && win->w_cursor.lnum > line2)
627: win->w_cursor.lnum += amount_after;
628: }
629: }
630: }
631:
632: /*
633: * When deleting lines, this may create duplicate marks in the
634: * jumplist. They will be removed here for the current window.
635: */
636: static void
637: cleanup_jumplist()
638: {
639: int i;
640: int from, to;
641:
642: to = 0;
643: for (from = 0; from < curwin->w_jumplistlen; ++from)
644: {
645: if (curwin->w_jumplistidx == from)
646: curwin->w_jumplistidx = to;
647: for (i = from + 1; i < curwin->w_jumplistlen; ++i)
648: if (curwin->w_jumplist[i].fnum == curwin->w_jumplist[from].fnum &&
649: curwin->w_jumplist[i].mark.lnum ==
650: curwin->w_jumplist[from].mark.lnum)
651: break;
652: if (i >= curwin->w_jumplistlen) /* no duplicate */
653: curwin->w_jumplist[to++] = curwin->w_jumplist[from];
654: }
655: if (curwin->w_jumplistidx == curwin->w_jumplistlen)
656: curwin->w_jumplistidx = to;
657: curwin->w_jumplistlen = to;
658: }
659:
660: void
661: set_last_cursor(win)
662: WIN *win;
663: {
664: win->w_buffer->b_last_cursor = win->w_cursor;
665: }
666:
667: #ifdef VIMINFO
668: int
669: read_viminfo_filemark(line, fp, force)
670: char_u *line;
671: FILE *fp;
672: int force;
673: {
674: int idx;
675: char_u *str;
676:
677: /* We only get here (hopefully) if line[0] == '\'' */
678: str = line + 1;
679: if (*str > 127 || (!isdigit(*str) && !isupper(*str)))
680: EMSG2("viminfo: Illegal file mark name in line %s", line);
681: else
682: {
683: if (isdigit(*str))
684: idx = *str - '0' + NMARKS;
685: else
686: idx = *str - 'A';
687: if (namedfm[idx].mark.lnum == 0 || force)
688: {
689: str = skipwhite(str + 1);
690: namedfm[idx].mark.lnum = getdigits(&str);
691: str = skipwhite(str);
692: namedfm[idx].mark.col = getdigits(&str);
693: str = skipwhite(str);
694: viminfo_readstring(line);
695: namedfm_names[idx] = strsave(str);
696: }
697: }
698: return vim_fgets(line, LSIZE, fp);
699: }
700:
701: void
702: write_viminfo_filemarks(fp)
703: FILE *fp;
704: {
705: int i;
706: char_u *name;
707:
708: if (get_viminfo_parameter('\'') == 0)
709: return;
710:
711: fprintf(fp, "\n# File marks:\n");
712:
713: /*
714: * Find a mark that is the same file and position as the cursor.
715: * That one, or else the last one is deleted.
716: * Move '0 to '1, '1 to '2, etc. until the matching one or '9
717: * Set '0 mark to current cursor position.
718: */
719: if (curbuf->b_filename != NULL && !removable(curbuf->b_filename))
720: {
721: name = buflist_nr2name(curbuf->b_fnum, TRUE, FALSE);
722: for (i = NMARKS; i < NMARKS + EXTRA_MARKS - 1; ++i)
723: if (namedfm[i].mark.lnum == curwin->w_cursor.lnum &&
724: (namedfm_names[i] == NULL ?
725: namedfm[i].fnum == curbuf->b_fnum :
726: STRCMP(name, namedfm_names[i]) == 0))
727: break;
728:
729: vim_free(namedfm_names[i]);
730: for ( ; i > NMARKS; --i)
731: {
732: namedfm[i] = namedfm[i - 1];
733: namedfm_names[i] = namedfm_names[i - 1];
734: }
735: namedfm[NMARKS].mark = curwin->w_cursor;
736: namedfm[NMARKS].fnum = curbuf->b_fnum;
737: namedfm_names[NMARKS] = NULL;
738: }
739:
740: for (i = 0; i < NMARKS + EXTRA_MARKS; i++)
741: {
742: if (namedfm[i].mark.lnum == 0) /* not set */
743: continue;
744:
745: if (namedfm[i].fnum) /* there is a buffer */
746: name = buflist_nr2name(namedfm[i].fnum, TRUE, FALSE);
747: else
748: name = namedfm_names[i]; /* use name from .viminfo */
749: if (name == NULL)
750: continue;
751:
752: fprintf(fp, "'%c %ld %ld %s\n",
753: i < NMARKS ? i + 'A' : i - NMARKS + '0',
754: (long)namedfm[i].mark.lnum,
755: (long)namedfm[i].mark.col,
756: name);
757: }
758: }
759:
760: /*
761: * Return TRUE if "name" is on removable media (depending on 'viminfo').
762: */
763: static int
764: removable(name)
765: char_u *name;
766: {
767: char_u *p;
768: char_u part[51];
769: int retval = FALSE;
770:
771: name = home_replace_save(NULL, name);
772: if (name != NULL)
773: {
774: for (p = p_viminfo; *p; )
775: {
776: copy_option_part(&p, part, 51, ", ");
777: if (part[0] == 'r' && vim_strnicmp(part + 1, name,
778: (size_t)STRLEN(part + 1)) == 0)
779: {
780: retval = TRUE;
781: break;
782: }
783: }
784: vim_free(name);
785: }
786: return retval;
787: }
788:
789: /*
790: * Write all the named marks for all buffers.
791: * Return the number of buffers for which marks have been written.
792: */
793: int
794: write_viminfo_marks(fp_out)
795: FILE *fp_out;
796: {
797: int count;
798: BUF *buf;
799: WIN *win;
800: int is_mark_set;
801: int i;
802:
803: /*
804: * Set b_last_cursor for the all buffers that have a window.
805: */
806: for (win = firstwin; win != NULL; win = win->w_next)
807: set_last_cursor(win);
808:
809: fprintf(fp_out, "\n# History of marks within files (newest to oldest):\n");
810: count = 0;
811: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
812: {
813: /*
814: * Only write something if buffer has been loaded and at least one
815: * mark is set.
816: */
817: if (buf->b_marks_read)
818: {
819: if (buf->b_last_cursor.lnum != 0)
820: is_mark_set = TRUE;
821: else
822: {
823: is_mark_set = FALSE;
824: for (i = 0; i < NMARKS; i++)
825: if (buf->b_namedm[i].lnum != 0)
826: {
827: is_mark_set = TRUE;
828: break;
829: }
830: }
831: if (is_mark_set && buf->b_filename != NULL &&
832: buf->b_filename[0] != NUL && !removable(buf->b_filename))
833: {
834: home_replace(NULL, buf->b_filename, IObuff, IOSIZE);
835: fprintf(fp_out, "\n> %s\n", (char *)IObuff);
836: if (buf->b_last_cursor.lnum != 0)
837: fprintf(fp_out, "\t\"\t%ld\t%d\n",
838: buf->b_last_cursor.lnum, buf->b_last_cursor.col);
839: for (i = 0; i < NMARKS; i++)
840: if (buf->b_namedm[i].lnum != 0)
841: fprintf(fp_out, "\t%c\t%ld\t%d\n", 'a' + i,
842: buf->b_namedm[i].lnum, buf->b_namedm[i].col);
843: count++;
844: }
845: }
846: }
847:
848: return count;
849: }
850:
851: /*
852: * Handle marks in the viminfo file:
853: * fp_out == NULL read marks for current buffer only
854: * fp_out != NULL copy marks for buffers not in buffer list
855: */
856: void
857: copy_viminfo_marks(line, fp_in, fp_out, count, eof)
858: char_u *line;
859: FILE *fp_in;
860: FILE *fp_out;
861: int count;
862: int eof;
863: {
864: BUF *buf;
865: int num_marked_files;
866: char_u save_char;
867: int load_marks;
868: int copy_marks_out;
869: char_u *str;
870: int i;
871: char_u *p;
872:
873: num_marked_files = get_viminfo_parameter('\'');
874: while (!eof && (count < num_marked_files || fp_out == NULL))
875: {
876: if (line[0] != '>')
877: {
878: if (line[0] != '\n' && line[0] != '\r' && line[0] != '#')
879: EMSG2("viminfo: Illegal starting char in line %s", line);
880: eof = vim_fgets(line, LSIZE, fp_in);
881: continue; /* Skip this dud line */
882: }
883:
884: /*
885: * Find filename, set str to start.
886: * Ignore leading and trailing white space.
887: */
888: str = skipwhite(line + 1);
889: p = str + STRLEN(str);
890: while (p != str && (*p == NUL || vim_isspace(*p)))
891: p--;
892: if (*p)
893: p++;
894: save_char = *p;
895: *p = NUL;
896:
897: /*
898: * If fp_out == NULL, load marks for current buffer.
899: * If fp_out != NULL, copy marks for buffers not in buflist.
900: */
901: load_marks = copy_marks_out = FALSE;
902: if (fp_out == NULL)
903: {
904: if (curbuf->b_filename != NULL &&
905: fullpathcmp(str, curbuf->b_filename) == FPC_SAME)
906: load_marks = TRUE;
907: }
908: else /* fp_out != NULL */
909: {
910: /* This is slow if there are many buffers!! */
911: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
912: if (buf->b_filename != NULL &&
913: fullpathcmp(str, buf->b_filename) == FPC_SAME)
914: break;
915:
916: /*
917: * copy marks if the buffer has not been loaded
918: */
919: if (buf == NULL || !buf->b_marks_read)
920: {
921: copy_marks_out = TRUE;
922: *p = save_char;
923: fputs("\n", fp_out);
924: fputs((char *)line, fp_out);
925: count++;
926: }
927: }
928: while (!(eof = vim_fgets(line, LSIZE, fp_in)) && line[0] == TAB)
929: {
930: if (load_marks)
931: {
932: if (line[1] == '"')
933: sscanf((char *)line + 2, "%ld %d",
934: &curbuf->b_last_cursor.lnum,
935: &curbuf->b_last_cursor.col);
936: else if ((i = line[1] - 'a') >= 0 && i < NMARKS)
937: sscanf((char *)line + 2, "%ld %d",
938: &curbuf->b_namedm[i].lnum,
939: &curbuf->b_namedm[i].col);
940: }
941: else if (copy_marks_out)
942: fputs((char *)line, fp_out);
943: }
944: if (load_marks)
945: return;
946: }
947: }
948: #endif /* VIMINFO */