(autocmp_chars): Check lookback count.

(composition_compute_stop_pos): Set cmp_it->lookback.
(composition_reseat_it): Check lookback count.
(struct position_record): New struct.
(FORWARD_CHAR, BACKWARD_CHAR, CHAR_COMPOSABLE_P): New macros.
(find_automatic_composition): New function.
(composition_adjust_point): Use find_automatic_composition.

2 files changed, 264 insertions, 104 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 2cb1c7b8cb0..ff10dd9b61e 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,15 @@
+2008-09-05  Kenichi Handa  <handa@m17n.org>
+
+        * composite.c (autocmp_chars): Check lookback count.
+        (composition_compute_stop_pos): Set cmp_it->lookback.
+        (composition_reseat_it): Check lookback count.
+        (struct position_record): New struct.
+        (FORWARD_CHAR, BACKWARD_CHAR, CHAR_COMPOSABLE_P): New macros.
+        (find_automatic_composition): New function.
+        (composition_adjust_point): Use find_automatic_composition.
+
+        * dispextern.h (struct composition_it): New member lookback.
+
 2008-09-02  Chong Yidong  <cyd@stupidchicken.com>
 
         * indent.c (Fvertical_motion): Don't call move_it_by_lines again
diff --git a/src/composite.c b/src/composite.c
index 257ca66632d..6e9c823d8c1 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -402,8 +402,8 @@ get_composition_id (charpos, bytepos, nchars, prop, string)
 }
 
 
