Prefer more inline functions in character.h

* src/buffer.h (fetch_char_advance, fetch_char_advance_no_check)
(buf_next_char_len, next_char_len, buf_prev_char_len)
(prev_char_len, inc_both, dec_both): New inline functions,
replacing the old character.h macros FETCH_CHAR_ADVANCE,
FETCH_CHAR_ADVANCE_NO_CHECK, BUF_INC_POS, INC_POS, BUF_DEC_POS,
DEC_POS, INC_BOTH, DEC_BOTH respectively.  All callers changed.
These new functions all assume buffer primitives and so need
to be here rather than in character.h.
* src/casefiddle.c (make_char_unibyte): New static function,
replacing the old MAKE_CHAR_UNIBYTE macro.  All callers changed.
(do_casify_unibyte_string): Use SINGLE_BYTE_CHAR_P instead
of open-coding it.
* src/ccl.c (GET_TRANSLATION_TABLE): New static function,
replacing the old macro of the same name.
* src/character.c (string_char): Omit 2nd arg.  3rd arg can no
longer be NULL.  All callers changed.
* src/character.h (SINGLE_BYTE_CHAR_P): Move up.
(MAKE_CHAR_UNIBYTE, MAKE_CHAR_MULTIBYTE, PREV_CHAR_BOUNDARY)
(STRING_CHAR_AND_LENGTH, STRING_CHAR_ADVANCE)
(FETCH_STRING_CHAR_ADVANCE)
(FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE)
(FETCH_STRING_CHAR_ADVANCE_NO_CHECK, FETCH_CHAR_ADVANCE)
(FETCH_CHAR_ADVANCE_NO_CHECK, INC_POS, DEC_POS, INC_BOTH)
(DEC_BOTH, BUF_INC_POS, BUF_DEC_POS): Remove.
(make_char_multibyte): New static function, replacing
the old macro MAKE_CHAR_MULTIBYTE.  All callers changed.
(CHAR_STRING_ADVANCE): Remove; all callers changed to use
CHAR_STRING.
(NEXT_CHAR_BOUNDARY): Remove; it was unused.
(raw_prev_char_len): New inline function, replacing the
old PREV_CHAR_BOUNDARY macro.  All callers changed.
(string_char_and_length): New inline function, replacing the
old STRING_CHAR_AND_LENGTH macro.  All callers changed.
(STRING_CHAR): Rewrite in terms of string_char_and_length.
(string_char_advance): New inline function, replacing the old
STRING_CHAR_ADVANCE macro.  All callers changed.
(fetch_string_char_advance): New inline function, replacing the
old FETCH_STRING_CHAR_ADVANCE macro.  All callers changed.
(fetch_string_char_as_multibyte_advance): New inline function,
replacing the old FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE macro.
All callers changed.
(fetch_string_char_advance_no_check): New inline function,
replacing the old FETCH_STRING_CHAR_ADVANCE_NO_CHECK macro.  All
callers changed.
* src/regex-emacs.c (HEAD_ADDR_VSTRING): Remove; no longer used.
* src/syntax.c (scan_lists): Use dec_bytepos instead of
open-coding it.
* src/xdisp.c (string_char_and_length): Rename from
string_char_and_length to avoid name conflict with new function in
character.h.  All callers changed.

1 files changed, 26 insertions, 35 deletions

diff --git a/src/coding.c b/src/coding.c
index 0daa390bc85..716b0d99792 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -643,7 +643,7 @@ growable_destination (struct coding_system *coding)
         else                                            \
           {                                             \
             src--;                                      \
-            c = - string_char (src, &src, NULL);        \
+            c = - string_char_advance (&src);           \
             record_conversion_result                    \
               (coding, CODING_RESULT_INVALID_SRC);      \
           }                                             \
@@ -728,7 +728,7 @@ growable_destination (struct coding_system *coding)
         unsigned ch = (c);              \
         if (ch >= 0x80)                 \
           ch = BYTE8_TO_CHAR (ch);      \
