* gtkutil.c (USE_NEW_GTK_FONT_CHOOSER) [HAVE_FREETYPE]:

[gnu-emacs] / src / composite.c

diff --git a/src/composite.c b/src/composite.c
index 9bbd4550c7b41db9fd31d4c7aa2f5f4282eac789..cef2ed86e573fbf82cb4472c0daecb9ebecb7cb8 100644 (file)
--- a/src/composite.c
+++ b/src/composite.c
@@ -24,8 +24,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 
 
 #include <config.h>
 

-#define COMPOSITE_INLINE EXTERN_INLINE
-

 #include "lisp.h"
 #include "character.h"
 #include "buffer.h"
 #include "lisp.h"
 #include "character.h"
 #include "buffer.h"


@@ -160,10 +158,6 @@ static Lisp_Object Qauto_composition_function;
    auto-compositions.  */
 #define MAX_AUTO_COMPOSITION_LOOKBACK 3
 
    auto-compositions.  */
 #define MAX_AUTO_COMPOSITION_LOOKBACK 3
 

-/* Temporary variable used in macros COMPOSITION_XXX.  */
-Lisp_Object composition_temp;
-
-\f

 /* Return COMPOSITION-ID of a composition at buffer position
    CHARPOS/BYTEPOS and length NCHARS.  The `composition' property of
    the sequence is PROP.  STRING, if non-nil, is a string that
 /* Return COMPOSITION-ID of a composition at buffer position
    CHARPOS/BYTEPOS and length NCHARS.  The `composition' property of
    the sequence is PROP.  STRING, if non-nil, is a string that


@@ -234,7 +228,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
     key = components;
   else if (NILP (components))
     {
     key = components;
   else if (NILP (components))
     {

-      key = Fmake_vector (make_number (nchars), Qnil);
+      key = make_uninit_vector (nchars);

       if (STRINGP (string))
        for (i = 0; i < nchars; i++)
          {
       if (STRINGP (string))
        for (i = 0; i < nchars; i++)
          {


@@ -478,11 +472,11 @@ run_composition_function (ptrdiff_t from, ptrdiff_t to, Lisp_Object prop)
      valid too.  */
   if (from > BEGV
       && find_composition (from - 1, -1, &start, &end, &prop, Qnil)
      valid too.  */
   if (from > BEGV
       && find_composition (from - 1, -1, &start, &end, &prop, Qnil)

-      && !COMPOSITION_VALID_P (start, end, prop))
+      && !composition_valid_p (start, end, prop))

     from = start;
   if (to < ZV
       && find_composition (to, -1, &start, &end, &prop, Qnil)
     from = start;
   if (to < ZV
       && find_composition (to, -1, &start, &end, &prop, Qnil)

-      && !COMPOSITION_VALID_P (start, end, prop))
+      && !composition_valid_p (start, end, prop))

     to = end;
   if (!NILP (Ffboundp (func)))
     call2 (func, make_number (from), make_number (to));
     to = end;
   if (!NILP (Ffboundp (func)))
     call2 (func, make_number (from), make_number (to));


@@ -524,7 +518,7 @@ update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
         latter to the copy of it.  */
       if (from > BEGV
          && find_composition (from - 1, -1, &start, &end, &prop, Qnil)
         latter to the copy of it.  */
       if (from > BEGV
          && find_composition (from - 1, -1, &start, &end, &prop, Qnil)

-         && COMPOSITION_VALID_P (start, end, prop))
+         && composition_valid_p (start, end, prop))

        {
          min_pos = start;
          if (end > to)
        {
          min_pos = start;
          if (end > to)


@@ -538,7 +532,7 @@ update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
        }
       else if (from < ZV
               && find_composition (from, -1, &start, &from, &prop, Qnil)
        }
       else if (from < ZV
               && find_composition (from, -1, &start, &from, &prop, Qnil)

-              && COMPOSITION_VALID_P (start, from, prop))
+              && composition_valid_p (start, from, prop))

        {
          if (from > to)
            max_pos = from;
        {
          if (from > to)
            max_pos = from;


@@ -553,7 +547,7 @@ update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
          (to - 1).  */
       while (from < to - 1
             && find_composition (from, to, &start, &from, &prop, Qnil)
          (to - 1).  */
       while (from < to - 1
             && find_composition (from, to, &start, &from, &prop, Qnil)

-            && COMPOSITION_VALID_P (start, from, prop)
+            && composition_valid_p (start, from, prop)

             && from < to - 1)
        run_composition_function (start, from, prop);
     }
             && from < to - 1)
        run_composition_function (start, from, prop);
     }


