* fileio.c (Fread_file_name): Do not pass redundant args and ...

* callint.c (read_file_name): ... convert to static here.
* lisp.h (Fread_file_name): Do not EXFUN it.
* composite.c (CHAR_COMPOSABLE_P): Replace unsafe macro with ...
(char_composable_p): ... static function.  All users changed.

1 files changed, 16 insertions, 15 deletions

diff --git a/src/composite.c b/src/composite.c
index fa882141908..5e14ad037a6 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -921,17 +921,18 @@ autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos,
   return unbind_to (count, lgstring);
 }
 
-static Lisp_Object _work_val;
-
 /* 1 iff the character C is composable.  Characters of general
    category Z? or C? are not composable except for ZWNJ and ZWJ. */
 
-#define CHAR_COMPOSABLE_P(C)                                            \
-  ((C) > ' '                                                            \
-   && ((C) == 0x200C || (C) == 0x200D                                   \
-       || (_work_val = CHAR_TABLE_REF (Vunicode_category_table, (C)),   \
-           (INTEGERP (_work_val)                                        \
-            && (XINT (_work_val) <= UNICODE_CATEGORY_So)))))
+static bool
+char_composable_p (int c)
+{
+  Lisp_Object val;
+  return (c > ' '                       
+          && (c == 0x200C || c == 0x200D
+              || (val = CHAR_TABLE_REF (Vunicode_category_table, c),
+                  (INTEGERP (val) && (XINT (val) <= UNICODE_CATEGORY_So)))));
+}
 
 /* Update cmp_it->stop_pos to the next position after CHARPOS (and
    BYTEPOS) where character composition may happen.  If BYTEPOS is
@@ -1067,7 +1068,7 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
         p = SDATA (string) + bytepos;
       c = STRING_CHAR_AND_LENGTH (p, len);
       limit = bytepos + len;
-      while (CHAR_COMPOSABLE_P (c))
+      while (char_composable_p (c))
         {
           val = CHAR_TABLE_REF (Vcomposition_function_table, c);
           if (! NILP (val))
@@ -1144,7 +1145,7 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
       /* Skip all uncomposable characters.  */
       if (NILP (string))
         {
-          while (charpos - 1 > endpos && ! CHAR_COMPOSABLE_P (c))
+          while (charpos - 1 > endpos && ! char_composable_p (c))
             {
               DEC_BOTH (charpos, bytepos);
               c = FETCH_MULTIBYTE_CHAR (bytepos);
@@ -1152,7 +1153,7 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
         }
       else
         {
-          while (charpos - 1 > endpos && ! CHAR_COMPOSABLE_P (c))
+          while (charpos - 1 > endpos && ! char_composable_p (c))
             {
               p--;
               while (! CHAR_HEAD_P (*p))
@@ -1486,7 +1487,7 @@ find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
                   |-B-|-C-|--D--|
 
      Here, it is known that characters after positions 1 and 9 can
-     never be composed (i.e. ! CHAR_COMPOSABLE_P (CH)), and
+     never be composed (i.e. ! char_composable_p (CH)), and
      composition A is an invalid one because it's partially covered by
      the valid composition C.  And to know whether a composition is
      valid or not, the only way is to start searching forward from a
@@ -1510,7 +1511,7 @@ find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
   while (1)
     {
       c = STRING_CHAR (cur.p);
-      if (! CHAR_COMPOSABLE_P (c))
+      if (! char_composable_p (c))
         {
           if (limit <= pos)     /* case (1)  */
             {
@@ -1519,7 +1520,7 @@ find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
                   return 0;
                 BACKWARD_CHAR (cur, stop);
                 c = STRING_CHAR (cur.p);
-              } while (! CHAR_COMPOSABLE_P (c));
+              } while (! char_composable_p (c));
               fore_check_limit = cur.pos + 1;
             }
           else                  /* case (2) */
@@ -1535,7 +1536,7 @@ find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
           prev = cur;
           BACKWARD_CHAR (cur, stop);
           c = STRING_CHAR (cur.p);
-          if (! CHAR_COMPOSABLE_P (c))
+          if (! char_composable_p (c))
             {
               cur = prev;
               break;