comparison src/intervals.c @ 1189:164176515d2a

comment changes

1188:a6d32838af49

   If POSITION is the first character of an interval, meaning that point
   is actually between the two intervals, make the new text belong to
   the interval which is "sticky".

   If both intervals are "stick", then make them belong to the left-most
   interval.  Another possibility would be to create a new interval for
   this text, and make it have the merged properties of both ends. */

static INTERVAL
adjust_intervals_for_insertion (tree, position, length)

      if (! NULL_INTERVAL_P (parent->right))
	parent->right->parent = parent;
    }
}

/* Recurse down to the interval containing FROM.  Then delete as much
   as possible (up to AMOUNT) from that interval, adjusting parental
   intervals on the way up.  If an interval is zeroed out, then
   it is deleted.

   Returns the amount deleted. */

static int
interval_deletion_adjustment (tree, from, amount)
     register INTERVAL tree;
     register int from, amount;

	      return my_amount;
	    }
	}
    }

  abort ();
}

static void
adjust_intervals_for_deletion (buffer, start, length)
     struct buffer *buffer;
     int start, length;

	  return;
	}
    }
}

/* Note that all intervals in OBJECT after START have slid by LENGTH. */

INLINE void
offset_intervals (buffer, start, length)
     struct buffer *buffer;
     int start, length;

  if (length > 0)
    adjust_intervals_for_insertion (buffer->intervals, start, length);
  else
    adjust_intervals_for_deletion (buffer, start, -length);
}

static INTERVAL
reproduce_tree (source, parent)
     INTERVAL source, parent;
{

  if (! NULL_RIGHT_CHILD (source))
    t->right = reproduce_tree (source->right, t);

  return t;
}

static INTERVAL
make_new_interval (intervals, start, length)
     INTERVAL intervals;
     int start, length;

1189:164176515d2a

   If POSITION is the first character of an interval, meaning that point
   is actually between the two intervals, make the new text belong to
   the interval which is "sticky".

   If both intervals are "sticky", then make them belong to the left-most
   interval.  Another possibility would be to create a new interval for
   this text, and make it have the merged properties of both ends. */

static INTERVAL
adjust_intervals_for_insertion (tree, position, length)

      if (! NULL_INTERVAL_P (parent->right))
	parent->right->parent = parent;
    }
}

/* Find the interval in TREE corresponding to the character position FROM
   and delete as much as possible of AMOUNT from that interval, starting
   after the relative position of FROM within it.  Return the amount
   actually deleted, and if the interval was zeroed-out, delete that
   interval node from the tree.

   Do this by recursing down TREE to the interval in question, and
   deleting the appropriate amount of text. */

static int
interval_deletion_adjustment (tree, from, amount)
     register INTERVAL tree;
     register int from, amount;

	      return my_amount;
	    }
	}
    }

  /* Never reach here */
  abort ();
}

/* Effect the adjustments neccessary to the interval tree of BUFFER
   to correspond to the deletion of LENGTH characters from that buffer
   text.  The deletion is effected at position START (relative to the
   buffer). */

static void
adjust_intervals_for_deletion (buffer, start, length)
     struct buffer *buffer;
     int start, length;

	  return;
	}
    }
}

/* Make the adjustments neccessary to the interval tree of BUFFER to
   represent an addition or deletion of LENGTH characters starting
   at position START.  Addition or deletion is indicated by the sign
   of LENGTH. */

INLINE void
offset_intervals (buffer, start, length)
     struct buffer *buffer;
     int start, length;

  if (length > 0)
    adjust_intervals_for_insertion (buffer->intervals, start, length);
  else
    adjust_intervals_for_deletion (buffer, start, -length);
}

/* Make an exact copy of interval tree SOURCE which descends from
   PARENT.  This is done by recursing through SOURCE, copying
   the current interval and its properties, and then adjusting
   the pointers of the copy. */

static INTERVAL
reproduce_tree (source, parent)
     INTERVAL source, parent;
{

  if (! NULL_RIGHT_CHILD (source))
    t->right = reproduce_tree (source->right, t);

  return t;
}

/* Make a new interval of length LENGTH starting at START in the
   group of intervals INTERVALS, which is actually an interval tree.
   Returns the new interval.

   Generate an error if the new positions would overlap an existing
   interval. */

static INTERVAL
make_new_interval (intervals, start, length)
     INTERVAL intervals;
     int start, length;