@@ -562,7 +556,7 @@ update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
     {
       if (from < to
          && find_composition (to - 1, -1, &start, &end, &prop, Qnil)
     {
       if (from < to
          && find_composition (to - 1, -1, &start, &end, &prop, Qnil)

-         && COMPOSITION_VALID_P (start, end, prop))
+         && composition_valid_p (start, end, prop))

        {
          /* TO should be also at composition boundary.  But,
             insertion or deletion will make two compositions adjacent
        {
          /* TO should be also at composition boundary.  But,
             insertion or deletion will make two compositions adjacent


@@ -580,7 +574,7 @@ update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
        }
       else if (to < ZV
               && find_composition (to, -1, &start, &end, &prop, Qnil)
        }
       else if (to < ZV
               && find_composition (to, -1, &start, &end, &prop, Qnil)

-              && COMPOSITION_VALID_P (start, end, prop))
+              && composition_valid_p (start, end, prop))

        {
          run_composition_function (start, end, prop);
          max_pos = end;
        {
          run_composition_function (start, end, prop);
          max_pos = end;


@@ -595,7 +589,7 @@ update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
       specbind (Qinhibit_point_motion_hooks, Qt);
       Fremove_list_of_text_properties (make_number (min_pos),
                                       make_number (max_pos),
       specbind (Qinhibit_point_motion_hooks, Qt);
       Fremove_list_of_text_properties (make_number (min_pos),
                                       make_number (max_pos),

-                                      Fcons (Qauto_composed, Qnil), Qnil);
+                                      list1 (Qauto_composed), Qnil);

       unbind_to (count, Qnil);
     }
 }
       unbind_to (count, Qnil);
     }
 }


@@ -680,7 +674,6 @@ composition_gstring_put_cache (Lisp_Object gstring, ptrdiff_t len)
       len = j;
     }
 
       len = j;
     }
 

-  lint_assume (len <= TYPE_MAXIMUM (ptrdiff_t) - 2);

   copy = Fmake_vector (make_number (len + 2), Qnil);
   LGSTRING_SET_HEADER (copy, Fcopy_sequence (header));
   for (i = 0; i < len; i++)
   copy = Fmake_vector (make_number (len + 2), Qnil);
   LGSTRING_SET_HEADER (copy, Fcopy_sequence (header));
   for (i = 0; i < len; i++)


@@ -698,10 +691,6 @@ composition_gstring_from_id (ptrdiff_t id)
   return HASH_VALUE (h, id);
 }
 
   return HASH_VALUE (h, id);
 }
 

-static Lisp_Object fill_gstring_header (Lisp_Object, Lisp_Object,
-                                        Lisp_Object, Lisp_Object,
-                                        Lisp_Object);
-

 bool
 composition_gstring_p (Lisp_Object gstring)
 {
 bool
 composition_gstring_p (Lisp_Object gstring)
 {


@@ -791,7 +780,8 @@ static Lisp_Object gstring_work;
 static Lisp_Object gstring_work_headers;
 
 static Lisp_Object
 static Lisp_Object gstring_work_headers;
 
 static Lisp_Object

-fill_gstring_header (Lisp_Object header, Lisp_Object start, Lisp_Object end, Lisp_Object font_object, Lisp_Object string)
+fill_gstring_header (Lisp_Object header, Lisp_Object start, Lisp_Object end,
+                    Lisp_Object font_object, Lisp_Object string)

 {
   ptrdiff_t from, to, from_byte;
   ptrdiff_t len, i;
 {
   ptrdiff_t from, to, from_byte;
   ptrdiff_t len, i;


@@ -831,7 +821,7 @@ fill_gstring_header (Lisp_Object header, Lisp_Object start, Lisp_Object end, Lis
       if (len <= 8)
        header = AREF (gstring_work_headers, len - 1);
       else
       if (len <= 8)
        header = AREF (gstring_work_headers, len - 1);
       else

-       header = Fmake_vector (make_number (len + 1), Qnil);
+       header = make_uninit_vector (len + 1);

     }
 
   ASET (header, 0, font_object);
     }
 
   ASET (header, 0, font_object);


@@ -904,7 +894,7 @@ autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos,
               Lisp_Object string)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
               Lisp_Object string)
 {
   ptrdiff_t count = SPECPDL_INDEX ();

-  FRAME_PTR f = XFRAME (win->frame);
+  struct frame *f = XFRAME (win->frame);

   Lisp_Object pos = make_number (charpos);
   ptrdiff_t to;
   ptrdiff_t pt = PT, pt_byte = PT_BYTE;
   Lisp_Object pos = make_number (charpos);
   ptrdiff_t to;
   ptrdiff_t pt = PT, pt_byte = PT_BYTE;


@@ -1015,7 +1005,7 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
   if (charpos < endpos
       && find_composition (charpos, endpos, &start, &end, &prop, string)
       && start >= charpos
   if (charpos < endpos
       && find_composition (charpos, endpos, &start, &end, &prop, string)
       && start >= charpos

-      && COMPOSITION_VALID_P (start, end, prop))
+      && composition_valid_p (start, end, prop))

     {
       cmp_it->stop_pos = endpos = start;
       cmp_it->ch = -1;
     {
       cmp_it->stop_pos = endpos = start;
       cmp_it->ch = -1;


@@ -1201,7 +1191,7 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
 
 /* Check if the character at CHARPOS (and BYTEPOS) is composed
    (possibly with the following characters) on window W.  ENDPOS limits
 
 /* Check if the character at CHARPOS (and BYTEPOS) is composed
    (possibly with the following characters) on window W.  ENDPOS limits

-   characters to be composed.  FACE, in non-NULL, is a base face of
+   characters to be composed.  FACE, if non-NULL, is a base face of

    the character.  If STRING is not nil, it is a string containing the
    character to check, and CHARPOS and BYTEPOS are indices in the
    string.  In that case, FACE must not be NULL.
    the character.  If STRING is not nil, it is a string containing the
    character to check, and CHARPOS and BYTEPOS are indices in the
    string.  In that case, FACE must not be NULL.


@@ -1675,7 +1665,7 @@ composition_adjust_point (ptrdiff_t last_pt, ptrdiff_t new_pt)
 
   /* At first check the static composition. */
   if (get_property_and_range (new_pt, Qcomposition, &val, &beg, &end, Qnil)
 
   /* At first check the static composition. */
   if (get_property_and_range (new_pt, Qcomposition, &val, &beg, &end, Qnil)

-      && COMPOSITION_VALID_P (beg, end, val))
+      && composition_valid_p (beg, end, val))

     {
       if (beg < new_pt /* && end > new_pt   <- It's always the case.  */
          && (last_pt <= beg || last_pt >= end))
     {
       if (beg < new_pt /* && end > new_pt   <- It's always the case.  */
          && (last_pt <= beg || last_pt >= end))


@@ -1875,14 +1865,12 @@ See `find-composition' for more details.  */)
          && (e <= XINT (pos) ? e > end : s < start))
        return list3 (make_number (s), make_number (e), gstring);
     }
          && (e <= XINT (pos) ? e > end : s < start))
        return list3 (make_number (s), make_number (e), gstring);
     }

-  if (!COMPOSITION_VALID_P (start, end, prop))
-    return Fcons (make_number (start), Fcons (make_number (end),
-                                             Fcons (Qnil, Qnil)));
+  if (!composition_valid_p (start, end, prop))
+    return list3 (make_number (start), make_number (end), Qnil);

   if (NILP (detail_p))
   if (NILP (detail_p))

-    return Fcons (make_number (start), Fcons (make_number (end),
-                                             Fcons (Qt, Qnil)));
+    return list3 (make_number (start), make_number (end), Qt);

 
 

-  if (COMPOSITION_REGISTERD_P (prop))
+  if (composition_registered_p (prop))

     id = COMPOSITION_ID (prop);
   else
     {
     id = COMPOSITION_ID (prop);
   else
     {


@@ -1895,17 +1883,14 @@ See `find-composition' for more details.  */)
   if (id >= 0)
     {
       Lisp_Object components, relative_p, mod_func;
   if (id >= 0)
     {
       Lisp_Object components, relative_p, mod_func;

-      enum composition_method method = COMPOSITION_METHOD (prop);
+      enum composition_method method = composition_method (prop);

       int width = composition_table[id]->width;
 
       components = Fcopy_sequence (COMPOSITION_COMPONENTS (prop));
       relative_p = (method == COMPOSITION_WITH_RULE_ALTCHARS
                    ? Qnil : Qt);
       mod_func = COMPOSITION_MODIFICATION_FUNC (prop);
       int width = composition_table[id]->width;
 
       components = Fcopy_sequence (COMPOSITION_COMPONENTS (prop));
       relative_p = (method == COMPOSITION_WITH_RULE_ALTCHARS
                    ? Qnil : Qt);
       mod_func = COMPOSITION_MODIFICATION_FUNC (prop);

-      tail = Fcons (components,
-                   Fcons (relative_p,
-                          Fcons (mod_func,
-                                 Fcons (make_number (width), Qnil))));
+      tail = list4 (components, relative_p, mod_func, make_number (width));

     }
   else
     tail = Qnil;
     }
   else
     tail = Qnil;