Mercurial > hg > xemacs-beta

comparison src/charset.h @ 867:804517e16990

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[xemacs-hg @ 2002-06-05 09:54:39 by ben] Textual renaming: text/char names abbrev.c, alloc.c, buffer.c, buffer.h, bytecode.c, callint.c, casefiddle.c, casetab.c, charset.h, chartab.c, chartab.h, cmds.c, console-gtk.h, console-msw.c, console-msw.h, console-stream.c, console-tty.c, console-x.c, console-x.h, console.h, data.c, device-msw.c, device-x.c, dialog-msw.c, dired-msw.c, dired.c, doc.c, doprnt.c, editfns.c, eldap.c, emodules.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-unixoid.c, events.c, events.h, file-coding.c, file-coding.h, fileio.c, filelock.c, fns.c, font-lock.c, frame-gtk.c, frame-msw.c, frame-x.c, frame.c, glyphs-eimage.c, glyphs-msw.c, glyphs-x.c, glyphs.c, glyphs.h, gpmevent.c, gui-x.c, gui-x.h, gui.c, gui.h, hpplay.c, indent.c, insdel.c, insdel.h, intl-win32.c, keymap.c, line-number.c, line-number.h, lisp-disunion.h, lisp-union.h, lisp.h, lread.c, lrecord.h, lstream.c, lstream.h, md5.c, menubar-msw.c, menubar-x.c, menubar.c, minibuf.c, mule-ccl.c, mule-charset.c, mule-coding.c, mule-wnnfns.c, ndir.h, nt.c, objects-gtk.c, objects-gtk.h, objects-msw.c, objects-tty.c, objects-x.c, objects.c, objects.h, postgresql.c, print.c, process-nt.c, process-unix.c, process.c, procimpl.h, realpath.c, redisplay-gtk.c, redisplay-msw.c, redisplay-output.c, redisplay-tty.c, redisplay-x.c, redisplay.c, redisplay.h, regex.c, search.c, select-common.h, select-gtk.c, select-x.c, sound.h, symbols.c, syntax.c, syntax.h, sysdep.c, sysdep.h, sysdir.h, sysfile.h, sysproc.h, syspwd.h, systime.h, syswindows.h, termcap.c, tests.c, text.c, text.h, toolbar-common.c, tooltalk.c, ui-gtk.c, unexnt.c, unicode.c, win32.c: Text/char naming rationalization. [a] distinguish between "charptr" when it refers to operations on the pointer itself and when it refers to operations on text; and [b] use consistent naming for everything referring to internal format, i.e. Itext == text in internal format Ibyte == a byte in such text Ichar == a char as represented in internal character format thus e.g. set_charptr_emchar -> set_itext_ichar The pre and post tags on either side of this change are: pre-internal-format-textual-renaming post-internal-format-textual-renaming See the Internals Manual for details of exactly how this was done, how to handle the change in your workspace, etc.
author ben
date Wed, 05 Jun 2002 09:58:45 +0000
parents 6728e641994e
children 184461bc8de4
comparison
equal deleted inserted replaced
866:613552a02607 867:804517e16990
38 /* used when MULE is not defined, so that Charset-type stuff can still 38 /* used when MULE is not defined, so that Charset-type stuff can still
39 be done */ 39 be done */
40 40
41 #define Vcharset_ascii Qnil 41 #define Vcharset_ascii Qnil
42 42
43 #define emchar_charset(ch) Vcharset_ascii 43 #define ichar_charset(ch) Vcharset_ascii
44 #define emchar_leading_byte(ch) LEADING_BYTE_ASCII 44 #define ichar_leading_byte(ch) LEADING_BYTE_ASCII
45 #define emchar_len(ch) 1 45 #define ichar_len(ch) 1
46 #define emchar_len_fmt(ch, fmt) 1 46 #define ichar_len_fmt(ch, fmt) 1
47 #define LEADING_BYTE_ASCII 0x80 47 #define LEADING_BYTE_ASCII 0x80
48 #define NUM_LEADING_BYTES 1 48 #define NUM_LEADING_BYTES 1
49 #define MIN_LEADING_BYTE 0x80 49 #define MIN_LEADING_BYTE 0x80
50 #define CHARSETP(cs) 1 50 #define CHARSETP(cs) 1
51 #define charset_by_leading_byte(lb) Vcharset_ascii 51 #define charset_by_leading_byte(lb) Vcharset_ascii
52 #define XCHARSET_LEADING_BYTE(cs) LEADING_BYTE_ASCII 52 #define XCHARSET_LEADING_BYTE(cs) LEADING_BYTE_ASCII
53 #define XCHARSET_GRAPHIC(cs) -1 53 #define XCHARSET_GRAPHIC(cs) -1
54 #define XCHARSET_COLUMNS(cs) 1 54 #define XCHARSET_COLUMNS(cs) 1
55 #define XCHARSET_DIMENSION(cs) 1 55 #define XCHARSET_DIMENSION(cs) 1
56 #define BREAKUP_EMCHAR(ch, charset, byte1, byte2) do { \ 56 #define BREAKUP_ICHAR(ch, charset, byte1, byte2) do { \
57 (charset) = Vcharset_ascii; \ 57 (charset) = Vcharset_ascii; \
58 (byte1) = (ch); \ 58 (byte1) = (ch); \
59 (byte2) = 0; \ 59 (byte2) = 0; \
60 } while (0) 60 } while (0)
61 61
157 157
158 /* Is this a prefix for a private leading byte? */ 158 /* Is this a prefix for a private leading byte? */
159 159
160 DECLARE_INLINE_HEADER ( 160 DECLARE_INLINE_HEADER (
161 int 161 int
162 leading_byte_prefix_p (Intbyte lb) 162 leading_byte_prefix_p (Ibyte lb)
163 ) 163 )
164 { 164 {
165 return (lb == PRE_LEADING_BYTE_PRIVATE_1 || 165 return (lb == PRE_LEADING_BYTE_PRIVATE_1 ||
166 lb == PRE_LEADING_BYTE_PRIVATE_2); 166 lb == PRE_LEADING_BYTE_PRIVATE_2);
167 } 167 }
226 int from_unicode_levels; 226 int from_unicode_levels;
227 227
228 unsigned char unicode_table_loaded; 228 unsigned char unicode_table_loaded;
229 229
230 /* Final byte of this character set in ISO2022 designating escape sequence */ 230 /* Final byte of this character set in ISO2022 designating escape sequence */
231 Intbyte final; 231 Ibyte final;
232 232
233 /* Number of bytes (1 - 4) required in the internal representation 233 /* Number of bytes (1 - 4) required in the internal representation
234 for characters in this character set. This is *not* the 234 for characters in this character set. This is *not* the
235 same as the dimension of the character set). */ 235 same as the dimension of the character set). */
236 int rep_bytes; 236 int rep_bytes;
277 #define CHARSET_LEFT_TO_RIGHT 0 277 #define CHARSET_LEFT_TO_RIGHT 0
278 #define CHARSET_RIGHT_TO_LEFT 1 278 #define CHARSET_RIGHT_TO_LEFT 1
279 279
280 /* Leading byte and id have been regrouped. -- OG */ 280 /* Leading byte and id have been regrouped. -- OG */
281 #define CHARSET_ID(cs) ((cs)->id) 281 #define CHARSET_ID(cs) ((cs)->id)
282 #define CHARSET_LEADING_BYTE(cs) ((Intbyte) CHARSET_ID (cs)) 282 #define CHARSET_LEADING_BYTE(cs) ((Ibyte) CHARSET_ID (cs))
283 #define CHARSET_NAME(cs) ((cs)->name) 283 #define CHARSET_NAME(cs) ((cs)->name)
284 #define CHARSET_SHORT_NAME(cs) ((cs)->short_name) 284 #define CHARSET_SHORT_NAME(cs) ((cs)->short_name)
285 #define CHARSET_LONG_NAME(cs) ((cs)->long_name) 285 #define CHARSET_LONG_NAME(cs) ((cs)->long_name)
286 #define CHARSET_REP_BYTES(cs) ((cs)->rep_bytes) 286 #define CHARSET_REP_BYTES(cs) ((cs)->rep_bytes)
287 #define CHARSET_COLUMNS(cs) ((cs)->columns) 287 #define CHARSET_COLUMNS(cs) ((cs)->columns)
333 /* Table of charsets indexed by leading byte. */ 333 /* Table of charsets indexed by leading byte. */
334 Lisp_Object charset_by_leading_byte[NUM_LEADING_BYTES]; 334 Lisp_Object charset_by_leading_byte[NUM_LEADING_BYTES];
335 335
336 /* Table of charsets indexed by type/final-byte/direction. */ 336 /* Table of charsets indexed by type/final-byte/direction. */
337 Lisp_Object charset_by_attributes[4][128][2]; 337 Lisp_Object charset_by_attributes[4][128][2];
338 Intbyte next_allocated_1_byte_leading_byte; 338 Ibyte next_allocated_1_byte_leading_byte;
339 Intbyte next_allocated_2_byte_leading_byte; 339 Ibyte next_allocated_2_byte_leading_byte;
340 }; 340 };
341 341
342 DECLARE_INLINE_HEADER ( 342 DECLARE_INLINE_HEADER (
343 Lisp_Object 343 Lisp_Object
344 charset_by_leading_byte (int lb) 344 charset_by_leading_byte (int lb)
374 /************************************************************************/ 374 /************************************************************************/
375 375
376 /* The bit fields of character are divided into 3 parts: 376 /* The bit fields of character are divided into 3 parts:
377 FIELD1(5bits):FIELD2(7bits):FIELD3(7bits) */ 377 FIELD1(5bits):FIELD2(7bits):FIELD3(7bits) */
378 378
379 #define EMCHAR_FIELD1_MASK (0x1F << 14) 379 #define ICHAR_FIELD1_MASK (0x1F << 14)
380 #define EMCHAR_FIELD2_MASK (0x7F << 7) 380 #define ICHAR_FIELD2_MASK (0x7F << 7)
381 #define EMCHAR_FIELD3_MASK 0x7F 381 #define ICHAR_FIELD3_MASK 0x7F
382 382
383 /* Macros to access each field of a character code of C. */ 383 /* Macros to access each field of a character code of C. */
384 384
385 #define emchar_field1(c) (((c) & EMCHAR_FIELD1_MASK) >> 14) 385 #define ichar_field1(c) (((c) & ICHAR_FIELD1_MASK) >> 14)
386 #define emchar_field2(c) (((c) & EMCHAR_FIELD2_MASK) >> 7) 386 #define ichar_field2(c) (((c) & ICHAR_FIELD2_MASK) >> 7)
387 #define emchar_field3(c) ((c) & EMCHAR_FIELD3_MASK) 387 #define ichar_field3(c) ((c) & ICHAR_FIELD3_MASK)
388 388
389 /* Field 1, if non-zero, usually holds a leading byte for a 389 /* Field 1, if non-zero, usually holds a leading byte for a
390 dimension-2 charset. Field 2, if non-zero, usually holds a leading 390 dimension-2 charset. Field 2, if non-zero, usually holds a leading
391 byte for a dimension-1 charset. */ 391 byte for a dimension-1 charset. */
392 392
398 #define FIELD1_TO_OFFICIAL_LEADING_BYTE (MIN_LEADING_BYTE_OFFICIAL_2 - 1) 398 #define FIELD1_TO_OFFICIAL_LEADING_BYTE (MIN_LEADING_BYTE_OFFICIAL_2 - 1)
399 #define FIELD1_TO_PRIVATE_LEADING_BYTE 0xE1 399 #define FIELD1_TO_PRIVATE_LEADING_BYTE 0xE1
400 400
401 /* Minimum and maximum allowed values for the fields. */ 401 /* Minimum and maximum allowed values for the fields. */
402 402
403 #define MIN_EMCHAR_FIELD2_OFFICIAL \ 403 #define MIN_ICHAR_FIELD2_OFFICIAL \
404 (MIN_LEADING_BYTE_OFFICIAL_1 - FIELD2_TO_OFFICIAL_LEADING_BYTE) 404 (MIN_LEADING_BYTE_OFFICIAL_1 - FIELD2_TO_OFFICIAL_LEADING_BYTE)
405 #define MAX_EMCHAR_FIELD2_OFFICIAL \ 405 #define MAX_ICHAR_FIELD2_OFFICIAL \
406 (MAX_LEADING_BYTE_OFFICIAL_1 - FIELD2_TO_OFFICIAL_LEADING_BYTE) 406 (MAX_LEADING_BYTE_OFFICIAL_1 - FIELD2_TO_OFFICIAL_LEADING_BYTE)
407 407
408 #define MIN_EMCHAR_FIELD1_OFFICIAL \ 408 #define MIN_ICHAR_FIELD1_OFFICIAL \
409 (MIN_LEADING_BYTE_OFFICIAL_2 - FIELD1_TO_OFFICIAL_LEADING_BYTE) 409 (MIN_LEADING_BYTE_OFFICIAL_2 - FIELD1_TO_OFFICIAL_LEADING_BYTE)
410 #define MAX_EMCHAR_FIELD1_OFFICIAL \ 410 #define MAX_ICHAR_FIELD1_OFFICIAL \
411 (MAX_LEADING_BYTE_OFFICIAL_2 - FIELD1_TO_OFFICIAL_LEADING_BYTE) 411 (MAX_LEADING_BYTE_OFFICIAL_2 - FIELD1_TO_OFFICIAL_LEADING_BYTE)
412 412
413 #define MIN_EMCHAR_FIELD2_PRIVATE \ 413 #define MIN_ICHAR_FIELD2_PRIVATE \
414 (MIN_LEADING_BYTE_PRIVATE_1 - FIELD2_TO_PRIVATE_LEADING_BYTE) 414 (MIN_LEADING_BYTE_PRIVATE_1 - FIELD2_TO_PRIVATE_LEADING_BYTE)
415 #define MAX_EMCHAR_FIELD2_PRIVATE \ 415 #define MAX_ICHAR_FIELD2_PRIVATE \
416 (MAX_LEADING_BYTE_PRIVATE_1 - FIELD2_TO_PRIVATE_LEADING_BYTE) 416 (MAX_LEADING_BYTE_PRIVATE_1 - FIELD2_TO_PRIVATE_LEADING_BYTE)
417 417
418 #define MIN_EMCHAR_FIELD1_PRIVATE \ 418 #define MIN_ICHAR_FIELD1_PRIVATE \
419 (MIN_LEADING_BYTE_PRIVATE_2 - FIELD1_TO_PRIVATE_LEADING_BYTE) 419 (MIN_LEADING_BYTE_PRIVATE_2 - FIELD1_TO_PRIVATE_LEADING_BYTE)
420 #define MAX_EMCHAR_FIELD1_PRIVATE \ 420 #define MAX_ICHAR_FIELD1_PRIVATE \
421 (MAX_LEADING_BYTE_PRIVATE_2 - FIELD1_TO_PRIVATE_LEADING_BYTE) 421 (MAX_LEADING_BYTE_PRIVATE_2 - FIELD1_TO_PRIVATE_LEADING_BYTE)
422 422
423 /* Minimum character code of each <type> character. */ 423 /* Minimum character code of each <type> character. */
424 424
425 #define MIN_CHAR_OFFICIAL_TYPE9N (MIN_EMCHAR_FIELD2_OFFICIAL << 7) 425 #define MIN_CHAR_OFFICIAL_TYPE9N (MIN_ICHAR_FIELD2_OFFICIAL << 7)
426 #define MIN_CHAR_PRIVATE_TYPE9N (MIN_EMCHAR_FIELD2_PRIVATE << 7) 426 #define MIN_CHAR_PRIVATE_TYPE9N (MIN_ICHAR_FIELD2_PRIVATE << 7)
427 #define MIN_CHAR_OFFICIAL_TYPE9NX9N (MIN_EMCHAR_FIELD1_OFFICIAL << 14) 427 #define MIN_CHAR_OFFICIAL_TYPE9NX9N (MIN_ICHAR_FIELD1_OFFICIAL << 14)
428 #define MIN_CHAR_PRIVATE_TYPE9NX9N (MIN_EMCHAR_FIELD1_PRIVATE << 14) 428 #define MIN_CHAR_PRIVATE_TYPE9NX9N (MIN_ICHAR_FIELD1_PRIVATE << 14)
429 #define MIN_CHAR_COMPOSITION (0x1F << 14) 429 #define MIN_CHAR_COMPOSITION (0x1F << 14)
430 430
431 /* Leading byte of a character. 431 /* Leading byte of a character.
432 432
433 NOTE: This takes advantage of the fact that 433 NOTE: This takes advantage of the fact that
434 FIELD2_TO_OFFICIAL_LEADING_BYTE and 434 FIELD2_TO_OFFICIAL_LEADING_BYTE and
435 FIELD2_TO_PRIVATE_LEADING_BYTE are the same. 435 FIELD2_TO_PRIVATE_LEADING_BYTE are the same.
436 */ 436 */
437 437
438 DECLARE_INLINE_HEADER ( 438 DECLARE_INLINE_HEADER (
439 Intbyte 439 Ibyte
440 emchar_leading_byte (Emchar c) 440 ichar_leading_byte (Ichar c)
441 ) 441 )
442 { 442 {
443 if (emchar_ascii_p (c)) 443 if (ichar_ascii_p (c))
444 return LEADING_BYTE_ASCII; 444 return LEADING_BYTE_ASCII;
445 else if (c < 0xA0) 445 else if (c < 0xA0)
446 return LEADING_BYTE_CONTROL_1; 446 return LEADING_BYTE_CONTROL_1;
447 else if (c < MIN_CHAR_OFFICIAL_TYPE9NX9N) 447 else if (c < MIN_CHAR_OFFICIAL_TYPE9NX9N)
448 return emchar_field2 (c) + FIELD2_TO_OFFICIAL_LEADING_BYTE; 448 return ichar_field2 (c) + FIELD2_TO_OFFICIAL_LEADING_BYTE;
449 else if (c < MIN_CHAR_PRIVATE_TYPE9NX9N) 449 else if (c < MIN_CHAR_PRIVATE_TYPE9NX9N)
450 return emchar_field1 (c) + FIELD1_TO_OFFICIAL_LEADING_BYTE; 450 return ichar_field1 (c) + FIELD1_TO_OFFICIAL_LEADING_BYTE;
451 else if (c < MIN_CHAR_COMPOSITION) 451 else if (c < MIN_CHAR_COMPOSITION)
452 return emchar_field1 (c) + FIELD1_TO_PRIVATE_LEADING_BYTE; 452 return ichar_field1 (c) + FIELD1_TO_PRIVATE_LEADING_BYTE;
453 else 453 else
454 { 454 {
455 #ifdef ENABLE_COMPOSITE_CHARS 455 #ifdef ENABLE_COMPOSITE_CHARS
456 return LEADING_BYTE_COMPOSITE; 456 return LEADING_BYTE_COMPOSITE;
457 #else 457 #else
461 } 461 }
462 } 462 }
463 463
464 DECLARE_INLINE_HEADER ( 464 DECLARE_INLINE_HEADER (
465 Bytecount 465 Bytecount
466 emchar_len (Emchar c) 466 ichar_len (Ichar c)
467 ) 467 )
468 { 468 {
469 if (emchar_ascii_p (c)) 469 if (ichar_ascii_p (c))
470 return 1; 470 return 1;
471 else if (c < MIN_CHAR_OFFICIAL_TYPE9NX9N) 471 else if (c < MIN_CHAR_OFFICIAL_TYPE9NX9N)
472 return 2; 472 return 2;
473 else if (c < MIN_CHAR_PRIVATE_TYPE9NX9N) 473 else if (c < MIN_CHAR_PRIVATE_TYPE9NX9N)
474 return 3; /* dimension-2 official or dimension-1 private */ 474 return 3; /* dimension-2 official or dimension-1 private */
485 } 485 }
486 } 486 }
487 487
488 DECLARE_INLINE_HEADER ( 488 DECLARE_INLINE_HEADER (
489 Bytecount 489 Bytecount
490 emchar_len_fmt (Emchar c, Internal_Format fmt) 490 ichar_len_fmt (Ichar c, Internal_Format fmt)
491 ) 491 )
492 { 492 {
493 switch (fmt) 493 switch (fmt)
494 { 494 {
495 case FORMAT_DEFAULT: 495 case FORMAT_DEFAULT:
496 return emchar_len (c); 496 return ichar_len (c);
497 case FORMAT_16_BIT_FIXED: 497 case FORMAT_16_BIT_FIXED:
498 return 2; 498 return 2;
499 case FORMAT_32_BIT_FIXED: 499 case FORMAT_32_BIT_FIXED:
500 return 4; 500 return 4;
501 default: 501 default:
502 text_checking_assert (fmt == FORMAT_8_BIT_FIXED); 502 text_checking_assert (fmt == FORMAT_8_BIT_FIXED);
503 return 1; 503 return 1;
504 } 504 }
505 } 505 }
506 506
507 #define emchar_charset(c) charset_by_leading_byte (emchar_leading_byte (c)) 507 #define ichar_charset(c) charset_by_leading_byte (ichar_leading_byte (c))
508 508
509 /* Return a character whose charset is CHARSET and position-codes are C1 509 /* Return a character whose charset is CHARSET and position-codes are C1
510 and C2. TYPE9N character ignores C2. (For typical charsets, i.e. not 510 and C2. TYPE9N character ignores C2. (For typical charsets, i.e. not
511 ASCII, Control-1 or Composite, C1 and C2 will be in the range of 32 to 511 ASCII, Control-1 or Composite, C1 and C2 will be in the range of 32 to
512 127 or 33 to 126. See `make-char'.) 512 127 or 33 to 126. See `make-char'.)
515 FIELD2_TO_OFFICIAL_LEADING_BYTE and 515 FIELD2_TO_OFFICIAL_LEADING_BYTE and
516 FIELD2_TO_PRIVATE_LEADING_BYTE are the same. 516 FIELD2_TO_PRIVATE_LEADING_BYTE are the same.
517 */ 517 */
518 518
519 DECLARE_INLINE_HEADER ( 519 DECLARE_INLINE_HEADER (
520 Emchar 520 Ichar
521 make_emchar (Lisp_Object charset, int c1, int c2) 521 make_ichar (Lisp_Object charset, int c1, int c2)
522 ) 522 )
523 { 523 {
524 Emchar retval; 524 Ichar retval;
525 if (EQ (charset, Vcharset_ascii)) 525 if (EQ (charset, Vcharset_ascii))
526 retval = c1; 526 retval = c1;
527 else if (EQ (charset, Vcharset_control_1)) 527 else if (EQ (charset, Vcharset_control_1))
528 retval = c1 | 0x80; 528 retval = c1 | 0x80;
529 #ifdef ENABLE_COMPOSITE_CHARS 529 #ifdef ENABLE_COMPOSITE_CHARS
537 retval = ((XCHARSET_LEADING_BYTE (charset) - 537 retval = ((XCHARSET_LEADING_BYTE (charset) -
538 FIELD1_TO_OFFICIAL_LEADING_BYTE) << 14) | ((c1) << 7) | (c2); 538 FIELD1_TO_OFFICIAL_LEADING_BYTE) << 14) | ((c1) << 7) | (c2);
539 else 539 else
540 retval = ((XCHARSET_LEADING_BYTE (charset) - 540 retval = ((XCHARSET_LEADING_BYTE (charset) -
541 FIELD1_TO_PRIVATE_LEADING_BYTE) << 14) | ((c1) << 7) | (c2); 541 FIELD1_TO_PRIVATE_LEADING_BYTE) << 14) | ((c1) << 7) | (c2);
542 text_checking_assert (valid_emchar_p (retval)); 542 text_checking_assert (valid_ichar_p (retval));
543 return retval; 543 return retval;
544 } 544 }
545 545
546 /* BREAKUP_EMCHAR_1_UNSAFE assumes that the charset has already been 546 /* BREAKUP_ICHAR_1_UNSAFE assumes that the charset has already been
547 calculated, and just computes c1 and c2. 547 calculated, and just computes c1 and c2.
548 548
549 BREAKUP_EMCHAR also computes and stores the charset. */ 549 BREAKUP_ICHAR also computes and stores the charset. */
550 550
551 #define BREAKUP_EMCHAR_1_UNSAFE(c, charset, c1, c2) \ 551 #define BREAKUP_ICHAR_1_UNSAFE(c, charset, c1, c2) \
552 XCHARSET_DIMENSION (charset) == 1 \ 552 XCHARSET_DIMENSION (charset) == 1 \
553 ? ((c1) = emchar_field3 (c), (c2) = 0) \ 553 ? ((c1) = ichar_field3 (c), (c2) = 0) \
554 : ((c1) = emchar_field2 (c), \ 554 : ((c1) = ichar_field2 (c), \
555 (c2) = emchar_field3 (c)) 555 (c2) = ichar_field3 (c))
556 556
557 DECLARE_INLINE_HEADER ( 557 DECLARE_INLINE_HEADER (
558 void 558 void
559 breakup_emchar_1 (Emchar c, Lisp_Object *charset, int *c1, int *c2) 559 breakup_ichar_1 (Ichar c, Lisp_Object *charset, int *c1, int *c2)
560 ) 560 )
561 { 561 {
562 text_checking_assert (valid_emchar_p (c)); 562 text_checking_assert (valid_ichar_p (c));
563 *charset = emchar_charset (c); 563 *charset = ichar_charset (c);
564 BREAKUP_EMCHAR_1_UNSAFE (c, *charset, *c1, *c2); 564 BREAKUP_ICHAR_1_UNSAFE (c, *charset, *c1, *c2);
565 } 565 }
566 566
567 /* BREAKUP_EMCHAR separates an Emchar into its components. The charset of 567 /* BREAKUP_ICHAR separates an Ichar into its components. The charset of
568 character C is set to CHARSET, and the position-codes of C are set to C1 568 character C is set to CHARSET, and the position-codes of C are set to C1
569 and C2. C2 of TYPE9N character is 0. */ 569 and C2. C2 of TYPE9N character is 0. */
570 570
571 #define BREAKUP_EMCHAR(c, charset, c1, c2) \ 571 #define BREAKUP_ICHAR(c, charset, c1, c2) \
572 breakup_emchar_1 (c, &(charset), &(c1), &(c2)) 572 breakup_ichar_1 (c, &(charset), &(c1), &(c2))
573 573
574 void get_charset_limits (Lisp_Object charset, int *low, int *high); 574 void get_charset_limits (Lisp_Object charset, int *low, int *high);
575 int emchar_to_unicode (Emchar chr); 575 int ichar_to_unicode (Ichar chr);
576 576
577 #endif /* MULE */ 577 #endif /* MULE */
578 578
579 #endif /* INCLUDED_charset_h_ */ 579 #endif /* INCLUDED_charset_h_ */