HCoop / bpt / emacs.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
(mik, pt154): New coding systems.
[bpt/emacs.git] / src / intervals.c
diff --git a/src/intervals.c b/src/intervals.c
index fa23272..09a9bc5 100644 (file)
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -1,5 +1,5 @@
 /* Code for doing intervals.
 /* Code for doing intervals.
-   Copyright (C) 1993, 1994, 1995, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1994, 1995, 1997, 1998 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
 
 This file is part of GNU Emacs.
 
@@ -45,18 +45,16 @@ Boston, MA 02111-1307, USA.  */
 #include "buffer.h"
 #include "puresize.h"
 #include "keyboard.h"
 #include "buffer.h"
 #include "puresize.h"
 #include "keyboard.h"
-
-/* The rest of the file is within this conditional.  */
-#ifdef USE_TEXT_PROPERTIES
+#include "keymap.h"
 
 /* Test for membership, allowing for t (actually any non-cons) to mean the
    universal set.  */
 
 #define TMEM(sym, set) (CONSP (set) ? ! NILP (Fmemq (sym, set)) : ! NILP (set))
 
 
 /* Test for membership, allowing for t (actually any non-cons) to mean the
    universal set.  */
 
 #define TMEM(sym, set) (CONSP (set) ? ! NILP (Fmemq (sym, set)) : ! NILP (set))
 
-#define min(x, y) ((x) < (y) ? (x) : (y))
-
 Lisp_Object merge_properties_sticky ();
 Lisp_Object merge_properties_sticky ();
+static INTERVAL reproduce_tree P_ ((INTERVAL, INTERVAL));
+static INTERVAL reproduce_tree_obj P_ ((INTERVAL, Lisp_Object));
 \f
 /* Utility functions for intervals.  */
 
 \f
 /* Utility functions for intervals.  */
 
@@ -78,15 +76,16 @@ create_root_interval (parent)
       new->total_length = (BUF_Z (XBUFFER (parent))
                           - BUF_BEG (XBUFFER (parent)));
       BUF_INTERVALS (XBUFFER (parent)) = new;
       new->total_length = (BUF_Z (XBUFFER (parent))
                           - BUF_BEG (XBUFFER (parent)));
       BUF_INTERVALS (XBUFFER (parent)) = new;
+      new->position = 1;
     }
   else if (STRINGP (parent))
     {
       new->total_length = XSTRING (parent)->size;
       XSTRING (parent)->intervals = new;
     }
   else if (STRINGP (parent))
     {
       new->total_length = XSTRING (parent)->size;
       XSTRING (parent)->intervals = new;
+      new->position = 0;
     }
 
     }
 
-  new->parent = (INTERVAL) parent;
-  new->position = 1;
+  SET_INTERVAL_OBJECT (new, parent);
 
   return new;
 }
 
   return new;
 }
@@ -145,7 +144,7 @@ intervals_equal (i0, i1)
      INTERVAL i0, i1;
 {
   register Lisp_Object i0_cdr, i0_sym, i1_val;
      INTERVAL i0, i1;
 {
   register Lisp_Object i0_cdr, i0_sym, i1_val;
-  register i1_len;
+  register int i1_len;
 
   if (DEFAULT_INTERVAL_P (i0) && DEFAULT_INTERVAL_P (i1))
     return 1;
 
   if (DEFAULT_INTERVAL_P (i0) && DEFAULT_INTERVAL_P (i1))
     return 1;
@@ -187,32 +186,57 @@ intervals_equal (i0, i1)
   return 1;
 }
 \f
   return 1;
 }
 \f
-static int icount;
-static int idepth;
-static int zero_length;
 
 /* Traverse an interval tree TREE, performing FUNCTION on each node.
 
 /* Traverse an interval tree TREE, performing FUNCTION on each node.
+   No guarantee is made about the order of traversal.
    Pass FUNCTION two args: an interval, and ARG.  */
 
 void
    Pass FUNCTION two args: an interval, and ARG.  */
 
 void
-traverse_intervals (tree, position, depth, function, arg)
+traverse_intervals_noorder (tree, function, arg)
      INTERVAL tree;
      INTERVAL tree;
-     int position, depth;
-     void (* function) ();
+     void (* function) P_ ((INTERVAL, Lisp_Object));
      Lisp_Object arg;
 {
      Lisp_Object arg;
 {
-  if (NULL_INTERVAL_P (tree))
-    return;
+  /* Minimize stack usage.  */
+  while (!NULL_INTERVAL_P (tree))
+    {
+      (*function) (tree, arg);
+      if (NULL_INTERVAL_P (tree->right))
+       tree = tree->left;
+      else
+       {
+         traverse_intervals_noorder (tree->left, function, arg);
+         tree = tree->right;
+       }
+    }
+}
 
 
-  traverse_intervals (tree->left, position, depth + 1, function, arg);
-  position += LEFT_TOTAL_LENGTH (tree);
-  tree->position = position;
-  (*function) (tree, arg);
-  position += LENGTH (tree);
-  traverse_intervals (tree->right, position, depth + 1,  function, arg);
+/* Traverse an interval tree TREE, performing FUNCTION on each node.
+   Pass FUNCTION two args: an interval, and ARG.  */
+
+void
+traverse_intervals (tree, position, function, arg)
+     INTERVAL tree;
+     int position;
+     void (* function) P_ ((INTERVAL, Lisp_Object));
+     Lisp_Object arg;
+{
+  while (!NULL_INTERVAL_P (tree))
+    {
+      traverse_intervals (tree->left, position, function, arg);
+      position += LEFT_TOTAL_LENGTH (tree);
+      tree->position = position;
+      (*function) (tree, arg);
+      position += LENGTH (tree); tree = tree->right;
+    }
 }
 \f
 #if 0
 }
 \f
 #if 0
+
+static int icount;
+static int idepth;
+static int zero_length;
+
 /* These functions are temporary, for debugging purposes only.  */
 
 INTERVAL search_interval, found_interval;
 /* These functions are temporary, for debugging purposes only.  */
 
 INTERVAL search_interval, found_interval;
@@ -235,7 +259,7 @@ search_for_interval (i, tree)
   icount = 0;
   search_interval = i;
   found_interval = NULL_INTERVAL;
   icount = 0;
   search_interval = i;
   found_interval = NULL_INTERVAL;
-  traverse_intervals (tree, 1, 0, &check_for_interval, Qnil);
+  traverse_intervals_noorder (tree, &check_for_interval, Qnil);
   return found_interval;
 }
 
   return found_interval;
 }
 
@@ -257,7 +281,7 @@ count_intervals (i)
   icount = 0;
   idepth = 0;
   zero_length = 0;
   icount = 0;
   idepth = 0;
   zero_length = 0;
-  traverse_intervals (i, 1, 0, &inc_interval_count, Qnil);
+  traverse_intervals_noorder (i, &inc_interval_count, Qnil);
 
   return icount;
 }
 
   return icount;
 }
@@ -269,7 +293,7 @@ root_interval (interval)
   register INTERVAL i = interval;
 
   while (! ROOT_INTERVAL_P (i))
   register INTERVAL i = interval;
 
   while (! ROOT_INTERVAL_P (i))
-    i = i->parent;
+    i = INTERVAL_PARENT (i);
 
   return i;
 }
 
   return i;
 }
@@ -284,7 +308,7 @@ root_interval (interval)
      c           c
 */
 
      c           c
 */
 
