?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add test for Bug#21454
[emacs.git] / src / character.h
blob2cb76b0f2d535c43c193c3a9d17fe4d8b5d37296
1 /* Header for multibyte character handler.
2 Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
3 Licensed to the Free Software Foundation.
4 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 National Institute of Advanced Industrial Science and Technology (AIST)
6 Registration Number H13PRO009
7
8 This file is part of GNU Emacs.
9
10 GNU Emacs is free software: you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation, either version 3 of the License, or (at
13 your option) any later version.
14
15 GNU Emacs is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
22
23 #ifndef EMACS_CHARACTER_H
24 #define EMACS_CHARACTER_H
25
26 #include <verify.h>
27 #include "lisp.h"
28
29 INLINE_HEADER_BEGIN
30
31 /* character code 1st byte byte sequence
32 -------------- -------- -------------
33 0-7F 00..7F 0xxxxxxx
34 80-7FF C2..DF 110xxxxx 10xxxxxx
35 800-FFFF E0..EF 1110xxxx 10xxxxxx 10xxxxxx
36 10000-1FFFFF F0..F7 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
37 200000-3FFF7F F8 11111000 1000xxxx 10xxxxxx 10xxxxxx 10xxxxxx
38 3FFF80-3FFFFF C0..C1 1100000x 10xxxxxx (for eight-bit-char)
39 400000-... invalid
40
41 invalid 1st byte 80..BF 10xxxxxx
42 F9..FF 11111xxx (xxx != 000)
43 */
44
45 /* Maximum character code ((1 << CHARACTERBITS) - 1). */
46 #define MAX_CHAR 0x3FFFFF
47
48 /* Maximum Unicode character code. */
49 #define MAX_UNICODE_CHAR 0x10FFFF
50
51 /* Maximum N-byte character codes. */
52 #define MAX_1_BYTE_CHAR 0x7F
53 #define MAX_2_BYTE_CHAR 0x7FF
54 #define MAX_3_BYTE_CHAR 0xFFFF
55 #define MAX_4_BYTE_CHAR 0x1FFFFF
56 #define MAX_5_BYTE_CHAR 0x3FFF7F
57
58 /* Minimum leading code of multibyte characters. */
59 #define MIN_MULTIBYTE_LEADING_CODE 0xC0
60 /* Maximum leading code of multibyte characters. */
61 #define MAX_MULTIBYTE_LEADING_CODE 0xF8
62
63 /* Unicode character values. */
64 enum
65 {
66 NO_BREAK_SPACE = 0x00A0,
67 SOFT_HYPHEN = 0x00AD,
68 ZERO_WIDTH_NON_JOINER = 0x200C,
69 ZERO_WIDTH_JOINER = 0x200D,
70 HYPHEN = 0x2010,
71 NON_BREAKING_HYPHEN = 0x2011,
72 LEFT_SINGLE_QUOTATION_MARK = 0x2018,
73 RIGHT_SINGLE_QUOTATION_MARK = 0x2019,
74 PARAGRAPH_SEPARATOR = 0x2029,
75 LEFT_POINTING_ANGLE_BRACKET = 0x2329,
76 RIGHT_POINTING_ANGLE_BRACKET = 0x232A,
77 LEFT_ANGLE_BRACKET = 0x3008,
78 RIGHT_ANGLE_BRACKET = 0x3009,
79 OBJECT_REPLACEMENT_CHARACTER = 0xFFFC,
80 };
81
82 /* UTF-8 encodings. Use \x escapes, so they are portable to pre-C11
83 compilers and can be concatenated with ordinary string literals. */
84 #define uLSQM "\xE2\x80\x98" /* U+2018 LEFT SINGLE QUOTATION MARK */
85 #define uRSQM "\xE2\x80\x99" /* U+2019 RIGHT SINGLE QUOTATION MARK */
86
87 /* Nonzero iff C is a character that corresponds to a raw 8-bit
88 byte. */
89 #define CHAR_BYTE8_P(c) ((c) > MAX_5_BYTE_CHAR)
90
91 /* Return the character code for raw 8-bit byte BYTE. */
92 #define BYTE8_TO_CHAR(byte) ((byte) + 0x3FFF00)
93
94 #define UNIBYTE_TO_CHAR(byte) \
95 (ASCII_CHAR_P (byte) ? (byte) : BYTE8_TO_CHAR (byte))
96
97 /* Return the raw 8-bit byte for character C. */
98 #define CHAR_TO_BYTE8(c) (CHAR_BYTE8_P (c) ? (c) - 0x3FFF00 : (c & 0xFF))
99
100 /* Return the raw 8-bit byte for character C,
101 or -1 if C doesn't correspond to a byte. */
102 #define CHAR_TO_BYTE_SAFE(c) \
103 (ASCII_CHAR_P (c) ? c : (CHAR_BYTE8_P (c) ? (c) - 0x3FFF00 : -1))
104
105 /* Nonzero iff BYTE is the 1st byte of a multibyte form of a character
106 that corresponds to a raw 8-bit byte. */
107 #define CHAR_BYTE8_HEAD_P(byte) ((byte) == 0xC0 || (byte) == 0xC1)
108
109 /* If C is not ASCII, make it unibyte. */
110 #define MAKE_CHAR_UNIBYTE(c) \
111 do { \
112 if (! ASCII_CHAR_P (c)) \
113 c = CHAR_TO_BYTE8 (c); \
114 } while (false)
115
116
117 /* If C is not ASCII, make it multibyte. Assumes C < 256. */
118 #define MAKE_CHAR_MULTIBYTE(c) \
119 (eassert ((c) >= 0 && (c) < 256), (c) = UNIBYTE_TO_CHAR (c))
120
121 /* This is the maximum byte length of multibyte form. */
122 #define MAX_MULTIBYTE_LENGTH 5
123
124 /* Nonzero iff X is a character. */
125 #define CHARACTERP(x) (NATNUMP (x) && XFASTINT (x) <= MAX_CHAR)
126
127 /* Nonzero iff C is valid as a character code. */
128 #define CHAR_VALID_P(c) UNSIGNED_CMP (c, <=, MAX_CHAR)
129
130 /* Check if Lisp object X is a character or not. */
131 #define CHECK_CHARACTER(x) \
132 CHECK_TYPE (CHARACTERP (x), Qcharacterp, x)
133
134 #define CHECK_CHARACTER_CAR(x) \
135 do { \
136 Lisp_Object tmp = XCAR (x); \
137 CHECK_CHARACTER (tmp); \
138 } while (false)
139
140 #define CHECK_CHARACTER_CDR(x) \
141 do { \
142 Lisp_Object tmp = XCDR (x); \
143 CHECK_CHARACTER (tmp); \
144 } while (false)
145
146 /* Nonzero iff C is a character of code less than 0x100. */
147 #define SINGLE_BYTE_CHAR_P(c) UNSIGNED_CMP (c, <, 0x100)
148
149 /* Nonzero if character C has a printable glyph. */
150 #define CHAR_PRINTABLE_P(c) \
151 (((c) >= 32 && (c) < 127) \
152 || ! NILP (CHAR_TABLE_REF (Vprintable_chars, (c))))
153
154 /* Return byte length of multibyte form for character C. */
155 #define CHAR_BYTES(c) \
156 ( (c) <= MAX_1_BYTE_CHAR ? 1 \
157 : (c) <= MAX_2_BYTE_CHAR ? 2 \
158 : (c) <= MAX_3_BYTE_CHAR ? 3 \
159 : (c) <= MAX_4_BYTE_CHAR ? 4 \
160 : (c) <= MAX_5_BYTE_CHAR ? 5 \
161 : 2)
162
163
164 /* Return the leading code of multibyte form of C. */
165 #define CHAR_LEADING_CODE(c) \
166 ((c) <= MAX_1_BYTE_CHAR ? c \
167 : (c) <= MAX_2_BYTE_CHAR ? (0xC0 | ((c) >> 6)) \
168 : (c) <= MAX_3_BYTE_CHAR ? (0xE0 | ((c) >> 12)) \
169 : (c) <= MAX_4_BYTE_CHAR ? (0xF0 | ((c) >> 18)) \
170 : (c) <= MAX_5_BYTE_CHAR ? 0xF8 \
171 : (0xC0 | (((c) >> 6) & 0x01)))
172
173
174 /* Store multibyte form of the character C in P. The caller should
175 allocate at least MAX_MULTIBYTE_LENGTH bytes area at P in advance.
176 Returns the length of the multibyte form. */
177
178 #define CHAR_STRING(c, p) \
179 (UNSIGNED_CMP (c, <=, MAX_1_BYTE_CHAR) \
180 ? ((p)[0] = (c), \
181 1) \
182 : UNSIGNED_CMP (c, <=, MAX_2_BYTE_CHAR) \
183 ? ((p)[0] = (0xC0 | ((c) >> 6)), \
184 (p)[1] = (0x80 | ((c) & 0x3F)), \
185 2) \
186 : UNSIGNED_CMP (c, <=, MAX_3_BYTE_CHAR) \
187 ? ((p)[0] = (0xE0 | ((c) >> 12)), \
188 (p)[1] = (0x80 | (((c) >> 6) & 0x3F)), \
189 (p)[2] = (0x80 | ((c) & 0x3F)), \
190 3) \
191 : verify_expr (sizeof (c) <= sizeof (unsigned), char_string (c, p)))
192
193 /* Store multibyte form of byte B in P. The caller should allocate at
194 least MAX_MULTIBYTE_LENGTH bytes area at P in advance. Returns the
195 length of the multibyte form. */
196
197 #define BYTE8_STRING(b, p) \
198 ((p)[0] = (0xC0 | (((b) >> 6) & 0x01)), \
199 (p)[1] = (0x80 | ((b) & 0x3F)), \
200 2)
201
202
203 /* Store multibyte form of the character C in P and advance P to the
204 end of the multibyte form. The caller should allocate at least
205 MAX_MULTIBYTE_LENGTH bytes area at P in advance. */
206
207 #define CHAR_STRING_ADVANCE(c, p) \
208 do { \
209 if ((c) <= MAX_1_BYTE_CHAR) \
210 *(p)++ = (c); \
211 else if ((c) <= MAX_2_BYTE_CHAR) \
212 *(p)++ = (0xC0 | ((c) >> 6)), \
213 *(p)++ = (0x80 | ((c) & 0x3F)); \
214 else if ((c) <= MAX_3_BYTE_CHAR) \
215 *(p)++ = (0xE0 | ((c) >> 12)), \
216 *(p)++ = (0x80 | (((c) >> 6) & 0x3F)), \
217 *(p)++ = (0x80 | ((c) & 0x3F)); \
218 else \
219 { \
220 verify (sizeof (c) <= sizeof (unsigned)); \
221 (p) += char_string (c, p); \
222 } \
223 } while (false)
224
225
226 /* Nonzero iff BYTE starts a non-ASCII character in a multibyte
227 form. */
228 #define LEADING_CODE_P(byte) (((byte) & 0xC0) == 0xC0)
229
230 /* Nonzero iff BYTE is a trailing code of a non-ASCII character in a
231 multibyte form. */
232 #define TRAILING_CODE_P(byte) (((byte) & 0xC0) == 0x80)
233
234 /* Nonzero iff BYTE starts a character in a multibyte form.
235 This is equivalent to:
236 (ASCII_CHAR_P (byte) || LEADING_CODE_P (byte)) */
237 #define CHAR_HEAD_P(byte) (((byte) & 0xC0) != 0x80)
238
239 /* How many bytes a character that starts with BYTE occupies in a
240 multibyte form. Unlike MULTIBYTE_LENGTH below, this macro does not
241 validate the multibyte form, but looks only at its first byte. */
242 #define BYTES_BY_CHAR_HEAD(byte) \
243 (!((byte) & 0x80) ? 1 \
244 : !((byte) & 0x20) ? 2 \
245 : !((byte) & 0x10) ? 3 \
246 : !((byte) & 0x08) ? 4 \
247 : 5)
248
249
250 /* The byte length of multibyte form at unibyte string P ending at
251 PEND. If the string doesn't point to a valid multibyte form,
252 return 0. Unlike BYTES_BY_CHAR_HEAD, this macro validates the
253 multibyte form. */
254
255 #define MULTIBYTE_LENGTH(p, pend) \
256 (p >= pend ? 0 \
257 : !((p)[0] & 0x80) ? 1 \
258 : ((p + 1 >= pend) || (((p)[1] & 0xC0) != 0x80)) ? 0 \
259 : ((p)[0] & 0xE0) == 0xC0 ? 2 \
260 : ((p + 2 >= pend) || (((p)[2] & 0xC0) != 0x80)) ? 0 \
261 : ((p)[0] & 0xF0) == 0xE0 ? 3 \
262 : ((p + 3 >= pend) || (((p)[3] & 0xC0) != 0x80)) ? 0 \
263 : ((p)[0] & 0xF8) == 0xF0 ? 4 \
264 : ((p + 4 >= pend) || (((p)[4] & 0xC0) != 0x80)) ? 0 \
265 : (p)[0] == 0xF8 && ((p)[1] & 0xF0) == 0x80 ? 5 \
266 : 0)
267
268
269 /* Like MULTIBYTE_LENGTH, but don't check the ending address. The
270 multibyte form is still validated, unlike BYTES_BY_CHAR_HEAD. */
271
272 #define MULTIBYTE_LENGTH_NO_CHECK(p) \
273 (!((p)[0] & 0x80) ? 1 \
274 : ((p)[1] & 0xC0) != 0x80 ? 0 \
275 : ((p)[0] & 0xE0) == 0xC0 ? 2 \
276 : ((p)[2] & 0xC0) != 0x80 ? 0 \
277 : ((p)[0] & 0xF0) == 0xE0 ? 3 \
278 : ((p)[3] & 0xC0) != 0x80 ? 0 \
279 : ((p)[0] & 0xF8) == 0xF0 ? 4 \
280 : ((p)[4] & 0xC0) != 0x80 ? 0 \
281 : (p)[0] == 0xF8 && ((p)[1] & 0xF0) == 0x80 ? 5 \
282 : 0)
283
284 /* If P is before LIMIT, advance P to the next character boundary.
285 Assumes that P is already at a character boundary of the same
286 multibyte form whose end address is LIMIT. */
287
288 #define NEXT_CHAR_BOUNDARY(p, limit) \
289 do { \
290 if ((p) < (limit)) \
291 (p) += BYTES_BY_CHAR_HEAD (*(p)); \
292 } while (false)
293
294
295 /* If P is after LIMIT, advance P to the previous character boundary.
296 Assumes that P is already at a character boundary of the same
297 multibyte form whose beginning address is LIMIT. */
298
299 #define PREV_CHAR_BOUNDARY(p, limit) \
300 do { \
301 if ((p) > (limit)) \
302 { \
303 const unsigned char *chp = (p); \
304 do { \
305 chp--; \
306 } while (chp >= limit && ! CHAR_HEAD_P (*chp)); \
307 (p) = (BYTES_BY_CHAR_HEAD (*chp) == (p) - chp) ? chp : (p) - 1; \
308 } \
309 } while (false)
310
311 /* Return the character code of character whose multibyte form is at P. */
312
313 #define STRING_CHAR(p) \
314 (!((p)[0] & 0x80) \
315 ? (p)[0] \
316 : ! ((p)[0] & 0x20) \
317 ? (((((p)[0] & 0x1F) << 6) \
318 | ((p)[1] & 0x3F)) \
319 + (((unsigned char) (p)[0]) < 0xC2 ? 0x3FFF80 : 0)) \
320 : ! ((p)[0] & 0x10) \
321 ? ((((p)[0] & 0x0F) << 12) \
322 | (((p)[1] & 0x3F) << 6) \
323 | ((p)[2] & 0x3F)) \
324 : string_char ((p), NULL, NULL))
325
326
327 /* Like STRING_CHAR, but set ACTUAL_LEN to the length of multibyte
328 form. */
329
330 #define STRING_CHAR_AND_LENGTH(p, actual_len) \
331 (!((p)[0] & 0x80) \
332 ? ((actual_len) = 1, (p)[0]) \
333 : ! ((p)[0] & 0x20) \
334 ? ((actual_len) = 2, \
335 (((((p)[0] & 0x1F) << 6) \
336 | ((p)[1] & 0x3F)) \
337 + (((unsigned char) (p)[0]) < 0xC2 ? 0x3FFF80 : 0))) \
338 : ! ((p)[0] & 0x10) \
339 ? ((actual_len) = 3, \
340 ((((p)[0] & 0x0F) << 12) \
341 | (((p)[1] & 0x3F) << 6) \
342 | ((p)[2] & 0x3F))) \
343 : string_char ((p), NULL, &actual_len))
344
345
346 /* Like STRING_CHAR, but advance P to the end of multibyte form. */
347
348 #define STRING_CHAR_ADVANCE(p) \
349 (!((p)[0] & 0x80) \
350 ? *(p)++ \
351 : ! ((p)[0] & 0x20) \
352 ? ((p) += 2, \
353 ((((p)[-2] & 0x1F) << 6) \
354 | ((p)[-1] & 0x3F) \
355 | ((unsigned char) ((p)[-2]) < 0xC2 ? 0x3FFF80 : 0))) \
356 : ! ((p)[0] & 0x10) \
357 ? ((p) += 3, \
358 ((((p)[-3] & 0x0F) << 12) \
359 | (((p)[-2] & 0x3F) << 6) \
360 | ((p)[-1] & 0x3F))) \
361 : string_char ((p), &(p), NULL))
362
363
364 /* Fetch the "next" character from Lisp string STRING at byte position
365 BYTEIDX, character position CHARIDX. Store it into OUTPUT.
366
367 All the args must be side-effect-free.
368 BYTEIDX and CHARIDX must be lvalues;
369 we increment them past the character fetched. */
370
371 #define FETCH_STRING_CHAR_ADVANCE(OUTPUT, STRING, CHARIDX, BYTEIDX) \
372 do \
373 { \
374 CHARIDX++; \
375 if (STRING_MULTIBYTE (STRING)) \
376 { \
377 unsigned char *chp = &SDATA (STRING)[BYTEIDX]; \
378 int chlen; \
379 \
380 OUTPUT = STRING_CHAR_AND_LENGTH (chp, chlen); \
381 BYTEIDX += chlen; \
382 } \
383 else \
384 { \
385 OUTPUT = SREF (STRING, BYTEIDX); \
386 BYTEIDX++; \
387 } \
388 } \
389 while (false)
390
391 /* Like FETCH_STRING_CHAR_ADVANCE, but return a multibyte character
392 even if STRING is unibyte. */
393
394 #define FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE(OUTPUT, STRING, CHARIDX, BYTEIDX) \
395 do \
396 { \
397 CHARIDX++; \
398 if (STRING_MULTIBYTE (STRING)) \
399 { \
400 unsigned char *chp = &SDATA (STRING)[BYTEIDX]; \
401 int chlen; \
402 \
403 OUTPUT = STRING_CHAR_AND_LENGTH (chp, chlen); \
404 BYTEIDX += chlen; \
405 } \
406 else \
407 { \
408 OUTPUT = SREF (STRING, BYTEIDX); \
409 BYTEIDX++; \
410 MAKE_CHAR_MULTIBYTE (OUTPUT); \
411 } \
412 } \
413 while (false)
414
415
416 /* Like FETCH_STRING_CHAR_ADVANCE, but assumes STRING is multibyte. */
417
418 #define FETCH_STRING_CHAR_ADVANCE_NO_CHECK(OUTPUT, STRING, CHARIDX, BYTEIDX) \
419 do \
420 { \
421 unsigned char *fetch_ptr = &SDATA (STRING)[BYTEIDX]; \
422 int fetch_len; \
423 \
424 OUTPUT = STRING_CHAR_AND_LENGTH (fetch_ptr, fetch_len); \
425 BYTEIDX += fetch_len; \
426 CHARIDX++; \
427 } \
428 while (false)
429
430
431 /* Like FETCH_STRING_CHAR_ADVANCE, but fetch character from the current
432 buffer. */
433
434 #define FETCH_CHAR_ADVANCE(OUTPUT, CHARIDX, BYTEIDX) \
435 do \
436 { \
437 CHARIDX++; \
438 if (!NILP (BVAR (current_buffer, enable_multibyte_characters))) \
439 { \
440 unsigned char *chp = BYTE_POS_ADDR (BYTEIDX); \
441 int chlen; \
442 \
443 OUTPUT = STRING_CHAR_AND_LENGTH (chp, chlen); \
444 BYTEIDX += chlen; \
445 } \
446 else \
447 { \
448 OUTPUT = *(BYTE_POS_ADDR (BYTEIDX)); \
449 BYTEIDX++; \
450 } \
451 } \
452 while (false)
453
454
455 /* Like FETCH_CHAR_ADVANCE, but assumes the current buffer is multibyte. */
456
457 #define FETCH_CHAR_ADVANCE_NO_CHECK(OUTPUT, CHARIDX, BYTEIDX) \
458 do \
459 { \
460 unsigned char *chp = BYTE_POS_ADDR (BYTEIDX); \
461 int chlen; \
462 \
463 OUTPUT = STRING_CHAR_AND_LENGTH (chp, chlen); \
464 BYTEIDX += chlen; \
465 CHARIDX++; \
466 } \
467 while (false)
468
469
470 /* Increment the buffer byte position POS_BYTE of the current buffer to
471 the next character boundary. No range checking of POS. */
472
473 #define INC_POS(pos_byte) \
474 do { \
475 unsigned char *chp = BYTE_POS_ADDR (pos_byte); \
476 pos_byte += BYTES_BY_CHAR_HEAD (*chp); \
477 } while (false)
478
479
480 /* Decrement the buffer byte position POS_BYTE of the current buffer to
481 the previous character boundary. No range checking of POS. */
482
483 #define DEC_POS(pos_byte) \
484 do { \
485 unsigned char *chp; \
486 \
487 pos_byte--; \
488 if (pos_byte < GPT_BYTE) \
489 chp = BEG_ADDR + pos_byte - BEG_BYTE; \
490 else \
491 chp = BEG_ADDR + GAP_SIZE + pos_byte - BEG_BYTE; \
492 while (!CHAR_HEAD_P (*chp)) \
493 { \
494 chp--; \
495 pos_byte--; \
496 } \
497 } while (false)
498
499 /* Increment both CHARPOS and BYTEPOS, each in the appropriate way. */
500
501 #define INC_BOTH(charpos, bytepos) \
502 do \
503 { \
504 (charpos)++; \
505 if (NILP (BVAR (current_buffer, enable_multibyte_characters))) \
506 (bytepos)++; \
507 else \
508 INC_POS ((bytepos)); \
509 } \
510 while (false)
511
512
513 /* Decrement both CHARPOS and BYTEPOS, each in the appropriate way. */
514
515 #define DEC_BOTH(charpos, bytepos) \
516 do \
517 { \
518 (charpos)--; \
519 if (NILP (BVAR (current_buffer, enable_multibyte_characters))) \
520 (bytepos)--; \
521 else \
522 DEC_POS ((bytepos)); \
523 } \
524 while (false)
525
526
527 /* Increment the buffer byte position POS_BYTE of the current buffer to
528 the next character boundary. This macro relies on the fact that
529 *GPT_ADDR and *Z_ADDR are always accessible and the values are
530 '\0'. No range checking of POS_BYTE. */
531
532 #define BUF_INC_POS(buf, pos_byte) \
533 do { \
534 unsigned char *chp = BUF_BYTE_ADDRESS (buf, pos_byte); \
535 pos_byte += BYTES_BY_CHAR_HEAD (*chp); \
536 } while (false)
537
538
539 /* Decrement the buffer byte position POS_BYTE of the current buffer to
540 the previous character boundary. No range checking of POS_BYTE. */
541
542 #define BUF_DEC_POS(buf, pos_byte) \
543 do { \
544 unsigned char *chp; \
545 pos_byte--; \
546 if (pos_byte < BUF_GPT_BYTE (buf)) \
547 chp = BUF_BEG_ADDR (buf) + pos_byte - BEG_BYTE; \
548 else \
549 chp = BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + pos_byte - BEG_BYTE;\
550 while (!CHAR_HEAD_P (*chp)) \
551 { \
552 chp--; \
553 pos_byte--; \
554 } \
555 } while (false)
556
557
558 /* Return a non-outlandish value for the tab width. */
559
560 #define SANE_TAB_WIDTH(buf) \
561 sanitize_tab_width (XFASTINT (BVAR (buf, tab_width)))
562 INLINE int
563 sanitize_tab_width (EMACS_INT width)
564 {
565 return 0 < width && width <= 1000 ? width : 8;
566 }
567
568 /* Return the width of ASCII character C. The width is measured by
569 how many columns C will occupy on the screen when displayed in the
570 current buffer. */
571
572 #define ASCII_CHAR_WIDTH(c) \
573 (c < 0x20 \
574 ? (c == '\t' \
575 ? SANE_TAB_WIDTH (current_buffer) \
576 : (c == '\n' ? 0 : (NILP (BVAR (current_buffer, ctl_arrow)) ? 4 : 2))) \
577 : (c < 0x7f \
578 ? 1 \
579 : ((NILP (BVAR (current_buffer, ctl_arrow)) ? 4 : 2))))
580
581 /* Return a non-outlandish value for a character width. */
582
583 INLINE int
584 sanitize_char_width (EMACS_INT width)
585 {
586 return 0 <= width && width <= 1000 ? width : 1000;
587 }
588
589 /* Return the width of character C. The width is measured by how many
590 columns C will occupy on the screen when displayed in the current
591 buffer. */
592
593 #define CHAR_WIDTH(c) \
594 (ASCII_CHAR_P (c) \
595 ? ASCII_CHAR_WIDTH (c) \
596 : sanitize_char_width (XINT (CHAR_TABLE_REF (Vchar_width_table, c))))
597
598 /* If C is a variation selector, return the index of the
599 variation selector (1..256). Otherwise, return 0. */
600
601 #define CHAR_VARIATION_SELECTOR_P(c) \
602 ((c) < 0xFE00 ? 0 \
603 : (c) <= 0xFE0F ? (c) - 0xFE00 + 1 \
604 : (c) < 0xE0100 ? 0 \
605 : (c) <= 0xE01EF ? (c) - 0xE0100 + 17 \
606 : 0)
607
608 /* Return true if C is a surrogate. */
609
610 INLINE bool
611 char_surrogate_p (int c)
612 {
613 return 0xD800 <= c && c <= 0xDFFF;
614 }
615
616 /* Data type for Unicode general category.
617
618 The order of members must be in sync with the 8th element of the
619 member of unidata-prop-alist (in admin/unidata/unidata-gen.el) for
620 Unicode character property `general-category'. */
621
622 typedef enum {
623 UNICODE_CATEGORY_UNKNOWN = 0,
624 UNICODE_CATEGORY_Lu,
625 UNICODE_CATEGORY_Ll,
626 UNICODE_CATEGORY_Lt,
627 UNICODE_CATEGORY_Lm,
628 UNICODE_CATEGORY_Lo,
629 UNICODE_CATEGORY_Mn,
630 UNICODE_CATEGORY_Mc,
631 UNICODE_CATEGORY_Me,
632 UNICODE_CATEGORY_Nd,
633 UNICODE_CATEGORY_Nl,
634 UNICODE_CATEGORY_No,
635 UNICODE_CATEGORY_Pc,
636 UNICODE_CATEGORY_Pd,
637 UNICODE_CATEGORY_Ps,
638 UNICODE_CATEGORY_Pe,
639 UNICODE_CATEGORY_Pi,
640 UNICODE_CATEGORY_Pf,
641 UNICODE_CATEGORY_Po,
642 UNICODE_CATEGORY_Sm,
643 UNICODE_CATEGORY_Sc,
644 UNICODE_CATEGORY_Sk,
645 UNICODE_CATEGORY_So,
646 UNICODE_CATEGORY_Zs,
647 UNICODE_CATEGORY_Zl,
648 UNICODE_CATEGORY_Zp,
649 UNICODE_CATEGORY_Cc,
650 UNICODE_CATEGORY_Cf,
651 UNICODE_CATEGORY_Cs,
652 UNICODE_CATEGORY_Co,
653 UNICODE_CATEGORY_Cn
654 } unicode_category_t;
655
656 extern EMACS_INT char_resolve_modifier_mask (EMACS_INT) ATTRIBUTE_CONST;
657 extern int char_string (unsigned, unsigned char *);
658 extern int string_char (const unsigned char *,
659 const unsigned char **, int *);
660
661 extern int translate_char (Lisp_Object, int c);
662 extern ptrdiff_t count_size_as_multibyte (const unsigned char *, ptrdiff_t);
663 extern ptrdiff_t str_as_multibyte (unsigned char *, ptrdiff_t, ptrdiff_t,
664 ptrdiff_t *);
665 extern ptrdiff_t str_to_multibyte (unsigned char *, ptrdiff_t, ptrdiff_t);
666 extern ptrdiff_t str_as_unibyte (unsigned char *, ptrdiff_t);
667 extern ptrdiff_t str_to_unibyte (const unsigned char *, unsigned char *,
668 ptrdiff_t);
669 extern ptrdiff_t strwidth (const char *, ptrdiff_t);
670 extern ptrdiff_t c_string_width (const unsigned char *, ptrdiff_t, int,
671 ptrdiff_t *, ptrdiff_t *);
672 extern ptrdiff_t lisp_string_width (Lisp_Object, ptrdiff_t,
673 ptrdiff_t *, ptrdiff_t *);
674
675 extern Lisp_Object Vchar_unify_table;
676 extern Lisp_Object string_escape_byte8 (Lisp_Object);
677
678 extern bool alphabeticp (int);
679 extern bool alphanumericp (int);
680 extern bool graphicp (int);
681 extern bool printablep (int);
682
683 /* Return a translation table of id number ID. */
684 #define GET_TRANSLATION_TABLE(id) \
685 (XCDR (XVECTOR (Vtranslation_table_vector)->contents[(id)]))
686
687 /* Look up the element in char table OBJ at index CH, and return it as
688 an integer. If the element is not a character, return CH itself. */
689
690 INLINE int
691 char_table_translate (Lisp_Object obj, int ch)
692 {
693 /* This internal function is expected to be called with valid arguments,
694 so there is a eassert instead of CHECK_xxx for the sake of speed. */
695 eassert (CHAR_VALID_P (ch));
696 eassert (CHAR_TABLE_P (obj));
697 obj = CHAR_TABLE_REF (obj, ch);
698 return CHARACTERP (obj) ? XINT (obj) : ch;
699 }
700
701 INLINE_HEADER_END
702
703 #endif /* EMACS_CHARACTER_H */
Emacs repository mirror