#include <verify.h>
INLINE_HEADER_BEGIN
-#ifndef CHARACTER_INLINE
-# define CHARACTER_INLINE INLINE
-#endif
/* character code 1st byte byte sequence
-------------- -------- -------------
#define BYTE8_TO_CHAR(byte) ((byte) + 0x3FFF00)
#define UNIBYTE_TO_CHAR(byte) \
- (ASCII_BYTE_P (byte) ? (byte) : BYTE8_TO_CHAR (byte))
+ (ASCII_CHAR_P (byte) ? (byte) : BYTE8_TO_CHAR (byte))
/* Return the raw 8-bit byte for character C. */
-#define CHAR_TO_BYTE8(c) \
- (CHAR_BYTE8_P (c) \
- ? (c) - 0x3FFF00 \
- : multibyte_char_to_unibyte (c))
+#define CHAR_TO_BYTE8(c) (CHAR_BYTE8_P (c) ? (c) - 0x3FFF00 : (c & 0xFF))
/* Return the raw 8-bit byte for character C,
or -1 if C doesn't correspond to a byte. */
-#define CHAR_TO_BYTE_SAFE(c) \
- (CHAR_BYTE8_P (c) \
- ? (c) - 0x3FFF00 \
- : multibyte_char_to_unibyte_safe (c))
+#define CHAR_TO_BYTE_SAFE(c) \
+ (ASCII_CHAR_P (c) ? c : (CHAR_BYTE8_P (c) ? (c) - 0x3FFF00 : -1))
/* Nonzero iff BYTE is the 1st byte of a multibyte form of a character
that corresponds to a raw 8-bit byte. */
do { \
if (! ASCII_CHAR_P (c)) \
c = CHAR_TO_BYTE8 (c); \
- } while (0)
+ } while (false)
/* If C is not ASCII, make it multibyte. Assumes C < 256. */
/* This is the maximum byte length of multibyte form. */
#define MAX_MULTIBYTE_LENGTH 5
-/* Return a Lisp character whose character code is C. Assumes C is
- a valid character code. */
-#define make_char(c) make_number (c)
-
-/* Nonzero iff C is an ASCII byte. */
-#define ASCII_BYTE_P(c) UNSIGNED_CMP (c, <, 0x80)
-
/* Nonzero iff X is a character. */
#define CHARACTERP(x) (NATNUMP (x) && XFASTINT (x) <= MAX_CHAR)
Lisp_Object tmp = XCAR (x); \
CHECK_CHARACTER (tmp); \
XSETCAR ((x), tmp); \
- } while (0)
+ } while (false)
#define CHECK_CHARACTER_CDR(x) \
do { \
Lisp_Object tmp = XCDR (x); \
CHECK_CHARACTER (tmp); \
XSETCDR ((x), tmp); \
- } while (0)
+ } while (false)
/* Nonzero iff C is a character of code less than 0x100. */
#define SINGLE_BYTE_CHAR_P(c) UNSIGNED_CMP (c, <, 0x100)
verify (sizeof (c) <= sizeof (unsigned)); \
(p) += char_string (c, p); \
} \
- } while (0)
+ } while (false)
/* Nonzero iff BYTE starts a non-ASCII character in a multibyte
/* Nonzero iff BYTE starts a character in a multibyte form.
This is equivalent to:
- (ASCII_BYTE_P (byte) || LEADING_CODE_P (byte)) */
+ (ASCII_CHAR_P (byte) || LEADING_CODE_P (byte)) */
#define CHAR_HEAD_P(byte) (((byte) & 0xC0) != 0x80)
/* How many bytes a character that starts with BYTE occupies in a
do { \
if ((p) < (limit)) \
(p) += BYTES_BY_CHAR_HEAD (*(p)); \
- } while (0)
+ } while (false)
/* If P is after LIMIT, advance P to the previous character boundary.
} while (chp >= limit && ! CHAR_HEAD_P (*chp)); \
(p) = (BYTES_BY_CHAR_HEAD (*chp) == (p) - chp) ? chp : (p) - 1; \
} \
- } while (0)
+ } while (false)
/* Return the character code of character whose multibyte form is at
P. Note that this macro unifies CJK characters whose codepoints
BYTEIDX++; \
} \
} \
- while (0)
+ while (false)
/* Like FETCH_STRING_CHAR_ADVANCE, but return a multibyte character
even if STRING is unibyte. */
MAKE_CHAR_MULTIBYTE (OUTPUT); \
} \
} \
- while (0)
+ while (false)
/* Like FETCH_STRING_CHAR_ADVANCE, but assumes STRING is multibyte. */
BYTEIDX += fetch_len; \
CHARIDX++; \
} \
- while (0)
+ while (false)
/* Like FETCH_STRING_CHAR_ADVANCE, but fetch character from the current
BYTEIDX++; \
} \
} \
- while (0)
+ while (false)
/* Like FETCH_CHAR_ADVANCE, but assumes the current buffer is multibyte. */
BYTEIDX += chlen; \
CHARIDX++; \
} \
- while (0)
+ while (false)
/* Increment the buffer byte position POS_BYTE of the current buffer to
do { \
unsigned char *chp = BYTE_POS_ADDR (pos_byte); \
pos_byte += BYTES_BY_CHAR_HEAD (*chp); \
- } while (0)
+ } while (false)
/* Decrement the buffer byte position POS_BYTE of the current buffer to
chp--; \
pos_byte--; \
} \
- } while (0)
+ } while (false)
/* Increment both CHARPOS and BYTEPOS, each in the appropriate way. */
else \
INC_POS ((bytepos)); \
} \
- while (0)
+ while (false)
/* Decrement both CHARPOS and BYTEPOS, each in the appropriate way. */
else \
DEC_POS ((bytepos)); \
} \
- while (0)
+ while (false)
/* Increment the buffer byte position POS_BYTE of the current buffer to
do { \
unsigned char *chp = BUF_BYTE_ADDRESS (buf, pos_byte); \
pos_byte += BYTES_BY_CHAR_HEAD (*chp); \
- } while (0)
+ } while (false)
/* Decrement the buffer byte position POS_BYTE of the current buffer to
chp--; \
pos_byte--; \
} \
- } while (0)
+ } while (false)
/* Return a non-outlandish value for the tab width. */
#define SANE_TAB_WIDTH(buf) \
sanitize_tab_width (XFASTINT (BVAR (buf, tab_width)))
-CHARACTER_INLINE int
+INLINE int
sanitize_tab_width (EMACS_INT width)
{
return 0 < width && width <= 1000 ? width : 8;
/* Return a non-outlandish value for a character width. */
-CHARACTER_INLINE int
+INLINE int
sanitize_char_width (EMACS_INT width)
{
return 0 <= width && width <= 1000 ? width : 1000;
: 0)
/* If C is a high surrogate, return 1. If C is a low surrogate,
- return 0. Otherwise, return 0. */
+ return 2. Otherwise, return 0. */
#define CHAR_SURROGATE_PAIR_P(c) \
((c) < 0xD800 ? 0 \
/* Data type for Unicode general category.
The order of members must be in sync with the 8th element of the
- member of unidata-prop-alist (in admin/unidata/unidata-getn.el) for
+ member of unidata-prop-alist (in admin/unidata/unidata-gen.el) for
Unicode character property `general-category'. */
typedef enum {
const unsigned char **, int *);
extern int translate_char (Lisp_Object, int c);
-extern void parse_str_as_multibyte (const unsigned char *,
- ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
extern ptrdiff_t count_size_as_multibyte (const unsigned char *, ptrdiff_t);
extern ptrdiff_t str_as_multibyte (unsigned char *, ptrdiff_t, ptrdiff_t,
ptrdiff_t *);
extern ptrdiff_t lisp_string_width (Lisp_Object, ptrdiff_t,
ptrdiff_t *, ptrdiff_t *);
-extern Lisp_Object Qcharacterp;
extern Lisp_Object Vchar_unify_table;
extern Lisp_Object string_escape_byte8 (Lisp_Object);
/* Return a translation table of id number ID. */
#define GET_TRANSLATION_TABLE(id) \
- (XCDR(XVECTOR(Vtranslation_table_vector)->contents[(id)]))
+ (XCDR (XVECTOR (Vtranslation_table_vector)->contents[(id)]))
+
+/* Look up the element in char table OBJ at index CH, and return it as
+ an integer. If the element is not a character, return CH itself. */
+
+INLINE int
+char_table_translate (Lisp_Object obj, int ch)
+{
+ /* This internal function is expected to be called with valid arguments,
+ so there is a eassert instead of CHECK_xxx for the sake of speed. */
+ eassert (CHAR_VALID_P (ch));
+ eassert (CHAR_TABLE_P (obj));
+ obj = CHAR_TABLE_REF (obj, ch);
+ return CHARACTERP (obj) ? XINT (obj) : ch;
+}
INLINE_HEADER_END