* composite.h: Minor fixups.

(composition_registered_p): Rename from COMPOSITION_REGISTERD_P
to fix a misspelling, and change it to an inline function while
we're at it (it need not be a macro).  All uses changed.
(composition_method, composition_valid_p):
Rewrite to avoid assignments in if-conditions.

3 files changed, 42 insertions, 30 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 8f275f0fe89..69e00cadbe9 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,12 @@
+2013-08-03  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * composite.h: Minor fixups.
+        (composition_registered_p): Rename from COMPOSITION_REGISTERD_P
+        to fix a misspelling, and change it to an inline function while
+        we're at it (it need not be a macro).  All uses changed.
+        (composition_method, composition_valid_p):
+        Rewrite to avoid assignments in if-conditions.
+
 2013-08-03  Dmitry Antipov  <dmantipov@yandex.ru>
 
         Do not use global Lisp_Object in composition macros.
diff --git a/src/composite.c b/src/composite.c
index 91a5c75630a..28942fe4f74 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1873,7 +1873,7 @@ See `find-composition' for more details.  */)
   if (NILP (detail_p))
     return list3 (make_number (start), make_number (end), Qt);
 
-  if (COMPOSITION_REGISTERD_P (prop))
+  if (composition_registered_p (prop))
     id = COMPOSITION_ID (prop);
   else
     {
diff --git a/src/composite.h b/src/composite.h
index fbb5add7c55..53665b36bd1 100644
--- a/src/composite.h
+++ b/src/composite.h
@@ -49,34 +49,38 @@ enum composition_method {
 /* Maximum number of components a single composition can have.  */
 #define MAX_COMPOSITION_COMPONENTS 16
 
-/* These macros access information about a composition that
+/* These operations access information about a composition that
    has `composition' property PROP.  PROP is:
         ((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
    or
         (COMPOSITION-ID . (LENGTH COMPONENTS . MODIFICATION-FUNC))
    They don't check validity of PROP.  */
 
-/* Return 1 if the composition is already registered.  */
-#define COMPOSITION_REGISTERD_P(prop) INTEGERP (XCAR (prop))
+/* Return true if PROP is already registered.  */
+COMPOSITE_INLINE bool
+composition_registered_p (Lisp_Object prop)
+{
+  return INTEGERP (XCAR (prop));
+}
 
 /* Return ID number of the already registered composition.  */
 #define COMPOSITION_ID(prop) XINT (XCAR (prop))
 
 /* Return length of the composition.  */
 #define COMPOSITION_LENGTH(prop)        \
-  (COMPOSITION_REGISTERD_P (prop)       \
+  (composition_registered_p (prop)      \
    ? XINT (XCAR (XCDR (prop)))          \
    : XINT (XCAR (XCAR (prop))))
 
 /* Return components of the composition.  */
 #define COMPOSITION_COMPONENTS(prop)    \
-  (COMPOSITION_REGISTERD_P (prop)       \
+  (composition_registered_p (prop)      \
    ? XCAR (XCDR (XCDR (prop)))          \
    : XCDR (XCAR (prop)))
 
 /* Return modification function of the composition.  */
 #define COMPOSITION_MODIFICATION_FUNC(prop)     \
-  (COMPOSITION_REGISTERD_P (prop)               \
+  (composition_registered_p (prop)              \
    ? XCDR (XCDR (XCDR (prop)))                  \
    : CONSP (prop) ? XCDR (prop) : Qnil)
 
@@ -199,43 +203,42 @@ extern void syms_of_composite (void);
 extern void compose_text (ptrdiff_t, ptrdiff_t, Lisp_Object, Lisp_Object,
                           Lisp_Object);
 
-/* Return the method of composition.  */
+/* Return the method of a composition with property PROP.  */
+
 COMPOSITE_INLINE enum composition_method
 composition_method (Lisp_Object prop)
 {
-  Lisp_Object temp;
-
-  return (COMPOSITION_REGISTERD_P (prop)
-          ? composition_table[COMPOSITION_ID (prop)]->method
-          : (temp = XCDR (XCAR (prop)),
-             (NILP (temp)
+  if (composition_registered_p (prop))
+    return composition_table[COMPOSITION_ID (prop)]->method;
+  else
+    {
+      Lisp_Object temp = XCDR (XCAR (prop));
+      return (NILP (temp)
               ? COMPOSITION_RELATIVE
-              : (INTEGERP (temp) || STRINGP (temp))
+              : INTEGERP (temp) || STRINGP (temp)
               ? COMPOSITION_WITH_ALTCHARS
-              : COMPOSITION_WITH_RULE_ALTCHARS)));
+              : COMPOSITION_WITH_RULE_ALTCHARS);
+    }
 }
 
-/* Return 1 if the composition is valid.  It is valid if
-   length of the composition equals to (END - START).  */
+/* Given offsets START and END, return true if PROP is a valid composition
+   property with length END - START.  */
+
 COMPOSITE_INLINE bool
 composition_valid_p (ptrdiff_t start, ptrdiff_t end, Lisp_Object prop)
 {
-  Lisp_Object temp;
-
   return (CONSP (prop)
-          && (COMPOSITION_REGISTERD_P (prop)
+          && (composition_registered_p (prop)
               ? (COMPOSITION_ID (prop) >= 0
                  && COMPOSITION_ID (prop) <= n_compositions
                  && CONSP (XCDR (prop)))
-              : (temp = XCAR (prop),
-                 (CONSP (temp)
-                  && (temp = XCDR (temp),
-                      (NILP (temp)
-                       || STRINGP (temp)
-                       || VECTORP (temp)
-                       || INTEGERP (temp)
-                       || CONSP (temp))))))
-          && (end - start) == COMPOSITION_LENGTH (prop));
+              : (CONSP (XCAR (prop))
+                  && (NILP (XCDR (XCAR (prop)))
+                      || STRINGP (XCDR (XCAR (prop)))
+                      || VECTORP (XCDR (XCAR (prop)))
+                      || INTEGERP (XCDR (XCAR (prop)))
+                      || CONSP (XCDR (XCAR (prop))))))
+          && COMPOSITION_LENGTH (prop) == end - start);
 }
 
 /* Macros for lispy glyph-string.  This is completely different from