-static INTERVAL
+static INLINE INTERVAL
 rotate_right (interval)
      INTERVAL interval;
 {
 rotate_right (interval)
      INTERVAL interval;
 {
@@ -294,21 +318,23 @@ rotate_right (interval)
 
   /* Deal with any Parent of A;  make it point to B.  */
   if (! ROOT_INTERVAL_P (interval))
 
   /* Deal with any Parent of A;  make it point to B.  */
   if (! ROOT_INTERVAL_P (interval))
-    if (AM_LEFT_CHILD (interval))
-      interval->parent->left = B;
-    else
-      interval->parent->right = B;
-  B->parent = interval->parent;
+    {
+      if (AM_LEFT_CHILD (interval))
+       INTERVAL_PARENT (interval)->left = B;
+      else
+       INTERVAL_PARENT (interval)->right = B;
+    }
+  COPY_INTERVAL_PARENT (B, interval);
 
   /* Make B the parent of A */
   i = B->right;
   B->right = interval;
 
   /* Make B the parent of A */
   i = B->right;
   B->right = interval;
-  interval->parent = B;
+  SET_INTERVAL_PARENT (interval, B);
 
   /* Make A point to c */
   interval->left = i;
   if (! NULL_INTERVAL_P (i))
 
   /* Make A point to c */
   interval->left = i;
   if (! NULL_INTERVAL_P (i))
-    i->parent = interval;
+    SET_INTERVAL_PARENT (i, interval);
 
   /* A's total length is decreased by the length of B and its left child.  */
   interval->total_length -= B->total_length - LEFT_TOTAL_LENGTH (interval);
 
   /* A's total length is decreased by the length of B and its left child.  */
   interval->total_length -= B->total_length - LEFT_TOTAL_LENGTH (interval);
@@ -328,7 +354,7 @@ rotate_right (interval)
     c               c
 */
 
     c               c
 */
 
-static INTERVAL
+static INLINE INTERVAL
 rotate_left (interval)
      INTERVAL interval;
 {
 rotate_left (interval)
      INTERVAL interval;
 {
@@ -338,21 +364,23 @@ rotate_left (interval)
 
   /* Deal with any parent of A;  make it point to B.  */
   if (! ROOT_INTERVAL_P (interval))
 
   /* Deal with any parent of A;  make it point to B.  */
   if (! ROOT_INTERVAL_P (interval))
-    if (AM_LEFT_CHILD (interval))
-      interval->parent->left = B;
-    else
-      interval->parent->right = B;
-  B->parent = interval->parent;
+    {
+      if (AM_LEFT_CHILD (interval))
+       INTERVAL_PARENT (interval)->left = B;
+      else
+       INTERVAL_PARENT (interval)->right = B;
+    }
+  COPY_INTERVAL_PARENT (B, interval);
 
   /* Make B the parent of A */
   i = B->left;
   B->left = interval;
 
   /* Make B the parent of A */
   i = B->left;
   B->left = interval;
-  interval->parent = B;
+  SET_INTERVAL_PARENT (interval, B);
 
   /* Make A point to c */
   interval->right = i;
   if (! NULL_INTERVAL_P (i))
 
   /* Make A point to c */
   interval->right = i;
   if (! NULL_INTERVAL_P (i))
-    i->parent = interval;
+    SET_INTERVAL_PARENT (i, interval);
 
   /* A's total length is decreased by the length of B and its right child.  */
   interval->total_length -= B->total_length - RIGHT_TOTAL_LENGTH (interval);
 
   /* A's total length is decreased by the length of B and its right child.  */
   interval->total_length -= B->total_length - RIGHT_TOTAL_LENGTH (interval);
@@ -407,17 +435,25 @@ balance_possible_root_interval (interval)
      register INTERVAL interval;
 {
   Lisp_Object parent;
      register INTERVAL interval;
 {
   Lisp_Object parent;
+  int have_parent = 0;
 
 
-  if (interval->parent == NULL_INTERVAL)
+  if (!INTERVAL_HAS_OBJECT (interval) && !INTERVAL_HAS_PARENT (interval))
     return interval;
 
     return interval;
 
-  parent = (Lisp_Object) (interval->parent);
+  if (INTERVAL_HAS_OBJECT (interval))
+    {
+      have_parent = 1;
+      GET_INTERVAL_OBJECT (parent, interval);
+    }
   interval = balance_an_interval (interval);
 
   interval = balance_an_interval (interval);
 
-  if (BUFFERP (parent))
-    BUF_INTERVALS (XBUFFER (parent)) = interval;
-  else if (STRINGP (parent))
-    XSTRING (parent)->intervals = interval;
+  if (have_parent)
+    {
+      if (BUFFERP (parent))
+       BUF_INTERVALS (XBUFFER (parent)) = interval;
+      else if (STRINGP (parent))
+       XSTRING (parent)->intervals = interval;
+    }
 
   return interval;
 }
 
   return interval;
 }
@@ -472,23 +508,23 @@ split_interval_right (interval, offset)
   int new_length = LENGTH (interval) - offset;
 
   new->position = position + offset;
   int new_length = LENGTH (interval) - offset;
 
   new->position = position + offset;
-  new->parent = interval;
+  SET_INTERVAL_PARENT (new, interval);
 
   if (NULL_RIGHT_CHILD (interval))
     {
       interval->right = new;
       new->total_length = new_length;
 
   if (NULL_RIGHT_CHILD (interval))
     {
       interval->right = new;
       new->total_length = new_length;
-
-      return new;
     }
     }
-
-  /* Insert the new node between INTERVAL and its right child.  */
-  new->right = interval->right;
-  interval->right->parent = new;
-  interval->right = new;
-  new->total_length = new_length + new->right->total_length;
-
-  balance_an_interval (new);
+  else
+    {
+      /* Insert the new node between INTERVAL and its right child.  */
+      new->right = interval->right;
+      SET_INTERVAL_PARENT (interval->right, new);
+      interval->right = new;
+      new->total_length = new_length + new->right->total_length;
+      balance_an_interval (new);
+    }
+  
   balance_possible_root_interval (interval);
 
   return new;
   balance_possible_root_interval (interval);
 
   return new;
@@ -513,37 +549,62 @@ split_interval_left (interval, offset)
      int offset;
 {
   INTERVAL new = make_interval ();
      int offset;
 {
   INTERVAL new = make_interval ();
-  int position = interval->position;
   int new_length = offset;
 
   new->position = interval->position;
   interval->position = interval->position + offset;
   int new_length = offset;
 
   new->position = interval->position;
   interval->position = interval->position + offset;
-  new->parent = interval;
+  SET_INTERVAL_PARENT (new, interval);
 
   if (NULL_LEFT_CHILD (interval))
     {
       interval->left = new;
       new->total_length = new_length;
 
   if (NULL_LEFT_CHILD (interval))
     {
       interval->left = new;
       new->total_length = new_length;
-
-      return new;
     }
     }
-
-  /* Insert the new node between INTERVAL and its left child.  */
-  new->left = interval->left;
-  new->left->parent = new;
-  interval->left = new;
-  new->total_length = new_length + new->left->total_length;
-
-  balance_an_interval (new);
+  else
+    {
+      /* Insert the new node between INTERVAL and its left child.  */
+      new->left = interval->left;
+      SET_INTERVAL_PARENT (new->left, new);
+      interval->left = new;
+      new->total_length = new_length + new->left->total_length;
+      balance_an_interval (new);
+    }
+  
   balance_possible_root_interval (interval);
 
   return new;
 }
 \f
   balance_possible_root_interval (interval);
 
   return new;
 }
 \f
+/* Return the proper position for the first character
+   described by the interval tree SOURCE.
+   This is 1 if the parent is a buffer,
+   0 if the parent is a string or if there is no parent.
+
+   Don't use this function on an interval which is the child
+   of another interval!  */
+
+int
+interval_start_pos (source)
+     INTERVAL source;
+{
+  Lisp_Object parent;
+
+  if (NULL_INTERVAL_P (source))
+    return 0;
+
+  if (! INTERVAL_HAS_OBJECT (source))
+    return 0;
+  GET_INTERVAL_OBJECT (parent, source);
+  if (BUFFERP (parent))
+    return BUF_BEG (XBUFFER (parent));
+  return 0;
+}
+
 /* Find the interval containing text position POSITION in the text
    represented by the interval tree TREE.  POSITION is a buffer
 /* Find the interval containing text position POSITION in the text
    represented by the interval tree TREE.  POSITION is a buffer
-   position; the earliest position is 1.  If POSITION is at the end of
-   the buffer, return the interval containing the last character.
+   position (starting from 1) or a string index (starting from 0).
+   If POSITION is at the end of the buffer or string,
+   return the interval containing the last character.
 
    The `position' field, which is a cache of an interval's position,
    is updated in the interval found.  Other functions (e.g., next_interval)
 
    The `position' field, which is a cache of an interval's position,
    is updated in the interval found.  Other functions (e.g., next_interval)
@@ -556,15 +617,25 @@ find_interval (tree, position)
 {
   /* The distance from the left edge of the subtree at TREE
                     to POSITION.  */
 {
   /* The distance from the left edge of the subtree at TREE
                     to POSITION.  */
-  register int relative_position = position - BEG;
+  register int relative_position;
 
   if (NULL_INTERVAL_P (tree))
     return NULL_INTERVAL;
 
 
   if (NULL_INTERVAL_P (tree))
     return NULL_INTERVAL;
 
+  relative_position = position;
+  if (INTERVAL_HAS_OBJECT (tree))
+    {
+      Lisp_Object parent;
+      GET_INTERVAL_OBJECT (parent, tree);
+      if (BUFFERP (parent))
+       relative_position -= BUF_BEG (XBUFFER (parent));
+    }
+
   if (relative_position > TOTAL_LENGTH (tree))
     abort ();                  /* Paranoia */
 
   if (relative_position > TOTAL_LENGTH (tree))
     abort ();                  /* Paranoia */
 
-  tree = balance_possible_root_interval (tree);
+  if (!handling_signal)
+    tree = balance_possible_root_interval (tree);
 
   while (1)
     {
 
   while (1)
     {
@@ -582,9 +653,9 @@ find_interval (tree, position)
        }
       else
        {
        }
       else
        {
-         tree->position =
-           (position - relative_position /* the left edge of *tree */
-            + LEFT_TOTAL_LENGTH (tree)); /* the left edge of this interval */
+         tree->position
+           = (position - relative_position /* the left edge of *tree */
+              + LEFT_TOTAL_LENGTH (tree)); /* the left edge of this interval */
 
          return tree;
        }
 
          return tree;
        }
@@ -620,12 +691,12 @@ next_interval (interval)
     {
       if (AM_LEFT_CHILD (i))
        {
     {
       if (AM_LEFT_CHILD (i))
        {
-         i = i->parent;
+         i = INTERVAL_PARENT (i);
          i->position = next_position;
          return i;
        }
 
          i->position = next_position;
          return i;
        }
 
-      i = i->parent;
+      i = INTERVAL_PARENT (i);
     }
 
   return NULL_INTERVAL;
     }
 
   return NULL_INTERVAL;
@@ -640,7 +711,6 @@ previous_interval (interval)
      register INTERVAL interval;
 {
   register INTERVAL i;
      register INTERVAL interval;
 {
   register INTERVAL i;
-  register position_of_previous;
 
   if (NULL_INTERVAL_P (interval))
     return NULL_INTERVAL;
 
   if (NULL_INTERVAL_P (interval))
     return NULL_INTERVAL;
@@ -660,19 +730,22 @@ previous_interval (interval)
     {
       if (AM_RIGHT_CHILD (i))
        {
     {
       if (AM_RIGHT_CHILD (i))
        {
-         i = i->parent;
+         i = INTERVAL_PARENT (i);
 
          i->position = interval->position - LENGTH (i);
          return i;
        }
 
          i->position = interval->position - LENGTH (i);
          return i;
        }
-      i = i->parent;
+      i = INTERVAL_PARENT (i);
     }
 
   return NULL_INTERVAL;
 }
 
 /* Find the interval containing POS given some non-NULL INTERVAL
     }
 
   return NULL_INTERVAL;
 }
 
 /* Find the interval containing POS given some non-NULL INTERVAL
-   in the same tree. */
+   in the same tree.  Note that we need to update interval->position
+   if we go down the tree.
+   To speed up the process, we assume that the ->position of
+   I and all its parents is already uptodate.  */
 INTERVAL
 update_interval (i, pos)
      register INTERVAL i;
 INTERVAL
 update_interval (i, pos)
      register INTERVAL i;
@@ -686,22 +759,31 @@ update_interval (i, pos)
       if (pos < i->position) 
        {
          /* Move left. */
       if (pos < i->position) 
        {
          /* Move left. */
-         if (pos >= i->position - TOTAL_LENGTH (i->left))
-           i = i->left;                /* Move to the left child */
+         if (pos >= i->position - TOTAL_LENGTH (i->left)) 
+           {
+             i->left->position = i->position - TOTAL_LENGTH (i->left)
+               + LEFT_TOTAL_LENGTH (i->left);
+             i = i->left;              /* Move to the left child */
+           }
          else if (NULL_PARENT (i)) 
            error ("Point before start of properties");
          else if (NULL_PARENT (i)) 
            error ("Point before start of properties");
-         else  i = i->parent;
+         else  
+             i = INTERVAL_PARENT (i);
          continue;
        }
       else if (pos >= INTERVAL_LAST_POS (i))
        {
          /* Move right. */
          continue;
        }
       else if (pos >= INTERVAL_LAST_POS (i))
        {
          /* Move right. */
-         if (pos < INTERVAL_LAST_POS (i) + TOTAL_LENGTH (i->right))
-           i = i->right;               /* Move to the right child */
+         if (pos < INTERVAL_LAST_POS (i) + TOTAL_LENGTH (i->right)) 
+           {
+             i->right->position = INTERVAL_LAST_POS (i) +
+               LEFT_TOTAL_LENGTH (i->right);
+             i = i->right;             /* Move to the right child */
+           }
          else if (NULL_PARENT (i)) 
            error ("Point after end of properties");
          else 
          else if (NULL_PARENT (i)) 
            error ("Point after end of properties");
          else 
-           i = i->parent;
+             i = INTERVAL_PARENT (i);
          continue;
        }
       else 
          continue;
        }
       else 
@@ -790,54 +872,90 @@ adjust_intervals_for_insertion (tree, position, length)
   register INTERVAL i;
   register INTERVAL temp;
   int eobp = 0;
   register INTERVAL i;
   register INTERVAL temp;
   int eobp = 0;
+  Lisp_Object parent;
+  int offset;
   
   if (TOTAL_LENGTH (tree) == 0)        /* Paranoia */
     abort ();
 
   
   if (TOTAL_LENGTH (tree) == 0)        /* Paranoia */
     abort ();
 
+  GET_INTERVAL_OBJECT (parent, tree);
+  offset = (BUFFERP (parent) ? BUF_BEG (XBUFFER (parent)) : 0);
+
   /* If inserting at point-max of a buffer, that position will be out
      of range.  Remember that buffer positions are 1-based.  */
   /* If inserting at point-max of a buffer, that position will be out
      of range.  Remember that buffer positions are 1-based.  */
-  if (position >= BEG + TOTAL_LENGTH (tree)){
-    position = BEG + TOTAL_LENGTH (tree);
-    eobp = 1;
-  }
+  if (position >= TOTAL_LENGTH (tree) + offset)
+    {
+      position = TOTAL_LENGTH (tree) + offset;
+      eobp = 1;
+    }
 
   i = find_interval (tree, position);
 
   /* If in middle of an interval which is not sticky either way,
      we must not just give its properties to the insertion.
 
   i = find_interval (tree, position);
 
   /* If in middle of an interval which is not sticky either way,
      we must not just give its properties to the insertion.
-     So split this interval at the insertion point.  */
-  if (! (position == i->position || eobp)
-      && END_NONSTICKY_P (i)
-      && FRONT_NONSTICKY_P (i))
+     So split this interval at the insertion point.
+
+     Originally, the if condition here was this:
+       (! (position == i->position || eobp)
+        && END_NONSTICKY_P (i)
+        && FRONT_NONSTICKY_P (i))
+     But, these macros are now unreliable because of introduction of
+     Vtext_property_default_nonsticky.  So, we always check properties
+     one by one if POSITION is in middle of an interval.  */
+  if (! (position == i->position || eobp))
     {
       Lisp_Object tail;
       Lisp_Object front, rear;
 
     {
       Lisp_Object tail;
       Lisp_Object front, rear;
 
-      front = textget (i->plist, Qfront_sticky);
-      rear  = textget (i->plist, Qrear_nonsticky);
+      tail = i->plist;
 
 
-      /* Does any actual property pose an actual problem?  */
-      for (tail = i->plist; ! NILP (tail); tail = Fcdr (Fcdr (tail)))
+      /* Properties font-sticky and rear-nonsticky override
+         Vtext_property_default_nonsticky.  So, if they are t, we can
+         skip one by one checking of properties.  */
+      rear = textget (i->plist, Qrear_nonsticky);
+      if (! CONSP (rear) && ! NILP (rear))
+       {
+         /* All properties are nonsticky.  We split the interval.  */
+         goto check_done;
+       }
+      front = textget (i->plist, Qfront_sticky);
+      if (! CONSP (front) && ! NILP (front))
        {
        {
-         Lisp_Object prop;
-         prop = XCONS (tail)->car;
+         /* All properties are sticky.  We don't split the interval.  */
+         tail = Qnil;
+         goto check_done;
+       }
 
 
-         /* Is this particular property rear-sticky?
-            Note, if REAR isn't a cons, it must be non-nil,
-            which means that all properties are rear-nonsticky.  */
-         if (CONSP (rear) && NILP (Fmemq (prop, rear)))
-           continue;
+      /* Does any actual property pose an actual problem?  We break
+         the loop if we find a nonsticky property.  */
+      for (; CONSP (tail); tail = Fcdr (XCDR (tail)))
+       {
+         Lisp_Object prop, tmp;
+         prop = XCAR (tail);
 
 
-         /* Is this particular property front-sticky?
-            Note, if FRONT isn't a cons, it must be nil,
-            which means that all properties are front-nonsticky.  */
+         /* Is this particular property front-sticky?  */
          if (CONSP (front) && ! NILP (Fmemq (prop, front)))
            continue;
 
          if (CONSP (front) && ! NILP (Fmemq (prop, front)))
            continue;
 
-         /* PROP isn't sticky on either side => it is a real problem.  */
-         break;
+         /* Is this particular property rear-nonsticky?  */
+         if (CONSP (rear) && ! NILP (Fmemq (prop, rear)))
+           break;
+
+         /* Is this particular property recorded as sticky or
+             nonsticky in Vtext_property_default_nonsticky?  */
+         tmp = Fassq (prop, Vtext_property_default_nonsticky);
+         if (CONSP (tmp))
+           {
+             if (NILP (tmp))
+               continue;
+             break;
+           }
+
+         /* By default, a text property is rear-sticky, thus we
+            continue the loop.  */
        }
 
        }
 
+    check_done:
       /* If any property is a real problem, split the interval.  */
       if (! NILP (tail))
        {
       /* If any property is a real problem, split the interval.  */
       if (! NILP (tail))
        {
@@ -866,15 +984,23 @@ adjust_intervals_for_insertion (tree, position, length)
       /* Even if we are positioned between intervals, we default
         to the left one if it exists.  We extend it now and split
         off a part later, if stickiness demands it.  */
       /* Even if we are positioned between intervals, we default
         to the left one if it exists.  We extend it now and split
         off a part later, if stickiness demands it.  */
-      for (temp = prev ? prev : i;! NULL_INTERVAL_P (temp); temp = temp->parent)
+      for (temp = prev ? prev : i; temp; temp = INTERVAL_PARENT_OR_NULL (temp))
        {
          temp->total_length += length;
          temp = balance_possible_root_interval (temp);
        }
       
       /* If at least one interval has sticky properties,
        {
          temp->total_length += length;
          temp = balance_possible_root_interval (temp);
        }
       
       /* If at least one interval has sticky properties,
-        we check the stickiness property by property.  */
-      if (END_NONSTICKY_P (prev) || FRONT_STICKY_P (i))
+        we check the stickiness property by property.
+
+        Originally, the if condition here was this:
+               (END_NONSTICKY_P (prev) || FRONT_STICKY_P (i))
+        But, these macros are now unreliable because of introduction
+        of Vtext_property_default_nonsticky.  So, we always have to
+        check stickiness of properties one by one.  If cache of
+        stickiness is implemented in the future, we may be able to
+        use those macros again.  */
+      if (1)
        {
          Lisp_Object pleft, pright;
          struct interval newi;
        {
          Lisp_Object pleft, pright;
          struct interval newi;
@@ -883,7 +1009,7 @@ adjust_intervals_for_insertion (tree, position, length)
          pright = NULL_INTERVAL_P (i) ? Qnil : i->plist;
          newi.plist = merge_properties_sticky (pleft, pright);
 
          pright = NULL_INTERVAL_P (i) ? Qnil : i->plist;
          newi.plist = merge_properties_sticky (pleft, pright);
 
-         if(! prev) /* i.e. position == BEG */
+         if (! prev) /* i.e. position == BEG */
            {
              if (! intervals_equal (i, &newi))
                {
            {
              if (! intervals_equal (i, &newi))
                {
@@ -914,7 +1040,7 @@ adjust_intervals_for_insertion (tree, position, length)
   /* Otherwise just extend the interval.  */
   else
     {
   /* Otherwise just extend the interval.  */
   else
     {
-      for (temp = i; ! NULL_INTERVAL_P (temp); temp = temp->parent)
+      for (temp = i; temp; temp = INTERVAL_PARENT_OR_NULL (temp))
        {
          temp->total_length += length;
          temp = balance_possible_root_interval (temp);
        {
          temp->total_length += length;
          temp = balance_possible_root_interval (temp);
@@ -982,8 +1108,10 @@ merge_properties_sticky (pleft, pright)
   rrear  = textget (pright, Qrear_nonsticky);
 
   /* Go through each element of PRIGHT.  */
   rrear  = textget (pright, Qrear_nonsticky);
 
   /* Go through each element of PRIGHT.  */
-  for (tail1 = pright; ! NILP (tail1); tail1 = Fcdr (Fcdr (tail1)))
+  for (tail1 = pright; CONSP (tail1); tail1 = Fcdr (Fcdr (tail1)))
     {
     {
+      Lisp_Object tmp;
+
       sym = Fcar (tail1);
 
       /* Sticky properties get special treatment.  */
       sym = Fcar (tail1);
 
       /* Sticky properties get special treatment.  */
@@ -991,7 +1119,7 @@ merge_properties_sticky (pleft, pright)
        continue;
 
       rval = Fcar (Fcdr (tail1));
        continue;
 
       rval = Fcar (Fcdr (tail1));
-      for (tail2 = pleft; ! NILP (tail2); tail2 = Fcdr (Fcdr (tail2)))
+      for (tail2 = pleft; CONSP (tail2); tail2 = Fcdr (Fcdr (tail2)))
        if (EQ (sym, Fcar (tail2)))
          break;
 
        if (EQ (sym, Fcar (tail2)))
          break;
 
@@ -1001,8 +1129,15 @@ merge_properties_sticky (pleft, pright)
       lpresent = ! NILP (tail2);
       lval = (NILP (tail2) ? Qnil : Fcar (Fcdr (tail2)));
 
       lpresent = ! NILP (tail2);
       lval = (NILP (tail2) ? Qnil : Fcar (Fcdr (tail2)));
 
-      use_left = ! TMEM (sym, lrear) && lpresent;
-      use_right = TMEM (sym, rfront);
+      /* Even if lrear or rfront say nothing about the stickiness of
+        SYM, Vtext_property_default_nonsticky may give default
+        stickiness to SYM.  */
+      tmp = Fassq (sym, Vtext_property_default_nonsticky);
+      use_left = (lpresent
+                 && ! (TMEM (sym, lrear)
+                       || (CONSP (tmp) && ! NILP (XCDR (tmp)))));
+      use_right = (TMEM (sym, rfront)
+                  || (CONSP (tmp) && NILP (XCDR (tmp))));
       if (use_left && use_right)
        {
          if (NILP (lval))
       if (use_left && use_right)
        {
          if (NILP (lval))
@@ -1031,8 +1166,10 @@ merge_properties_sticky (pleft, pright)
     }
 
   /* Now go through each element of PLEFT.  */
     }
 
   /* Now go through each element of PLEFT.  */
-  for (tail2 = pleft; ! NILP (tail2); tail2 = Fcdr (Fcdr (tail2)))
+  for (tail2 = pleft; CONSP (tail2); tail2 = Fcdr (Fcdr (tail2)))
     {
     {
+      Lisp_Object tmp;
+
       sym = Fcar (tail2);
 
       /* Sticky properties get special treatment.  */
       sym = Fcar (tail2);
 
       /* Sticky properties get special treatment.  */
@@ -1040,7 +1177,7 @@ merge_properties_sticky (pleft, pright)
        continue;
 
       /* If sym is in PRIGHT, we've already considered it.  */
        continue;
 
       /* If sym is in PRIGHT, we've already considered it.  */
-      for (tail1 = pright; ! NILP (tail1); tail1 = Fcdr (Fcdr (tail1)))
+      for (tail1 = pright; CONSP (tail1); tail1 = Fcdr (Fcdr (tail1)))
        if (EQ (sym, Fcar (tail1)))
          break;
       if (! NILP (tail1))
        if (EQ (sym, Fcar (tail1)))
          break;
       if (! NILP (tail1))
@@ -1048,14 +1185,19 @@ merge_properties_sticky (pleft, pright)
 
       lval = Fcar (Fcdr (tail2));
 
 
       lval = Fcar (Fcdr (tail2));
 
+      /* Even if lrear or rfront say nothing about the stickiness of
+        SYM, Vtext_property_default_nonsticky may give default
+        stickiness to SYM.  */
+      tmp = Fassq (sym, Vtext_property_default_nonsticky);
+
       /* Since rval is known to be nil in this loop, the test simplifies.  */
       /* Since rval is known to be nil in this loop, the test simplifies.  */
-      if (! TMEM (sym, lrear))
+      if (! (TMEM (sym, lrear) || (CONSP (tmp) && ! NILP (XCDR (tmp)))))
        {
          props = Fcons (lval, Fcons (sym, props));
          if (TMEM (sym, lfront))
            front = Fcons (sym, front);
        }
        {
          props = Fcons (lval, Fcons (sym, props));
          if (TMEM (sym, lfront))
            front = Fcons (sym, front);
        }
-      else if (TMEM (sym, rfront))
+      else if (TMEM (sym, rfront) || (CONSP (tmp) && NILP (XCDR (tmp))))
        {
          /* The value is nil, but we still inherit the stickiness
             from the right.  */
        {
          /* The value is nil, but we still inherit the stickiness
             from the right.  */
@@ -1106,7 +1248,7 @@ delete_node (i)
       this->total_length += migrate_amt;
     }
   this->left = migrate;
       this->total_length += migrate_amt;
     }
   this->left = migrate;
-  migrate->parent = this;
+  SET_INTERVAL_PARENT (migrate, this);
 
   return i->right;
 }
 
   return i->right;
 }
@@ -1130,10 +1272,10 @@ delete_interval (i)
   if (ROOT_INTERVAL_P (i))
     {
       Lisp_Object owner;
   if (ROOT_INTERVAL_P (i))
     {
       Lisp_Object owner;
-      owner = (Lisp_Object) i->parent;
+      GET_INTERVAL_OBJECT (owner, i);
       parent = delete_node (i);
       if (! NULL_INTERVAL_P (parent))
       parent = delete_node (i);
       if (! NULL_INTERVAL_P (parent))
-       parent->parent = (INTERVAL) owner;
+       SET_INTERVAL_OBJECT (parent, owner);
 
       if (BUFFERP (owner))
        BUF_INTERVALS (XBUFFER (owner)) = parent;
 
       if (BUFFERP (owner))
        BUF_INTERVALS (XBUFFER (owner)) = parent;
@@ -1145,18 +1287,18 @@ delete_interval (i)
       return;
     }
 
       return;
     }
 
-  parent = i->parent;
+  parent = INTERVAL_PARENT (i);
   if (AM_LEFT_CHILD (i))
     {
       parent->left = delete_node (i);
       if (! NULL_INTERVAL_P (parent->left))
   if (AM_LEFT_CHILD (i))
     {
       parent->left = delete_node (i);
       if (! NULL_INTERVAL_P (parent->left))
-       parent->left->parent = parent;
+       SET_INTERVAL_PARENT (parent->left, parent);
     }
   else
     {
       parent->right = delete_node (i);
       if (! NULL_INTERVAL_P (parent->right))
     }
   else
     {
       parent->right = delete_node (i);
       if (! NULL_INTERVAL_P (parent->right))
-       parent->right->parent = parent;
+       SET_INTERVAL_PARENT (parent->right, parent);
     }
 }
 \f
     }
 }
 \f
@@ -1238,13 +1380,17 @@ adjust_intervals_for_deletion (buffer, start, length)
 {
   register int left_to_delete = length;
   register INTERVAL tree = BUF_INTERVALS (buffer);
 {
   register int left_to_delete = length;
   register INTERVAL tree = BUF_INTERVALS (buffer);
-  register int deleted;
+  Lisp_Object parent;
+  int offset;
+
+  GET_INTERVAL_OBJECT (parent, tree);
+  offset = (BUFFERP (parent) ? BUF_BEG (XBUFFER (parent)) : 0);
 
   if (NULL_INTERVAL_P (tree))
     return;
 
 
   if (NULL_INTERVAL_P (tree))
     return;
 
-  if (start > BEG + TOTAL_LENGTH (tree)
-      || start + length > BEG + TOTAL_LENGTH (tree))
+  if (start > offset + TOTAL_LENGTH (tree)
+      || start + length > offset + TOTAL_LENGTH (tree))
     abort ();
 
   if (length == TOTAL_LENGTH (tree))
     abort ();
 
   if (length == TOTAL_LENGTH (tree))
@@ -1259,11 +1405,11 @@ adjust_intervals_for_deletion (buffer, start, length)
       return;
     }
 
       return;
     }
 
-  if (start > BEG + TOTAL_LENGTH (tree))
-    start = BEG + TOTAL_LENGTH (tree);
+  if (start > offset + TOTAL_LENGTH (tree))
+    start = offset + TOTAL_LENGTH (tree);
   while (left_to_delete > 0)
     {
   while (left_to_delete > 0)
     {
-      left_to_delete -= interval_deletion_adjustment (tree, start - 1,
+      left_to_delete -= interval_deletion_adjustment (tree, start - offset,
                                                      left_to_delete);
       tree = BUF_INTERVALS (buffer);
       if (left_to_delete == tree->total_length)
                                                      left_to_delete);
       tree = BUF_INTERVALS (buffer);
       if (left_to_delete == tree->total_length)
@@ -1334,12 +1480,12 @@ merge_interval_right (i)
     {
       if (AM_LEFT_CHILD (successor))
        {
     {
       if (AM_LEFT_CHILD (successor))
        {
-         successor = successor->parent;
+         successor = INTERVAL_PARENT (successor);
          delete_interval (i);
          return successor;
        }
 
          delete_interval (i);
          return successor;
        }
 
-      successor = successor->parent;
+      successor = INTERVAL_PARENT (successor);
       successor->total_length -= absorb;
     }
 
       successor->total_length -= absorb;
     }
 
@@ -1387,12 +1533,12 @@ merge_interval_left (i)
     {
       if (AM_RIGHT_CHILD (predecessor))
        {
     {
       if (AM_RIGHT_CHILD (predecessor))
        {
-         predecessor = predecessor->parent;
+         predecessor = INTERVAL_PARENT (predecessor);
          delete_interval (i);
          return predecessor;
        }
 
          delete_interval (i);
          return predecessor;
        }
 
-      predecessor = predecessor->parent;
+      predecessor = INTERVAL_PARENT (predecessor);
       predecessor->total_length -= absorb;
     }
 
       predecessor->total_length -= absorb;
     }
 
@@ -1414,7 +1560,25 @@ reproduce_tree (source, parent)
 
   bcopy (source, t, INTERVAL_SIZE);
   copy_properties (source, t);
 
   bcopy (source, t, INTERVAL_SIZE);
   copy_properties (source, t);
-  t->parent = parent;
+  SET_INTERVAL_PARENT (t, parent);
+  if (! NULL_LEFT_CHILD (source))
+    t->left = reproduce_tree (source->left, t);
+  if (! NULL_RIGHT_CHILD (source))
+    t->right = reproduce_tree (source->right, t);
+
+  return t;
+}
+
+static INTERVAL
+reproduce_tree_obj (source, parent)
+     INTERVAL source;
+     Lisp_Object parent;
+{
+  register INTERVAL t = make_interval ();
+
+  bcopy (source, t, INTERVAL_SIZE);
+  copy_properties (source, t);
+  SET_INTERVAL_OBJECT (t, parent);
   if (! NULL_LEFT_CHILD (source))
     t->left = reproduce_tree (source->left, t);
   if (! NULL_RIGHT_CHILD (source))
   if (! NULL_LEFT_CHILD (source))
     t->left = reproduce_tree (source->left, t);
   if (! NULL_RIGHT_CHILD (source))
@@ -1471,6 +1635,11 @@ make_new_interval (intervals, start, length)
 /* Insert the intervals of SOURCE into BUFFER at POSITION.
    LENGTH is the length of the text in SOURCE.
 
 /* Insert the intervals of SOURCE into BUFFER at POSITION.
    LENGTH is the length of the text in SOURCE.
 
+   The `position' field of the SOURCE intervals is assumed to be
+   consistent with its parent; therefore, SOURCE must be an
+   interval tree made with copy_interval or must be the whole
+   tree of a buffer or a string.
+
    This is used in insdel.c when inserting Lisp_Strings into the
    buffer.  The text corresponding to SOURCE is already in the buffer
    when this is called.  The intervals of new tree are a copy of those
    This is used in insdel.c when inserting Lisp_Strings into the
    buffer.  The text corresponding to SOURCE is already in the buffer
    when this is called.  The intervals of new tree are a copy of those
@@ -1511,21 +1680,22 @@ graft_intervals_into_buffer (source, position, length, buffer, inherit)
 {
   register INTERVAL under, over, this, prev;
   register INTERVAL tree;
 {
   register INTERVAL under, over, this, prev;
   register INTERVAL tree;
-  int middle;
 
   tree = BUF_INTERVALS (buffer);
 
 
   tree = BUF_INTERVALS (buffer);
 
-  /* If the new text has no properties, it becomes part of whatever
-     interval it was inserted into.  */
+  /* If the new text has no properties, then with inheritance it
+     becomes part of whatever interval it was inserted into.
+     To prevent inheritance, we must clear out the properties
+     of the newly inserted text.  */
   if (NULL_INTERVAL_P (source))
     {
       Lisp_Object buf;
   if (NULL_INTERVAL_P (source))
     {
       Lisp_Object buf;
-      if (!inherit && ! NULL_INTERVAL_P (tree))
+      if (!inherit && !NULL_INTERVAL_P (tree) && length > 0)
        {
          XSETBUFFER (buf, buffer);
        {
          XSETBUFFER (buf, buffer);
-         Fset_text_properties (make_number (position),
-                               make_number (position + length),
-                               Qnil, buf);
+         set_text_properties_1 (make_number (position),
+                                make_number (position + length),
+                                Qnil, buf, 0);
        }
       if (! NULL_INTERVAL_P (BUF_INTERVALS (buffer)))
        BUF_INTERVALS (buffer) = balance_an_interval (BUF_INTERVALS (buffer));
        }
       if (! NULL_INTERVAL_P (BUF_INTERVALS (buffer)))
        BUF_INTERVALS (buffer) = balance_an_interval (BUF_INTERVALS (buffer));
@@ -1540,8 +1710,10 @@ graft_intervals_into_buffer (source, position, length, buffer, inherit)
        {
          Lisp_Object buf;
          XSETBUFFER (buf, buffer);
        {
          Lisp_Object buf;
          XSETBUFFER (buf, buffer);
-         BUF_INTERVALS (buffer) = reproduce_tree (source, buf);
-         /* Explicitly free the old tree here.  */
+         BUF_INTERVALS (buffer) = reproduce_tree_obj (source, buf);
+         BUF_INTERVALS (buffer)->position = 1;
+
+         /* Explicitly free the old tree here?  */
 
          return;
        }
 
          return;
        }
@@ -1560,7 +1732,8 @@ graft_intervals_into_buffer (source, position, length, buffer, inherit)
        some zero length intervals.  Eventually, do something clever
        about inserting properly.  For now, just waste the old intervals.  */
     {
        some zero length intervals.  Eventually, do something clever
        about inserting properly.  For now, just waste the old intervals.  */
     {
-      BUF_INTERVALS (buffer) = reproduce_tree (source, tree->parent);
+      BUF_INTERVALS (buffer) = reproduce_tree (source, INTERVAL_PARENT (tree));
+      BUF_INTERVALS (buffer)->position = 1;
       /* Explicitly free the old tree here.  */
 
       return;
       /* Explicitly free the old tree here.  */
 
       return;
@@ -1573,7 +1746,7 @@ graft_intervals_into_buffer (source, position, length, buffer, inherit)
   this = under = find_interval (tree, position);
   if (NULL_INTERVAL_P (under)) /* Paranoia */
     abort ();
   this = under = find_interval (tree, position);
   if (NULL_INTERVAL_P (under)) /* Paranoia */
     abort ();
-  over = find_interval (source, 1);
+  over = find_interval (source, interval_start_pos (source));
 
   /* Here for insertion in the middle of an interval.
      Split off an equivalent interval to the right,
 
   /* Here for insertion in the middle of an interval.
      Split off an equivalent interval to the right,
@@ -1585,14 +1758,19 @@ graft_intervals_into_buffer (source, position, length, buffer, inherit)
        = split_interval_left (this, position - under->position);
       copy_properties (under, end_unchanged);
       under->position = position;
        = split_interval_left (this, position - under->position);
       copy_properties (under, end_unchanged);
       under->position = position;
-      prev = 0;
-      middle = 1;
     }
   else
     {
     }
   else
     {
+      /* This call may have some effect because previous_interval may
+         update `position' fields of intervals.  Thus, don't ignore it
+         for the moment.  Someone please tell me the truth (K.Handa).  */
       prev = previous_interval (under);
       prev = previous_interval (under);
+#if 0
+      /* But, this code surely has no effect.  And, anyway,
+         END_NONSTICKY_P is unreliable now.  */
       if (prev && !END_NONSTICKY_P (prev))
        prev = 0;
       if (prev && !END_NONSTICKY_P (prev))
        prev = 0;
+#endif /* 0 */
     }
 
   /* Insertion is now at beginning of UNDER.  */
     }
 
   /* Insertion is now at beginning of UNDER.  */
@@ -1660,31 +1838,81 @@ textget (plist, prop)
 }
 
 \f
 }
 
 \f
-/* Set point in BUFFER to POSITION.  If the target position is 
+/* Set point "temporarily", without checking any text properties.  */
+
+INLINE void
+temp_set_point (buffer, charpos)
+     struct buffer *buffer;
+     int charpos;
+{
+  temp_set_point_both (buffer, charpos,
+                      buf_charpos_to_bytepos (buffer, charpos));
+}
+
+/* Set point in BUFFER "temporarily" to CHARPOS, which corresponds to
+   byte position BYTEPOS.  */
+
+INLINE void
+temp_set_point_both (buffer, charpos, bytepos)
+     int charpos, bytepos;
+     struct buffer *buffer;
+{
+  /* In a single-byte buffer, the two positions must be equal.  */
+  if (BUF_ZV (buffer) == BUF_ZV_BYTE (buffer)
+      && charpos != bytepos)
+    abort ();
+
+  if (charpos > bytepos)
+    abort ();
+
+  if (charpos > BUF_ZV (buffer) || charpos < BUF_BEGV (buffer))
+    abort ();
+
+  BUF_PT_BYTE (buffer) = bytepos;
+  BUF_PT (buffer) = charpos;
+}
+
+/* Set point in BUFFER to CHARPOS.  If the target position is 
    before an intangible character, move to an ok place.  */
 
 void
    before an intangible character, move to an ok place.  */
 
 void
-set_point (position, buffer)
-     register int position;
+set_point (buffer, charpos)
+     register struct buffer *buffer;
+     register int charpos;
+{
+  set_point_both (buffer, charpos, buf_charpos_to_bytepos (buffer, charpos));
+}
+
+/* Set point in BUFFER to CHARPOS, which corresponds to byte
+   position BYTEPOS.  If the target position is 
+   before an intangible character, move to an ok place.  */
+
+void
+set_point_both (buffer, charpos, bytepos)
      register struct buffer *buffer;
      register struct buffer *buffer;
+     register int charpos, bytepos;
 {
 {
-  register INTERVAL to, from, toprev, fromprev, target;
+  register INTERVAL to, from, toprev, fromprev;
   int buffer_point;
   int buffer_point;
-  register Lisp_Object obj;
   int old_position = BUF_PT (buffer);
   int old_position = BUF_PT (buffer);
-  int backwards = (position < old_position ? 1 : 0);
+  int backwards = (charpos < old_position ? 1 : 0);
   int have_overlays;
   int original_position;
 
   buffer->point_before_scroll = Qnil;
 
   int have_overlays;
   int original_position;
 
   buffer->point_before_scroll = Qnil;
 
-  if (position == BUF_PT (buffer))
+  if (charpos == BUF_PT (buffer))
     return;
 
     return;
 
+  /* In a single-byte buffer, the two positions must be equal.  */
+  if (BUF_ZV (buffer) == BUF_ZV_BYTE (buffer)
+      && charpos != bytepos)
+    abort ();
+
   /* Check this now, before checking if the buffer has any intervals.
      That way, we can catch conditions which break this sanity check
      whether or not there are intervals in the buffer.  */
   /* Check this now, before checking if the buffer has any intervals.
      That way, we can catch conditions which break this sanity check
      whether or not there are intervals in the buffer.  */
-  if (position > BUF_ZV (buffer) || position < BUF_BEGV (buffer))
+  if (charpos > BUF_ZV (buffer) || charpos < BUF_BEGV (buffer))
     abort ();
 
   have_overlays = (! NILP (buffer->overlays_before)
     abort ();
 
   have_overlays = (! NILP (buffer->overlays_before)
@@ -1694,17 +1922,17 @@ set_point (position, buffer)
      then we can do it quickly.  */
   if (NULL_INTERVAL_P (BUF_INTERVALS (buffer)) && ! have_overlays)
     {
      then we can do it quickly.  */
   if (NULL_INTERVAL_P (BUF_INTERVALS (buffer)) && ! have_overlays)
     {
-      BUF_PT (buffer) = position;
+      temp_set_point_both (buffer, charpos, bytepos);
       return;
     }
 
       return;
     }
 
-  /* Set TO to the interval containing the char after POSITION,
-     and TOPREV to the interval containing the char before POSITION.
+  /* Set TO to the interval containing the char after CHARPOS,
+     and TOPREV to the interval containing the char before CHARPOS.
      Either one may be null.  They may be equal.  */
      Either one may be null.  They may be equal.  */
-  to = find_interval (BUF_INTERVALS (buffer), position);
-  if (position == BUF_BEGV (buffer))
+  to = find_interval (BUF_INTERVALS (buffer), charpos);
+  if (charpos == BUF_BEGV (buffer))
     toprev = 0;
     toprev = 0;
-  else if (to && to->position == position)
+  else if (to && to->position == charpos)
     toprev = previous_interval (to);
   else
     toprev = to;
     toprev = previous_interval (to);
   else
     toprev = to;
@@ -1731,11 +1959,11 @@ set_point (position, buffer)
   if (to == from && toprev == fromprev && INTERVAL_VISIBLE_P (to)
       && ! have_overlays)
     {
   if (to == from && toprev == fromprev && INTERVAL_VISIBLE_P (to)
       && ! have_overlays)
     {
-      BUF_PT (buffer) = position;
+      temp_set_point_both (buffer, charpos, bytepos);
       return;
     }
 
       return;
     }
 
-  original_position = position;
+  original_position = charpos;
 
   /* If the new position is between two intangible characters
      with the same intangible property value,
 
   /* If the new position is between two intangible characters
      with the same intangible property value,
@@ -1745,54 +1973,86 @@ set_point (position, buffer)
          || have_overlays)
       /* Intangibility never stops us from positioning at the beginning
         or end of the buffer, so don't bother checking in that case.  */
          || have_overlays)
       /* Intangibility never stops us from positioning at the beginning
         or end of the buffer, so don't bother checking in that case.  */
-      && position != BEGV && position != ZV)
+      && charpos != BEGV && charpos != ZV)
     {
     {
-      Lisp_Object intangible_propval;
+      Lisp_Object intangible_propval, invisible_propval;
       Lisp_Object pos;
       Lisp_Object pos;
+      int invis_p;
 
 
-      XSETINT (pos, position);
+      XSETINT (pos, charpos);
 
       if (backwards)
        {
 
       if (backwards)
        {
-         intangible_propval = Fget_char_property (make_number (position),
-                                                  Qintangible, Qnil);
+         /* If the preceding char is both invisible and intangible,
+            start backing up from just before that one.  */
+
+         intangible_propval
+           = Fget_char_property (make_number (charpos - 1),
+                                 Qintangible, Qnil);
+         invisible_propval
+           = Fget_char_property (make_number (charpos - 1), Qinvisible, Qnil);
+         invis_p = TEXT_PROP_MEANS_INVISIBLE (invisible_propval);
+
+         if (! NILP (intangible_propval) && invis_p)
+           XSETINT (pos, --charpos);
 
          /* If following char is intangible,
             skip back over all chars with matching intangible property.  */
 
          /* If following char is intangible,
             skip back over all chars with matching intangible property.  */
+
+         intangible_propval = Fget_char_property (pos, Qintangible, Qnil);
+
          if (! NILP (intangible_propval))
          if (! NILP (intangible_propval))
-           while (XINT (pos) > BUF_BEGV (buffer)
-                  && EQ (Fget_char_property (make_number (XINT (pos) - 1),
-                                             Qintangible, Qnil),
-                         intangible_propval))
-             pos = Fprevious_char_property_change (pos, Qnil);
+           {
+             while (XINT (pos) > BUF_BEGV (buffer)
+                    && EQ (Fget_char_property (make_number (XINT (pos) - 1),
+                                               Qintangible, Qnil),
+                           intangible_propval))
+               pos = Fprevious_char_property_change (pos, Qnil);
+           }
        }
       else
        {
        }
       else
        {
-         intangible_propval = Fget_char_property (make_number (position - 1),
+         /* If preceding char is intangible,
+            skip forward over all chars with matching intangible property.  */
+
+         intangible_propval = Fget_char_property (make_number (charpos - 1),
                                                   Qintangible, Qnil);
 
                                                   Qintangible, Qnil);
 
-         /* If following char is intangible,
-            skip back over all chars with matching intangible property.  */
          if (! NILP (intangible_propval))
          if (! NILP (intangible_propval))
-           while (XINT (pos) < BUF_ZV (buffer)
-                  && EQ (Fget_char_property (pos, Qintangible, Qnil),
-                         intangible_propval))
-             pos = Fnext_char_property_change (pos, Qnil);
+           {
+             while (XINT (pos) < BUF_ZV (buffer)
+                    && EQ (Fget_char_property (pos, Qintangible, Qnil),
+                           intangible_propval))
+               pos = Fnext_char_property_change (pos, Qnil);
+
+             /* Is the last one invisible as well as intangible?  */
+
+             invisible_propval
+               = Fget_char_property (make_number (XINT (pos) - 1),
+                                     Qinvisible, Qnil);
+             invis_p = TEXT_PROP_MEANS_INVISIBLE (invisible_propval);
+
+             /* If so, advance one character more:
+                don't stop after an invisible, intangible character.  */
 
 
+             if (invis_p && XINT (pos) < BUF_ZV (buffer))
+               XSETINT (pos, XINT (pos) + 1);
+           }
        }
 
        }
 
-      position = XINT (pos);
+      charpos = XINT (pos);
+      bytepos = buf_charpos_to_bytepos (buffer, charpos);
     }
 
     }
 
-  if (position != original_position)
+  if (charpos != original_position)
     {
     {
-      /* Set TO to the interval containing the char after POSITION,
-        and TOPREV to the interval containing the char before POSITION.
+      /* Set TO to the interval containing the char after CHARPOS,
+        and TOPREV to the interval containing the char before CHARPOS.
         Either one may be null.  They may be equal.  */
         Either one may be null.  They may be equal.  */
-      to = find_interval (BUF_INTERVALS (buffer), position);
-      if (position == BUF_BEGV (buffer))
+      to = find_interval (BUF_INTERVALS (buffer), charpos);
+      if (charpos == BUF_BEGV (buffer))
        toprev = 0;
        toprev = 0;
-      else if (to && to->position == position)
+      else if (to && to->position == charpos)
        toprev = previous_interval (to);
       else
        toprev = to;
        toprev = previous_interval (to);
       else
        toprev = to;
@@ -1802,7 +2062,7 @@ set_point (position, buffer)
      and TOPREV is the interval before the stopping point.
      One or the other may be null.  */
 
      and TOPREV is the interval before the stopping point.
      One or the other may be null.  */
 
-  BUF_PT (buffer) = position;
+  temp_set_point_both (buffer, charpos, bytepos);
 
   /* We run point-left and point-entered hooks here, iff the
      two intervals are not equivalent.  These hooks take
 
   /* We run point-left and point-entered hooks here, iff the
      two intervals are not equivalent.  These hooks take
@@ -1832,26 +2092,20 @@ set_point (position, buffer)
        enter_before = Qnil;
 
       if (! EQ (leave_before, enter_before) && !NILP (leave_before))
        enter_before = Qnil;
 
       if (! EQ (leave_before, enter_before) && !NILP (leave_before))
-       call2 (leave_before, old_position, position);
+       call2 (leave_before, make_number (old_position),
+              make_number (charpos));
       if (! EQ (leave_after, enter_after) && !NILP (leave_after))
       if (! EQ (leave_after, enter_after) && !NILP (leave_after))
-       call2 (leave_after, old_position, position);
+       call2 (leave_after, make_number (old_position),
+              make_number (charpos));
 
       if (! EQ (enter_before, leave_before) && !NILP (enter_before))
 
       if (! EQ (enter_before, leave_before) && !NILP (enter_before))
-       call2 (enter_before, old_position, position);
+       call2 (enter_before, make_number (old_position),
+              make_number (charpos));
       if (! EQ (enter_after, leave_after) && !NILP (enter_after))
       if (! EQ (enter_after, leave_after) && !NILP (enter_after))
-       call2 (enter_after, old_position, position);
+       call2 (enter_after, make_number (old_position),
+              make_number (charpos));
     }
 }
     }
 }
-
-/* Set point temporarily, without checking any text properties.  */
-
-INLINE void
-temp_set_point (position, buffer)
-     int position;
-     struct buffer *buffer;
-{
-  BUF_PT (buffer) = position;
-}
 \f
 /* Move point to POSITION, unless POSITION is inside an intangible
    segment that reaches all the way to point.  */
 \f
 /* Move point to POSITION, unless POSITION is inside an intangible
    segment that reaches all the way to point.  */
@@ -1868,7 +2122,7 @@ move_if_not_intangible (position)
   if (! NILP (Vinhibit_point_motion_hooks))
     /* If intangible is inhibited, always move point to POSITION.  */
     ;
   if (! NILP (Vinhibit_point_motion_hooks))
     /* If intangible is inhibited, always move point to POSITION.  */
     ;
-  else if (PT < position && pos < ZV)
+  else if (PT < position && XINT (pos) < ZV)
     {
       /* We want to move forward, so check the text before POSITION.  */
 
     {
       /* We want to move forward, so check the text before POSITION.  */
 
@@ -1884,7 +2138,7 @@ move_if_not_intangible (position)
                      intangible_propval))
          pos = Fprevious_char_property_change (pos, Qnil);
     }
                      intangible_propval))
          pos = Fprevious_char_property_change (pos, Qnil);
     }
-  else if (pos > BEGV)
+  else if (XINT (pos) > BEGV)
     {
       /* We want to move backward, so check the text after POSITION.  */
 
     {
       /* We want to move backward, so check the text after POSITION.  */
 
@@ -1892,7 +2146,7 @@ move_if_not_intangible (position)
                                               Qintangible, Qnil);
 
       /* If following char is intangible,
                                               Qintangible, Qnil);
 
       /* If following char is intangible,
-        skip back over all chars with matching intangible property.  */
+        skip forward over all chars with matching intangible property.  */
       if (! NILP (intangible_propval))
        while (XINT (pos) < ZV
               && EQ (Fget_char_property (pos, Qintangible, Qnil),
       if (! NILP (intangible_propval))
        while (XINT (pos) < ZV
               && EQ (Fget_char_property (pos, Qintangible, Qnil),
@@ -1909,17 +2163,66 @@ move_if_not_intangible (position)
     SET_PT (position);
 }
 \f
     SET_PT (position);
 }
 \f
-/* Return the proper local map for position POSITION in BUFFER.
-   Use the map specified by the local-map property, if any.
-   Otherwise, use BUFFER's local map.  */
+/* If text at position POS has property PROP, set *VAL to the property
+   value, *START and *END to the beginning and end of a region that
+   has the same property, and return 1.  Otherwise return 0.
+
+   OBJECT is the string or buffer to look for the property in;
+   nil means the current buffer. */
+
+int
+get_property_and_range (pos, prop, val, start, end, object)
+     int pos;
+     Lisp_Object prop, *val;
+     int *start, *end;
+     Lisp_Object object;
+{
+  INTERVAL i, prev, next;
+
+  if (NILP (object))
+    i = find_interval (BUF_INTERVALS (current_buffer), pos);
+  else if (BUFFERP (object))
+    i = find_interval (BUF_INTERVALS (XBUFFER (object)), pos);
+  else if (STRINGP (object))
+    i = find_interval (XSTRING (object)->intervals, pos);
+  else
+    abort ();
+
+  if (NULL_INTERVAL_P (i) || (i->position + LENGTH (i) <= pos))
+    return 0;
+  *val = textget (i->plist, prop);
+  if (NILP (*val))
+    return 0;
+
+  next = i;                    /* remember it in advance */
+  prev = previous_interval (i);
+  while (! NULL_INTERVAL_P (prev)
+        && EQ (*val, textget (prev->plist, prop)))
+    i = prev, prev = previous_interval (prev);
+  *start = i->position;
+
+  next = next_interval (i);
+  while (! NULL_INTERVAL_P (next) 
+        && EQ (*val, textget (next->plist, prop)))
+    i = next, next = next_interval (next);
+  *end = i->position + LENGTH (i);
+
+  return 1;
+}
+\f
+/* Return the proper local keymap TYPE for position POSITION in
+   BUFFER; TYPE should be one of `keymap' or `local-map'.  Use the map
+   specified by the PROP property, if any.  Otherwise, if TYPE is
+   `local-map' use BUFFER's local map.  */
 
 Lisp_Object
 
 Lisp_Object
-get_local_map (position, buffer)
+get_local_map (position, buffer, type)
      register int position;
      register struct buffer *buffer;
      register int position;
      register struct buffer *buffer;
+     Lisp_Object type;
 {
 {
-  Lisp_Object prop, tem, lispy_position, lispy_buffer;
-  int old_begv, old_zv;
+  Lisp_Object prop, lispy_position, lispy_buffer;
+  int old_begv, old_zv, old_begv_byte, old_zv_byte;
 
   /* Perhaps we should just change `position' to the limit.  */
   if (position > BUF_Z (buffer) || position < BUF_BEG (buffer))
 
   /* Perhaps we should just change `position' to the limit.  */
   if (position > BUF_Z (buffer) || position < BUF_BEG (buffer))
@@ -1929,8 +2232,12 @@ get_local_map (position, buffer)
      the visible region contains no characters and hence no properties.  */
   old_begv = BUF_BEGV (buffer);
   old_zv = BUF_ZV (buffer);
      the visible region contains no characters and hence no properties.  */
   old_begv = BUF_BEGV (buffer);
   old_zv = BUF_ZV (buffer);
+  old_begv_byte = BUF_BEGV_BYTE (buffer);
+  old_zv_byte = BUF_ZV_BYTE (buffer);
   BUF_BEGV (buffer) = BUF_BEG (buffer);
   BUF_ZV (buffer) = BUF_Z (buffer);
   BUF_BEGV (buffer) = BUF_BEG (buffer);
   BUF_ZV (buffer) = BUF_Z (buffer);
+  BUF_BEGV_BYTE (buffer) = BUF_BEG_BYTE (buffer);
+  BUF_ZV_BYTE (buffer) = BUF_Z_BYTE (buffer);
 
   /* There are no properties at the end of the buffer, so in that case
      check for a local map on the last character of the buffer instead.  */
 
   /* There are no properties at the end of the buffer, so in that case
      check for a local map on the last character of the buffer instead.  */
@@ -1938,24 +2245,27 @@ get_local_map (position, buffer)
     --position;
   XSETFASTINT (lispy_position, position);
   XSETBUFFER (lispy_buffer, buffer);
     --position;
   XSETFASTINT (lispy_position, position);
   XSETBUFFER (lispy_buffer, buffer);
-  prop = Fget_char_property (lispy_position, Qlocal_map, lispy_buffer);
+  prop = Fget_char_property (lispy_position, type, lispy_buffer);
 
   BUF_BEGV (buffer) = old_begv;
   BUF_ZV (buffer) = old_zv;
 
   BUF_BEGV (buffer) = old_begv;
   BUF_ZV (buffer) = old_zv;
+  BUF_BEGV_BYTE (buffer) = old_begv_byte;
+  BUF_ZV_BYTE (buffer) = old_zv_byte;
 
   /* Use the local map only if it is valid.  */
 
   /* Use the local map only if it is valid.  */
-  /* Do allow symbols that are defined as keymaps.  */
-  if (SYMBOLP (prop) && !NILP (prop))
-    prop = Findirect_function (prop);
-  if (!NILP (prop)
-      && (tem = Fkeymapp (prop), !NILP (tem)))
+  prop = get_keymap (prop, 0, 0);
+  if (CONSP (prop))
     return prop;
 
     return prop;
 
-  return buffer->keymap;
+  if (EQ (type, Qkeymap))
+    return Qnil;
+  else
+    return buffer->keymap;
 }
 \f
 /* Produce an interval tree reflecting the intervals in
 }
 \f
 /* Produce an interval tree reflecting the intervals in
-   TREE from START to START + LENGTH.  */
+   TREE from START to START + LENGTH.
+   The new interval tree has no parent and has a starting-position of 0.  */
 
 INTERVAL
 copy_intervals (tree, start, length)
 
 INTERVAL
 copy_intervals (tree, start, length)
@@ -1978,7 +2288,7 @@ copy_intervals (tree, start, length)
     return NULL_INTERVAL;
 
   new = make_interval ();
     return NULL_INTERVAL;
 
   new = make_interval ();
-  new->position = 1;
+  new->position = 0;
   got = (LENGTH (i) - (start - i->position));
   new->total_length = length;
   copy_properties (i, new);
   got = (LENGTH (i) - (start - i->position));
   new->total_length = length;
   copy_properties (i, new);
@@ -2010,11 +2320,11 @@ copy_intervals_to_string (string, buffer, position, length)
   if (NULL_INTERVAL_P (interval_copy))
     return;
 
   if (NULL_INTERVAL_P (interval_copy))
     return;
 
-  interval_copy->parent = (INTERVAL) string;
+  SET_INTERVAL_OBJECT (interval_copy, string);
   XSTRING (string)->intervals = interval_copy;
 }
 \f
   XSTRING (string)->intervals = interval_copy;
 }
 \f
-/* Return 1 if string S1 and S2 have identical properties; 0 otherwise.
+/* Return 1 if strings S1 and S2 have identical properties; 0 otherwise.
    Assume they have identical characters.  */
 
 int
    Assume they have identical characters.  */
 
 int
@@ -2022,13 +2332,11 @@ compare_string_intervals (s1, s2)
      Lisp_Object s1, s2;
 {
   INTERVAL i1, i2;
      Lisp_Object s1, s2;
 {
   INTERVAL i1, i2;
-  int pos = 1;
-  int end = XSTRING (s1)->size + 1;
+  int pos = 0;
+  int end = XSTRING (s1)->size;
 
 
-  /* We specify 1 as position because the interval functions
-     always use positions starting at 1.  */
-  i1 = find_interval (XSTRING (s1)->intervals, 1);
-  i2 = find_interval (XSTRING (s2)->intervals, 1);
+  i1 = find_interval (XSTRING (s1)->intervals, 0);
+  i2 = find_interval (XSTRING (s2)->intervals, 0);
 
   while (pos < end)
     {
 
   while (pos < end)
     {
@@ -2052,5 +2360,73 @@ compare_string_intervals (s1, s2)
     }
   return 1;
 }
     }
   return 1;
 }
+\f
+/* Recursively adjust interval I in the current buffer
+   for setting enable_multibyte_characters to MULTI_FLAG.
+   The range of interval I is START ... END in characters,
+   START_BYTE ... END_BYTE in bytes.  */
+
+static void
+set_intervals_multibyte_1 (i, multi_flag, start, start_byte, end, end_byte)
+     INTERVAL i;
+     int multi_flag;
+     int start, start_byte, end, end_byte;
+{
+  /* Fix the length of this interval.  */
+  if (multi_flag)
+    i->total_length = end - start;
+  else
+    i->total_length = end_byte - start_byte;
+
+  /* Recursively fix the length of the subintervals.  */
+  if (i->left)
+    {
+      int left_end, left_end_byte;
+
+      if (multi_flag)
+       {
+         left_end_byte = start_byte + LEFT_TOTAL_LENGTH (i);
+         left_end = BYTE_TO_CHAR (left_end_byte);
+       }
+      else
+       {
+         left_end = start + LEFT_TOTAL_LENGTH (i);
+         left_end_byte = CHAR_TO_BYTE (left_end);
+       }
+
+      set_intervals_multibyte_1 (i->left, multi_flag, start, start_byte,
+                                left_end, left_end_byte);
+    }
+  if (i->right)
+    {
+      int right_start_byte, right_start;
+
+      if (multi_flag)
+       {
+         right_start_byte = end_byte - RIGHT_TOTAL_LENGTH (i);
+         right_start = BYTE_TO_CHAR (right_start_byte);
+       }
+      else
+       {
+         right_start = end - RIGHT_TOTAL_LENGTH (i);
+         right_start_byte = CHAR_TO_BYTE (right_start);
+       }
+
+      set_intervals_multibyte_1 (i->right, multi_flag,
+                                right_start, right_start_byte,
+                                end, end_byte);
+    }
+}
+
+/* Update the intervals of the current buffer
+   to fit the contents as multibyte (if MULTI_FLAG is 1)
+   or to fit them as non-multibyte (if MULTI_FLAG is 0).  */
 
 
-#endif /* USE_TEXT_PROPERTIES */
+void
+set_intervals_multibyte (multi_flag)
+     int multi_flag;
+{
+  if (BUF_INTERVALS (current_buffer))
+    set_intervals_multibyte_1 (BUF_INTERVALS (current_buffer), multi_flag,
+                              BEG, BEG_BYTE, Z, Z_BYTE);
+}
Unnamed repository; edit this file 'description' to name the repository.