-/* Find a composition at or nearest to position POS of OBJECT (buffer
-   or string).
+/* Find a static composition at or nearest to position POS of OBJECT
+   (buffer or string).
 
    OBJECT defaults to the current buffer.  If there's a composition at
    POS, set *START and *END to the start and end of the sequence,
@@ -916,9 +916,10 @@ autocmp_chars (cft_element, charpos, bytepos, limit, win, face, string)
   FRAME_PTR f = XFRAME (win->frame);
   Lisp_Object pos = make_number (charpos);
   EMACS_INT pt = PT, pt_byte = PT_BYTE;
+  int lookback;
   
   record_unwind_save_match_data ();
-  for (; CONSP (cft_element); cft_element = XCDR (cft_element))
+  for (lookback = -1; CONSP (cft_element); cft_element = XCDR (cft_element))
     {
       Lisp_Object elt = XCAR (cft_element);
       Lisp_Object re;
@@ -927,6 +928,10 @@ autocmp_chars (cft_element, charpos, bytepos, limit, win, face, string)
 
       if (! VECTORP (elt) || ASIZE (elt) != 3)
         continue;
+      if (lookback < 0)
+        lookback = XFASTINT (AREF (elt, 1));
+      else if (lookback != XFASTINT (AREF (elt, 1)))
+        break;
       re = AREF (elt, 0);
       if (NILP (string))
         TEMP_SET_PT_BOTH (charpos, bytepos);
@@ -1029,7 +1034,8 @@ composition_compute_stop_pos (cmp_it, charpos, bytepos, endpos, string)
             }
           if (CONSP (val))
             {
-              cmp_it->stop_pos = charpos - 1 - XFASTINT (AREF (elt, 1));
+              cmp_it->lookback = XFASTINT (AREF (elt, 1));
+              cmp_it->stop_pos = charpos - 1 - cmp_it->lookback;
               cmp_it->ch = c;
               break;
             }
@@ -1072,12 +1078,19 @@ composition_reseat_it (cmp_it, charpos, bytepos, endpos, w, face, string)
     }
   else
     {
-      Lisp_Object val;
+      Lisp_Object val, elt;
       int i;
 
       val = CHAR_TABLE_REF (Vcomposition_function_table, cmp_it->ch);
+      for (; CONSP (val); val = XCDR (val))
+        {
+          elt = XCAR (val);
+          if (cmp_it->lookback == XFASTINT (AREF (elt, 1)))
+            break;
+        }
       if (NILP (val))
         goto no_composition;
+
       val = autocmp_chars (val, charpos, bytepos, endpos, w, face, string);
       if (! composition_gstring_p (val))
         goto no_composition;
@@ -1167,19 +1180,214 @@ composition_update_it (cmp_it, charpos, bytepos, string)
 }
 
 
+struct position_record
+{
+  EMACS_INT pos, pos_byte;
+  unsigned char *p;
+};
+
+/* Update the members of POSTION to the next character boundary.  */
+#define FORWARD_CHAR(POSITION, STOP)                                    \
+  do {                                                                  \
+    if ((POSITION).pos == (STOP))                                       \
+      (POSITION).p = GAP_END_ADDR;                                      \
+    (POSITION).pos++;                                                   \
+    (POSITION).pos_byte += BYTES_BY_CHAR_HEAD (*((POSITION).p));        \
+    (POSITION).p += BYTES_BY_CHAR_HEAD (*((POSITION).p));               \
+  } while (0)
+
+/* Update the members of POSTION to the previous character boundary.  */
+#define BACKWARD_CHAR(POSITION, STOP)           \
+  do {                                          \
+    if ((POSITION).pos == STOP)                 \
+      (POSITION).p = GPT_ADDR;                  \
+    do {                                        \
+      (POSITION).pos_byte--;                    \
+      (POSITION).p--;                           \
+    } while (! CHAR_HEAD_P (*((POSITION).p)));  \
+    (POSITION).pos--;                           \
+  } while (0)
+
+static Lisp_Object _work_val;
+static int _work_char;
+
+/* 1 iff the character C is composable.  */
+#define CHAR_COMPOSABLE_P(C)                                    \
+  (_work_val = CHAR_TABLE_REF (Vunicode_category_table, (C)),   \
+   (SYMBOLP (_work_val)                                         \
+    && (_work_char = SDATA (SYMBOL_NAME (_work_val))[0]) != 'C' \
+    && _work_char != 'Z'))
+
+/* This is like find_composition, but find an automatic composition
+   instead.  If found, set *GSTRING to the glyph-string representing
+   the composition, and return 1.  Otherwise, return 0.  */
+
+static int
+find_automatic_composition (pos, limit, start, end, gstring, string)
+     EMACS_INT pos, limit, *start, *end;
+     Lisp_Object *gstring, string;
+{
+  EMACS_INT head, tail, stop;
+  struct position_record orig, cur, check, prev;
+  Lisp_Object check_val, val, elt;
+  int check_lookback;
+  int c;
+  struct window *w;
+
+  orig.pos = pos;
+  if (NILP (string))
+    {
+      head = BEGV, tail = ZV, stop = GPT;
+      orig.pos_byte = CHAR_TO_BYTE (orig.pos);
+      orig.p = BYTE_POS_ADDR (orig.pos_byte);
+    }
+  else
+    {
+      head = 0, tail = SCHARS (string), stop = -1;
+      orig.pos_byte = string_char_to_byte (string, orig.pos);
+      orig.p = SDATA (string) + orig.pos_byte;
+    }
+  if (limit < pos)
+    {
+      head = max (head, limit);
+      tail = min (tail, pos + 3);
+    }
+  else
+    {
+      tail = min (tail, limit + 3);
+    }
+  w = XWINDOW (selected_window);
+  cur = orig;
+
+ retry:
+  check_val = Qnil;
+  /* At first, check if POS is compoable.  */
+  c = STRING_CHAR (cur.p, 0);
+  if (! CHAR_COMPOSABLE_P (c))
+    {
+      if (limit < 0)
+        return 0;
+      if (limit >= cur.pos)
+        goto search_forward;
+    }
+  else
+    {
+      val = CHAR_TABLE_REF (Vcomposition_function_table, c);
+      if (! NILP (val))
+        check_val = val, check = cur;
+      else
+        while (cur.pos + 1 < tail)
+          {
+            FORWARD_CHAR (cur, stop);
+            c = STRING_CHAR (cur.p, 0);
+            if (! CHAR_COMPOSABLE_P (c))
+              break;
+            val = CHAR_TABLE_REF (Vcomposition_function_table, c);
+            if (NILP (val))
+              continue;
+            check_val = val, check = cur;
+            break;
+          }
+      cur = orig;
+    }
+  /* Rewind back to the position where we can safely search forward
+     for compositions.  */
+  while (cur.pos > head)
+    {
+      BACKWARD_CHAR (cur, stop);
+      c = STRING_CHAR (cur.p, 0);
+      if (! CHAR_COMPOSABLE_P (c))
+        break;
+      val = CHAR_TABLE_REF (Vcomposition_function_table, c);
+      if (! NILP (val))
+        check_val = val, check = cur;
+    }
+  prev = cur;
+  /* Now search forward.  */
+ search_forward:  
+  *gstring = Qnil;
+  if (! NILP (check_val) || limit >= orig.pos)
+    {
+      if (NILP (check_val))
+        cur = orig;
+      else
+        cur = check;
+      while (cur.pos < tail)
+        {
+          int need_adjustment = 0;
+
+          if (NILP (check_val))
+            {
+              c = STRING_CHAR (cur.p, 0);
+              check_val = CHAR_TABLE_REF (Vcomposition_function_table, c);
+            }
+          for (; CONSP (check_val); check_val = XCDR (check_val))
+            {
+              elt = XCAR (check_val);
+              if (VECTORP (elt) && ASIZE (elt) == 3 && NATNUMP (AREF (elt, 1))
+                  && cur.pos - XFASTINT (AREF (elt, 1)) >= head)
+                {
+                  check.pos = cur.pos - XFASTINT (AREF (elt, 1));
+                  if (check.pos == cur.pos)
+                    check.pos_byte = cur.pos_byte;
+                  else
+                    check.pos_byte = CHAR_TO_BYTE (check.pos);
+                  val = autocmp_chars (check_val, check.pos, check.pos_byte,
+                                       tail, w, NULL, string);
+                  need_adjustment = 1;
+                  if (! NILP (val))
+                    {
+                      *gstring = val;
+                      *start = check.pos;
+                      *end = check.pos + LGSTRING_CHAR_LEN (*gstring);
+                      if (*start <= orig.pos ? *end > orig.pos
+                          : limit >= orig.pos)
+                        return 1;
+                      cur.pos = *end;
+                      cur.pos_byte = CHAR_TO_BYTE (cur.pos);
+                      break;
+                    }
+                }
+            }
+          if (need_adjustment)
+            {
+              /* As we have called Lisp, there's a possibilily that
+                 buffer/string is relocated.  */
+              if (NILP (string))
+                cur.p  = BYTE_POS_ADDR (cur.pos_byte);
+              else
+                cur.p = SDATA (string) + cur.pos_byte;
+            }
+          if (! CONSP (check_val))
+            FORWARD_CHAR (cur, stop);
+          check_val = Qnil;
+        }
+    }
+  if (! NILP (*gstring))
+    return (limit >= 0 || (*start <= orig.pos && *end > orig.pos));
+  if (limit >= 0 && limit < orig.pos && prev.pos > head)
+    {
+      cur = prev;
+      BACKWARD_CHAR (cur, stop);
+      orig = cur;
+      tail = orig.pos;
+      goto retry;
+    }
+  return 0;
+}
+
 int
 composition_adjust_point (last_pt)
      EMACS_INT last_pt;
 {
-  /* Now check the automatic composition. */
   EMACS_INT charpos, bytepos, startpos, beg, end, pos;
-  Lisp_Object val, cat;
-  EMACS_INT limit;
-  int c;
+  Lisp_Object val;
+  int i;
 
   if (PT == BEGV || PT == ZV)
     return PT;
 
+  /* At first check the static composition. */
   if (get_property_and_range (PT, Qcomposition, &val, &beg, &end, Qnil)
       && COMPOSITION_VALID_P (beg, end, val)
       && beg < PT /* && end > PT   <- It's always the case.  */
@@ -1190,97 +1398,22 @@ composition_adjust_point (last_pt)
       || ! FUNCTIONP (Vauto_composition_function))
     return PT;
 
-  c = FETCH_MULTIBYTE_CHAR (PT_BYTE);
-  cat = CHAR_TABLE_REF (Vunicode_category_table, c);
-  if (SYMBOLP (cat)
-      && ((c = SDATA (SYMBOL_NAME (cat))[0]) == 'C' || c == 'Z'))
-    /* A control character is never composed.  */
+  /* Next check the automatic composition.  */
+  if (! find_automatic_composition (PT, -1, &beg, &end, &val, Qnil)
+      || beg == PT)
     return PT;
-
-  charpos = PT;
-  bytepos = PT_BYTE;
-  limit = (last_pt < PT ? last_pt : BEGV);
-  do {
-    DEC_BOTH (charpos, bytepos);
-    c = FETCH_MULTIBYTE_CHAR (bytepos);
-    cat = CHAR_TABLE_REF (Vunicode_category_table, c);
-    if (SYMBOLP (cat)
-        && ((c = SDATA (SYMBOL_NAME (cat))[0]) == 'C' || c == 'Z'))
-      {
-        INC_BOTH (charpos, bytepos);
-        break;
-      }
-  } while (charpos > limit);
-
-
-  limit = (last_pt < PT ? ZV : last_pt);
-  if (limit > PT + 3)
-    limit = PT + 3;
-  startpos = charpos;
-  while (charpos < limit)
+  for (i = 0; i < LGSTRING_GLYPH_LEN (val); i++)
     {
-      c = FETCH_MULTIBYTE_CHAR (bytepos);
-      if (charpos > PT)
-        {
-          int ch;
-
-          cat = CHAR_TABLE_REF (Vunicode_category_table, c);
-          if (SYMBOLP (cat)
-              && ((ch = SDATA (SYMBOL_NAME (cat))[0]) == 'C' || ch == 'Z'))
-            return PT;
-        }
-      val = CHAR_TABLE_REF (Vcomposition_function_table, c);
-      if (! CONSP (val))
-        {
-          INC_BOTH (charpos, bytepos);
-          continue;
-        }
-      for (; CONSP (val); val = XCDR (val))
-        {
-          Lisp_Object elt = XCAR (val);
+      Lisp_Object glyph = LGSTRING_GLYPH (val, i);
 
-          if (VECTORP (elt) && ASIZE (elt) == 3 && NATNUMP (AREF (elt, 1))
-              && (pos = charpos - XFASTINT (AREF (elt, 1))) < PT
-              && pos >= startpos)
-            {
-              Lisp_Object gstring;
-              EMACS_INT pos_byte;
-
-              if (XFASTINT (AREF (elt, 1)) == 0)
-                pos_byte = bytepos;
-              else
-                pos_byte = CHAR_TO_BYTE (pos);
-              gstring = autocmp_chars (val, pos, pos_byte, Z,
-                                       XWINDOW (selected_window), NULL, Qnil);
-              if (composition_gstring_p (gstring))
-                {
-                  if (pos + LGSTRING_CHAR_LEN (gstring) > PT)
-                    {
-                      int i;
-
-                      for (i = 0; i < LGSTRING_GLYPH_LEN (gstring); i++)
-                        {
-                          Lisp_Object glyph = LGSTRING_GLYPH (gstring, i);
-
-                          if (NILP (glyph))
-                            break;
-                          if (pos + LGLYPH_FROM (glyph) == PT)
-                            return PT;
-                          if (pos + LGLYPH_TO (glyph) + 1 > PT)
-                            return (PT < last_pt
-                                    ? pos + LGLYPH_FROM (glyph)
-                                    : pos + LGLYPH_TO (glyph) + 1);
-                        }
-                      return PT;
-                    }
-                  charpos = startpos = pos + LGSTRING_CHAR_LEN (gstring);
-                  bytepos = CHAR_TO_BYTE (charpos);
-                  break;
-                }
-            }
-        }
-      if (! CONSP (val))
-        INC_BOTH (charpos, bytepos);
+      if (NILP (glyph))
+        break;
+      if (beg + LGLYPH_FROM (glyph) == PT)
+        return PT;
+      if (beg + LGLYPH_TO (glyph) >= PT)
+        return (PT < last_pt
+                ? beg + LGLYPH_FROM (glyph)
+                : beg + LGLYPH_TO (glyph) + 1);
     }
   return PT;
 }