-        CHAR_STRING_ADVANCE (ch, dst);  \
+        dst += CHAR_STRING (ch, dst);   \
       }                                 \
     else                                \
       *dst++ = (c);                     \
@@ -747,11 +747,11 @@ growable_destination (struct coding_system *coding)
         ch = (c1);                      \
         if (ch >= 0x80)                 \
           ch = BYTE8_TO_CHAR (ch);      \
-        CHAR_STRING_ADVANCE (ch, dst);  \
+        dst += CHAR_STRING (ch, dst);   \
         ch = (c2);                      \
         if (ch >= 0x80)                 \
           ch = BYTE8_TO_CHAR (ch);      \
-        CHAR_STRING_ADVANCE (ch, dst);  \
+        dst += CHAR_STRING (ch, dst);   \
       }                                 \
     else                                \
       {                                 \
@@ -884,18 +884,18 @@ record_conversion_result (struct coding_system *coding,
 
 
 /* Store multibyte form of the character C in P, and advance P to the
-   end of the multibyte form.  This used to be like CHAR_STRING_ADVANCE
+   end of the multibyte form.  This used to be like adding CHAR_STRING
    without ever calling MAYBE_UNIFY_CHAR, but nowadays we don't call
-   MAYBE_UNIFY_CHAR in CHAR_STRING_ADVANCE.  */
+   MAYBE_UNIFY_CHAR in CHAR_STRING.  */
 
-#define CHAR_STRING_ADVANCE_NO_UNIFY(c, p)  CHAR_STRING_ADVANCE(c, p)
+#define CHAR_STRING_ADVANCE_NO_UNIFY(c, p) ((p) += CHAR_STRING (c, p))
 
 /* Return the character code of character whose multibyte form is at
    P, and advance P to the end of the multibyte form.  This used to be
-   like STRING_CHAR_ADVANCE without ever calling MAYBE_UNIFY_CHAR, but
-   nowadays STRING_CHAR_ADVANCE doesn't call MAYBE_UNIFY_CHAR.  */
+   like string_char_advance without ever calling MAYBE_UNIFY_CHAR, but
+   nowadays string_char_advance doesn't call MAYBE_UNIFY_CHAR.  */
 
-#define STRING_CHAR_ADVANCE_NO_UNIFY(p) STRING_CHAR_ADVANCE(p)
+#define STRING_CHAR_ADVANCE_NO_UNIFY(p) string_char_advance (&(p))
 
 /* Set coding->source from coding->src_object.  */
 
@@ -5131,7 +5131,7 @@ decode_coding_ccl (struct coding_system *coding)
           while (i < 1024 && p < src_end)
             {
               source_byteidx[i] = p - src;
-              source_charbuf[i++] = STRING_CHAR_ADVANCE (p);
+              source_charbuf[i++] = string_char_advance (&p);
             }
           source_byteidx[i] = p - src;
         }
@@ -5308,15 +5308,10 @@ encode_coding_raw_text (struct coding_system *coding)
               }
             else
               {
-                unsigned char str[MAX_MULTIBYTE_LENGTH], *p0 = str, *p1 = str;
-
-                CHAR_STRING_ADVANCE (c, p1);
-                do
-                  {
-                    EMIT_ONE_BYTE (*p0);
-                    p0++;
-                  }
-                while (p0 < p1);
+                unsigned char str[MAX_MULTIBYTE_LENGTH];
+                int len = CHAR_STRING (c, str);
+                for (int i = 0; i < len; i++)
+                  EMIT_ONE_BYTE (str[i]);
               }
           }
       else
@@ -5342,7 +5337,7 @@ encode_coding_raw_text (struct coding_system *coding)
               else if (CHAR_BYTE8_P (c))
                 *dst++ = CHAR_TO_BYTE8 (c);
               else
-                CHAR_STRING_ADVANCE (c, dst);
+                dst += CHAR_STRING (c, dst);
             }
         }
       else
