BSD 4_3 development

[unix-history] / usr / contrib / jove / marks.c

/*************************************************************************
* This program is copyright (C) 1985, 1986 by Jonathan Payne.  It is    *
* provided to you without charge for use only on a licensed Unix        *
* system.  You may copy JOVE provided that this notice is included with *
* the copy.  You may not sell copies of this program or versions        *
* modified for use on microcomputer systems, unless the copies are      *
* included with a Unix system distribution and the source is provided.  *
*************************************************************************/

int     MarksShouldFloat = 1;

#include "jove.h"

Mark *
MakeMark(line, column, type)
register Line   *line;
{
       register Mark   *newmark = (Mark *) emalloc(sizeof *newmark);

       MarkSet(newmark, line, column);
       newmark->m_next = curbuf->b_marks;
       newmark->m_floater = type;
       curbuf->b_marks = newmark;
       return newmark;
}

DelMark(m)
register Mark   *m;
{
       register Mark   *mp = curbuf->b_marks;

       if (m == mp)
               curbuf->b_marks = m->m_next;
       else {
               while (mp != 0 && mp->m_next != m)
                       mp = mp->m_next;
               if (mp == 0)
                       complain("Unknown mark!");
               mp->m_next = m->m_next;
       }
       free((char *) m);
}

AllMarkSet(b, line, col)
Buffer  *b;
register Line   *line;
{
       register Mark   *mp;

       for (mp = b->b_marks; mp != 0; mp = mp->m_next)
               MarkSet(mp, line, col);
}

MarkSet(m, line, column)
Mark    *m;
Line    *line;
{
       m->m_line = line;
       m->m_char = column;
}

PopMark()
{
       int     pmark;

       if (curmark == 0)
               return;
       if (curbuf->b_markring[(curbuf->b_themark + 1) % NMARKS] == 0) {
               pmark = curbuf->b_themark;
               do {
                       if (--pmark < 0)
                               pmark = NMARKS - 1;
               } while (curbuf->b_markring[pmark] != 0);

               curbuf->b_markring[pmark] = MakeMark(curline, curchar, MarksShouldFloat);
               ToMark(curmark);
               DelMark(curmark);
               curmark = 0;
       } else
               PtToMark();

       pmark = curbuf->b_themark - 1;
       if (pmark < 0)
               pmark = NMARKS - 1;
       curbuf->b_themark = pmark;
}

SetMark()
{
       if (exp_p)
               PopMark();
       else
               DoSetMark(curline, curchar);
}

DoSetMark(l, c)
Line    *l;
{
       curbuf->b_themark = (curbuf->b_themark + 1) % NMARKS;
       if (curmark == 0)
               curmark = MakeMark(l, c, MarksShouldFloat);
       else
               MarkSet(curmark, l, c);
       s_mess("[Point pushed]");
}

/* Move point to Mark */

ToMark(m)
Mark    *m;
{
       int     len;

       if (m == 0)
               return;
       DotTo(m->m_line, m->m_char);
       if (curchar > (len = length(curline)))
               curchar = len;
}

Mark *
CurMark()
{
       if (curmark == 0)
               complain("No mark.");
       return curmark;
}

PtToMark()
{
       Line    *mline;
       int     mchar;
       Mark    *m = CurMark();

       mline = curline;
       mchar = curchar;

       ToMark(m);
       MarkSet(m, mline, mchar);
}

/* Fix marks for after a deletion.  For now, even marks that don't
  float will actually float, because we can't allow marks to point
  to non-existant lines. */

DFixMarks(line1, char1, line2, char2)
register Line   *line1,
               *line2;
{
       register Mark   *m;
       Line    *lp = line1;

       if (curbuf->b_marks == 0)
               return;
       while (lp != line2->l_next) {
               for (m = curbuf->b_marks; m != 0; m = m->m_next) {
/*                      if (!m->m_floater)
                               continue; */
                       if (m->m_line == lp)
                               m->m_char |= (1 << 15);
               }
               lp = lp->l_next;
       }
       for (m = curbuf->b_marks; m; m = m->m_next) {
/*              if (!m->m_floater)
                       continue; */
               if ((m->m_char & (1 << 15)) == 0)
                       continue;       /* Not effected */
               m->m_char &= ~(1 << 15);
               if (m->m_line == line1 && m->m_char < char1)
                       continue;       /* This mark is not affected */
               if (line1 == line2) {
                       if (m->m_char >= char1 && m->m_char <= char2)
                               m->m_char = char1;
                       else if (m->m_char > char2)
                               m->m_char -= (char2 - char1);
                       /* Same line move the mark backward */
               } else if (m->m_line == line2) {
                       if (m->m_char > char2)
                               m->m_char = char1 + (m->m_char - char2);
                       else
                               m->m_char = char1;
                       m->m_line = line1;
               } else {
                       m->m_char = char1;
                       m->m_line = line1;
               }
       }
}

/* Fix marks after an insertion.  Marks that don't float are ignored
  on insertion, which means PtToMark has to be careful ... */

IFixMarks(line1, char1, line2, char2)
register Line   *line1,
               *line2;
{
       register Mark   *m;

       for (m = curbuf->b_marks; m != 0; m = m->m_next) {
               if (!m->m_floater)
                       continue;
               if (m->m_line == line1) {
                       if (m->m_char > char1) {
                               m->m_line = line2;
                               if (line1 == line2)
                                       m->m_char += (char2 - char1);
                               else
                                       m->m_char = char2 + (m->m_char - char1);
                       }
               } 
       }
}