@@ -1395,19 +1528,19 @@ See `find-composition' for more detail.  */)
      (pos, limit, string, detail_p)
      Lisp_Object pos, limit, string, detail_p;
 {
-  Lisp_Object prop, tail;
-  EMACS_INT start, end;
+  Lisp_Object prop, tail, gstring;
+  EMACS_INT start, end, from, to;
   int id;
 
   CHECK_NUMBER_COERCE_MARKER (pos);
-  start = XINT (pos);
+  from = XINT (pos);
   if (!NILP (limit))
     {
       CHECK_NUMBER_COERCE_MARKER (limit);
-      end = XINT (limit);
+      to = XINT (limit);
     }
   else
-    end = -1;
+    to = -1;
 
   if (!NILP (string))
     {
@@ -1421,8 +1554,23 @@ See `find-composition' for more detail.  */)
         args_out_of_range (Fcurrent_buffer (), pos);
     }
 
-  if (!find_composition (start, end, &start, &end, &prop, string))
-    return Qnil;
+  if (!find_composition (from, to, &start, &end, &prop, string))
+    {
+      if (!NILP (current_buffer->enable_multibyte_characters)
+          && FUNCTIONP (Vauto_composition_function)
+          && find_automatic_composition (from, to, &start, &end, &gstring,
+                                         string))
+        return list3 (make_number (start), make_number (end), gstring);
+      return Qnil;
+    }
+  if ((end <= XINT (pos) || start > XINT (pos)))
+    {
+      EMACS_INT s, e;
+
+      if (find_automatic_composition (from, to, &s, &e, &gstring, string)
+          && (e <= XINT (pos) ? e > end : s < start))
+        return list3 (make_number (start), make_number (end), gstring);
+    }
   if (!COMPOSITION_VALID_P (start, end, prop))
     return Fcons (make_number (start), Fcons (make_number (end),
                                               Fcons (Qnil, Qnil)));