home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / gnu / src / baseline / jove-4.14.6.lha / jove-4.14.6 / marks.c < prev    next >
C/C++ Source or Header  |  1992-01-10  |  4KB  |  231 lines
  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. bool    MarksShouldFloat = ON;
  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 != NULL) {
  36.         next = m->m_next;
  37.         free((UnivPtr) 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 != NULL && mp->m_next != m)
  52.             mp = mp->m_next;
  53.         if (mp == NULL)
  54.             complain("Unknown mark!");
  55.         mp->m_next = m->m_next;
  56.     }
  57.     free((UnivPtr) 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 != NULL; 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 == NULL)
  88.         return;
  89.     if (curbuf->b_markring[(curbuf->b_themark + 1) % NMARKS] == NULL) {
  90.         pmark = curbuf->b_themark;
  91.         do {
  92.             if (--pmark < 0)
  93.                 pmark = NMARKS - 1;
  94.         } while (curbuf->b_markring[pmark] != NULL);
  95.  
  96.         curbuf->b_markring[pmark] = MakeMark(curline,
  97.             curchar, MarksShouldFloat ? M_FLOATER : M_FIXED);
  98.         ToMark(curmark);
  99.         DelMark(curmark);
  100.         curmark = NULL;
  101.     } else
  102.         PtToMark();
  103.  
  104.     pmark = curbuf->b_themark - 1;
  105.     if (pmark < 0)
  106.         pmark = NMARKS - 1;
  107.     curbuf->b_themark = pmark;
  108. }
  109.  
  110. void
  111. SetMark()
  112. {
  113.     if (is_an_arg())
  114.         PopMark();
  115.     else
  116.         set_mark();
  117. }
  118.  
  119. void
  120. set_mark()
  121. {
  122.     do_set_mark(curline, curchar);
  123. }
  124.  
  125. void
  126. do_set_mark(l, c)
  127. Line    *l;
  128. int    c;
  129. {
  130.     curbuf->b_themark = (curbuf->b_themark + 1) % NMARKS;
  131.     if (curmark == NULL)
  132.         curmark = MakeMark(l, c,
  133.             MarksShouldFloat ? M_FLOATER : M_FIXED);
  134.     else
  135.         MarkSet(curmark, l, c);
  136.     s_mess("[Point pushed]");
  137. }
  138.  
  139. /* Move point to Mark */
  140.  
  141. void
  142. ToMark(m)
  143. Mark    *m;
  144. {
  145.     int    len;
  146.  
  147.     if (m == NULL)
  148.         return;
  149.     DotTo(m->m_line, m->m_char);
  150.     if (curchar > (len = length(curline)))
  151.         curchar = len;
  152. }
  153.  
  154. Mark *
  155. CurMark()
  156. {
  157.     if (curmark == NULL)
  158.         complain("No mark.");
  159.     return curmark;
  160. }
  161.  
  162. void
  163. PtToMark()
  164. {
  165.     Line    *mline;
  166.     int    mchar;
  167.     Mark    *m = CurMark();
  168.  
  169.     mline = curline;
  170.     mchar = curchar;
  171.  
  172.     ToMark(m);
  173.     MarkSet(m, mline, mchar);
  174. }
  175.  
  176. /* Fix marks for after a deletion.  For now, even marks that don't
  177.    float will actually float, because we can't allow marks to point
  178.    to non-existant lines. */
  179.  
  180. void
  181. DFixMarks(line1, char1, line2, char2)
  182. register Line    *line1,
  183.         *line2;
  184. int    char1,
  185.     char2;
  186. {
  187.     register Mark    *m;
  188.     Line    *lp;
  189.  
  190.     if (curbuf->b_marks == NULL)
  191.         return;
  192.     for (lp = line1; lp != line2->l_next; lp = lp->l_next) {
  193.         for (m = curbuf->b_marks; m != NULL; m = m->m_next) {
  194.             if (m->m_line == lp
  195.             && (lp != line1 || m->m_char > char1))
  196.             {
  197.                 if (lp == line2 && m->m_char >= char2)
  198.                     m->m_char -= char2-char1;
  199.                 else
  200.                     m->m_char = char1;
  201.                 m->m_line = line1;
  202.                 if (line1 != line2)
  203.                     m->m_flags |= M_BIG_DELETE;
  204.             }
  205.         }
  206.     }
  207. }
  208.  
  209. /* Fix marks after an insertion.  Marks that don't float are ignored
  210.    on insertion, which means PtToMark has to be careful ... */
  211.  
  212. void
  213. IFixMarks(line1, char1, line2, char2)
  214. register Line    *line1,
  215.         *line2;
  216. int    char1,
  217.     char2;
  218. {
  219.     register Mark    *m;
  220.  
  221.     for (m = curbuf->b_marks; m != NULL; m = m->m_next) {
  222.         if ((m->m_flags & M_FLOATER)
  223.         && m->m_line == line1
  224.         && m->m_char > char1)
  225.         {
  226.             m->m_line = line2;
  227.             m->m_char += char2 - char1;
  228.         }
  229.     }
  230. }
  231.