@@ -7457,7 +7452,7 @@ decode_coding (struct coding_system *coding)
               if (coding->src_multibyte
                   && CHAR_BYTE8_HEAD_P (*src) && nbytes > 0)
                 {
-                  c = STRING_CHAR_ADVANCE (src);
+                  c = string_char_advance (&src);
                   nbytes--;
                 }
               else
@@ -7551,10 +7546,8 @@ handle_composition_annotation (ptrdiff_t pos, ptrdiff_t limit,
                   len = SCHARS (components);
                   i = i_byte = 0;
                   while (i < len)
-                    {
-                      FETCH_STRING_CHAR_ADVANCE (*buf, components, i, i_byte);
-                      buf++;
-                    }
+                    *buf++ = fetch_string_char_advance (components,
+                                                        &i, &i_byte);
                 }
               else if (FIXNUMP (components))
                 {
@@ -7715,7 +7708,7 @@ consume_chars (struct coding_system *coding, Lisp_Object translation_table,
 
           lookup_buf[0] = c;
           for (i = 1; i < max_lookup && p < src_end; i++)
-            lookup_buf[i] = STRING_CHAR_ADVANCE (p);
+            lookup_buf[i] = string_char_advance (&p);
           lookup_buf_end = lookup_buf + i;
           trans = get_translation (trans, lookup_buf, lookup_buf_end,
                                    &from_nchars);
@@ -9075,7 +9068,7 @@ DEFUN ("find-coding-systems-region-internal",
         p++;
       else
         {
-          c = STRING_CHAR_ADVANCE (p);
+          c = string_char_advance (&p);
           if (!NILP (char_table_ref (work_table, c)))
             /* This character was already checked.  Ignore it.  */
             continue;
@@ -9208,7 +9201,7 @@ to the string and treated as in `substring'.  */)
           p = GAP_END_ADDR;
         }
 
-      c = STRING_CHAR_ADVANCE (p);
+      c = string_char_advance (&p);
       if (! (ASCII_CHAR_P (c) && ascii_compatible)
           && ! char_charset (translate_char (translation_table, c),
                              charset_list, NULL))
@@ -9326,7 +9319,7 @@ is nil.  */)
         p++;
       else
         {
-          c = STRING_CHAR_ADVANCE (p);
+          c = string_char_advance (&p);
 
           charset_map_loaded = 0;
           for (tail = list; CONSP (tail); tail = XCDR (tail))
@@ -9728,7 +9721,7 @@ encode_string_utf_8 (Lisp_Object string, Lisp_Object buffer,
               || (len == 2 ? ! CHAR_BYTE8_HEAD_P (c)
                   : (EQ (handle_over_uni, Qt)
                      || (len == 4
-                         && string_char (p, NULL, NULL) <= MAX_UNICODE_CHAR))))
+                         && STRING_CHAR (p) <= MAX_UNICODE_CHAR))))
             {
               p += len;
               continue;
@@ -10010,8 +10003,7 @@ decode_string_utf_8 (Lisp_Object string, const char *str, ptrdiff_t str_len,
                   && (len == 3
                       || (UTF_8_EXTRA_OCTET_P (p[3])
                           && len == 4
-                          && (string_char (p, NULL, NULL)
-                              <= MAX_UNICODE_CHAR))))))
+                          && STRING_CHAR (p) <= MAX_UNICODE_CHAR)))))
         {
           p += len;
           continue;
@@ -10148,8 +10140,7 @@ decode_string_utf_8 (Lisp_Object string, const char *str, ptrdiff_t str_len,
                    mlen++);
               if (mlen == len
                   && (len <= 3
-                      || (len == 4
-                          && string_char (p, NULL, NULL) <= MAX_UNICODE_CHAR)
+                      || (len == 4 && STRING_CHAR (p) <= MAX_UNICODE_CHAR)
                       || EQ (handle_over_uni, Qt)))
                 {
                   p += len;